Robotrontechnik-Forum

Registrieren || Einloggen || Hilfe/FAQ || Suche || Mitglieder || Home || Statistik || Kalender || Admins Willkommen Gast! RSS

Robotrontechnik-Forum » Technische Diskussionen » Programmerstellung mit dem C-Compiler z88dk » Themenansicht

Autor Thread - Seiten: -1-
000
11.10.2018, 17:00 Uhr
RobertK

Avatar von RobertK

Hier nun wie versprochen eine kurze Anleitung, wie man mit dem z88dk-Compiler sein erstes kompiliertes C-Programm für einen Robotron-Computer erzeugen kann.

1. Man lädt den aktuellen "Nightly Build" herunter, und zwar von http://www.z88dk.org/ -> links auf "Nightly builds/snapshots" -> oben auf z88dk-win32-latest.zip (oder auf die osx-Version für die stolzen Apple-Besitzer :-)).
Den "Last Stable Release" würde ich nicht empfehlen, da seit damals zahlreiche Verbesserungen - auch bei den Robotron-Targets - erfolgt sind.

2. Diese Zip-Datei entpackt man irgendwo auf die Festplatte des Rechners. Bei mir liegt das z88dk-Verzeichnis auf C:\Misc\z88dk\

3. Nun macht man irgendwo auf der Platte ein neues Verzeichnis, wo man seine eigenen Programme erstellen möchte. Bei mir ist das C:\Projekte\z88dk\

4. Dort erzeugt man eine neue Textdatei namens HalloWelt.c mit folgendem Inhalt:


Quellcode:

void main()
{
  printf("\n\n\n\nHallo Welt!\n\n\n");
  printf("Taste druecken zum Beenden...\n");
  fgetc_cons();    // warte auf irgendeinen Tastendruck      
}


Hinweis: das Editieren der Dateien funktioniert zwar schon auch mit dem Windows-Notepad, ich empfehle aber, sich gleich mit dem Notepad++ https://notepad-plus-plus.org/ anzufreunden und diesen zu verwenden - der hat auch keine Probleme mit den unterschiedlichen Arten von Zeilenumbrüchen.

5. Zum Kompilieren (erst mal für den Z1013) erzeugt man eine Batch-Datei. Man erstellt dazu eine neue Textdatei namens compile_HalloWelt_Z1013.bat mit folgendem Inhalt:


Quellcode:

setlocal
rem Set your z88dk root path here
set z88root=C:\Misc\z88dk\

set path=%PATH%;%z88root%bin\
set zcccfg=%z88root%lib\config\
set z80_ozfiles=%z88root%lib\

zcc +z1013 -create-app -o HalloWelt_Z1013 HalloWelt.c

endlocal

rem pause


Das z88root-Verzeichnis muss man entsprechend anpassen - je nachdem, wohin man den z88dk entpackt hat.

Und für die beiden anderen Zielsysteme kopiert man die Datei 2x und bennent sie compile_HalloWelt_KC85_2-5.bat sowie compile_HalloWelt_Z9001.bat, und die Zeile mit dem zcc-Aufruf bessert man wie folgt aus:

zcc +kc -lndos -create-app -o HalloWelt_KC85_2-5 HalloWelt.c
bzw.
zcc +z9001 -create-app -o HalloWelt_Z9001 HalloWelt.c

6. Das Kompilieren könnte man nun theoretisch mittels Doppelklick auf die Batch-Datei im Windows-Explorer starten (dann sollte man aber in der letzten Zeile "rem pause" auf "pause" ändern, damit das Fenster mit den Compilermeldungen sichtbar bleibt). Praktischer finde ich es aber, das in der Eingabeaufforderung aufzurufen. So kann man später jederzeit mit "Pfeil auf" und "Enter" erneut kompilieren.

7. Wenn der Compiler keine Fehlermeldungen geliefert hat, kann man nun das erstellte Programm im Emulator (ich verwende jkcemu-0.9.7.jar, sowie j1013-2.2.jar für den Z1013) ausprobieren. Beim Z1013 startet man die .Z80-Datei, beim Z9001 die TAP-Datei, und beim KC 85/2 bis /5 die .KCC-Datei.

Das war's mal für den Anfang, das sollte eigentlich jeder schaffen. :-)
Bei Unklarheiten bitte einfach hier fragen.

Dieser Beitrag wurde am 11.10.2018 um 17:03 Uhr von RobertK editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
001
13.10.2018, 11:50 Uhr
Bert



Hallo RobertK,

das funktioniert alles soweit wie beschrieben, Danke dafür!

Folgendes gilt nur für die KC85/3-5. Die Bibliotheken von z88dk greifen (momentan) ganz schön tief ins System ein:

1. einige Interrupts werden umgebogen:
01E4 PIO channel A (cassette input)
01E6 PIO channel B (keyboard input)
01EA CTC channel 1 (cassette output)
01EC CTC channel 2 (sound duration)
01EE CTC channel 3 (keyboard input)

andere nicht:
01D4..01E1 free for user
01E2 SIO channel B (if V24 module installed)
01E8 CTC channel 0 (free)
Das ist der Tatsache geschuldet, das CAOS und die z88dk-Bibliotheken auf das IX-Register angewiesen sind.

Problematisch sehe ich hier, das die Interruptvektoren nicht wieder zurückgebogen werden.

2. von code_crt_init wird der Cursor ausgeschaltet, aber nicht wieder an

3. die verwendete CAOS-Version wird über UP PADR ermittelt. Schräg, aber ok

4. Es wird eine eigene Schriftart (vom ZX Spektrum?) mitgebracht. Warum das denn?
Ich kann auch auf die Schnelle nicht erkennen, wo und ob man das abschalten kann.
Dazu gibt es eigene Zeichenroutinen mit Zugriff auf IX+1 und Port 84h (statt die vom CAOS zu verwenden).

5. Außerdem wird bei mir (Testsystem JKCEMU 0.9.7 KC85/4), der Bildschirmmodus beim Verlassen nicht korrekt zurückgesetzt.

So, das war es, was mir in der Schnelle aufgefallen ist...

Viele Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
002
13.10.2018, 20:51 Uhr
RobertK

Avatar von RobertK

Hallo Bert,

danke für die umfangreiche Analyse, die mein technisches Verständnis tw. übersteigt - für mich zählt immer nur das Ergebnis. :-)

ad 4. Das gehört zum Thema "Konsolen", auf das ich im nächsten Teil meines Tutorials eingehen wollte.
Dieses kleine Testprogramm verwendet die Standard-Konsole ("Native Console"), bei der man grundsätzlich nur Text fortlaufend ausgeben kann. Üblicherweise - so auch bei Z1013 und Z9001 - wird dabei der Standard-Font des Systems verwendet. Bei KC85/2-5 war das Implementieren der Konsolenausgabe allerdings derart kompliziert, dass der Entwickler (er heißt "Dom") das irgendwie "zu Fuß" machen musste, und in so einem Fall verwendet er standardmäßig immer den Spectrum-Font.
Man kann aber mittels -pragma-redirect:CRT_FONT=... einen anderen der vordefinierten Fonts verwenden (siehe bei https://github.com/z88dk/z88dk/wiki/Classic-GenericConsole die drei Screenshots im Bereich "Defining a custom font"). Mit diesem Befehl wird z.B. der BBC-Font verwendet:
zcc +kc -lndos -create-app -pragma-redirect:CRT_FONT=_font_8x8_bbc_system -o HalloWelt_KC85_2-5 HalloWelt.c

Hier ein Vergleich der beiden Fonts (oben Spectrum, unten BBC):


Und es kommt noch besser: man kann den Font des Systems in eine .fon-Datei exportieren und diesen verwenden, davon habe ich bei meinem Spiel in der Version für den Camputers Lynx Gebrauch gemacht. Siehe dazu die Datei compile_htron_CamputersLynx.bat, Dom hat mir dazu den Font dieses Systems in die Datei lynx3.fon exportiert (und nachbearbeitet, damit die Zeichen in 8x8 dargestellt werden können). Allerdings sind die Zeichenabstände bei der Konsolenausgabe etwas größer, wodurch es leider nicht ganz so gut aussieht wie am Original-System (siehe htron_CamputersLynx_StandardConsole.tap).

Theoretisch könntest du daher den KC-Font im gleichen Format wie lynx3.fon exportieren - leider habe ich keine Ahnung, was das für ein Dateiformat ist, aber bei Bedarf könnte ich bei Dom nachfragen.


ad 5. Danke für den Hinweis, ich hatte noch gar nicht gemerkt, dass das Problem auch mein Spiel betrifft. Bei manchen Systemen muss das Programm beim Beenden selbst in den Standard-Bildschirmmodus zurückschalten. Beim MC-1000 habe ich das versucht, doch dort hat das leider nie funktioniert. Ich muss mal forschen, ob man da beim KC irgendwas machen kann.

Dieser Beitrag wurde am 13.10.2018 um 20:53 Uhr von RobertK editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
003
18.10.2018, 10:56 Uhr
RobertK

Avatar von RobertK

Teil 2: Konsolen

Für die Ein- und Ausgabe (via Tastatur und Bildschirm) stellt z88dk je nach Target bis zu drei verschiedene "Konsolen"-Varianten zur Auswahl: "Native Console", "VT100 (ANSI)" und "Generic Console". In der Target-Liste
https://github.com/z88dk/z88dk/wiki/Platform
kann man nachsehen, welche Varianten bei den jeweiligen Targets unterstützt werden. Vorneweg: VT100 oder Generic Console sind sehr praktisch zu verwenden, die native Konsole ist eher mühsam, und mit Targets ohne irgendeine Konsolenunterstützung kann man ziemlich wenig anfangen.
Glücklicherweise sind die Robotron-Targets hier gut ausgestattet, die generische Konsole wird von allen dreien unterstützt.

Wie schon erwähnt verwendet das oben gezeigte Testprogramm für die Bildschirmanzeige die standarmäßige "Native Konsole". Damit kann man grundsätzlich nur Text fortlaufend (scrollend) ausgeben. Möchte man z.B. den Bildschirm löschen oder den Cursor an eine bestimmte Stelle positionieren, so kann man das nur mittels Ausgabe der entsprechenden Steuerzeichen erreichen. Bei meinem Spiel H-Tron habe ich beim Osborne 1-Target davon Gebrauch gemacht (mangels anderer Konsole).

Praktischer ist da die "VT100 (ANSI)"-Konsole:
https://www.z88dk.org/wiki/doku.php?id=library:conio
Hierzu muss man conio.h inkludieren und hat dann die Kompatibilität zu dieser Library aus DOS-Zeiten, was das Portieren von bestehenden MS-DOS-Programmen auf Z80-Targets erleichtert. Das Positionieren von Text kann dann einheitlich mittels gotoxy() erfolgen, und für die Tastatureingabe kann man kbhit() und getch() verwenden.

Und genauso funktioniert auch die "Generische Konsole":
https://github.com/z88dk/z88dk/wiki/Classic-GenericConsole
Hier kann man die selben Funktionen wie bei VT100 verwenden, jedoch muss man conio.h dazu nicht einbinden.

Wenn man eine der zwei letztgenannten Varianten verwenden möchte, muss man dies beim Kompilieren als Parameter angeben (wobei bei manchen Targets ohne Parameter eine der drei Konsolen als Default verwendet wird, was natürlich ein wenig verwirrend ist).

Wir erweitern nun unser Testprogramm, damit es den Text mittels der Generischen Konsole an eine bestimmte Position am Bildschirm ausgibt. Wir erstellen dazu eine Textdatei namens HalloWelt2.c:


Quellcode:
void main()
{
  // Bildschirm löschen
  printf("%c",12);
  printf("\x0c");  // "\x0c" (Zeichen 0x0c) positioniert den Cursor in die linke obere Ecke
  
  gotoxy(3,10); // Cursor in die 3. Spalte und 10. Zeile positionieren
  printf("Hallo Welt!");
  gotoxy(3,18); // Cursor in die 3. Spalte und 18. Zeile positionieren
  printf("Taste druecken zum Beenden...");
  while (!kbhit()); // warte auf irgendeinen Tastendruck - hier könnte man natürlich auch fgetc_cons() verwenden

  // Bildschirm löschen
  printf("%c",12);
  printf("\x0c");  // "\x0c" (Zeichen 0x0c) positioniert den Cursor in die linke obere Ecke
}



Und in den Batch-Dateien für das Kompilieren geben wir den Konsolen-Parameter an:


Quellcode:
zcc +z1013 -create-app -pragma-redirect:fputc_cons=fputc_cons_generic -o HalloWelt2_Z1013 HalloWelt2.c
zcc +z9001 -create-app -pragma-redirect:fputc_cons=fputc_cons_generic -o HalloWelt2_Z9001 HalloWelt2.c
zcc +kc -lndos -create-app -pragma-redirect:fputc_cons=fputc_cons_generic -o HalloWelt2_KC85_2-5 HalloWelt2.c


Soviel zu diesem Thema, soweit *ich* es verstanden habe - das Thema ist ein wenig verwirrend, und möglicherweise habe ich in obiger Beschreibung den einen oder anderen Fehler drinnen, bitte dies zu verzeihen.

Als dritten Teil meines Tutorials könnte ich euch noch kurz die Grafikausgabe mittels plot() erklären.

Dieser Beitrag wurde am 18.10.2018 um 11:00 Uhr von RobertK editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
004
28.11.2018, 17:51 Uhr
RobertK

Avatar von RobertK

Teil 3: Grafikausgabe

Ich darf euch kurz noch die Grafikausgabe erklären. Je nach Zielsystem wird von z88dk entweder hochauflösende Grafik oder Low-Res-Block-Grafik unterstützt. Letztere ist aus Blockgrafik-Zeichen aufgebaut (bei manchen Ziel-Systemen fehlen dafür die geeigneten Zeichen im Zeichensatz, aber bei den Robotron-Computern sind sie glücklicherweise vorhanden). Wenn ein Ziel-System mehrere Auflösungen anbietet, kann man üblicherweise in den Kompilier-Parametern angeben, welchen Grafikmodus man verwenden möchte (ohne Parameter wird eine der Auflösungen als Defaultwert verwendet), bei manchen Systemen kann man auf den gewünschten Modus auch zur Laufzeit umschalten.

In der Doku zur Library graphics.h kann man nachlesen, welche Funktionen zur Verfügung stehen. Mein Spiel verwendet davon grundsätzlich nur die Funktionen plot() zum Zeichnen und point() für die Kollisionsabfrage.

Unten habe ich ein kleines Testprogramm angefügt, mit dem ich bei neuen Zielsystemen immer erst mal die Grafikausgabe teste. Hier habe ich es etwas vereinfacht und alles nicht-Robotron-bezogene weggelassen.

Eine kurze Erklärung der vom Testprogramm verwendeten Funktionen:

plot(x,y) zeichnet ein Pixel an der Position x,y (die Koordinaten beginnen bei 0, wobei 0,0 die linke obere Ecke ist)
unplot(x,y) löscht ein eventuell vorhandenes Pixel
point(x,y) liefert 1, wenn sich an x,y ein Pixel befindet, ansonsten 0

Mit getmaxx() und getmaxy() kann man die verfügbare Auflösung bestimmen - was für das Cross-Developement praktisch ist, damit das Programm ohne großen Aufwand für verschiedene Plattformen kompiliert werden kann.

Weiters bietet graphics.h auch die Funktionen

c_plot(x,y)
c_unplot(x,y)
c_point(x,y)

Mit c_plot() wird statt einem Pixel gleich ein 4x4-Pixelblock gezeichnet, und die anderen Funktionen verhalten sich ebenfalls entsprechend.
Das dient dazu, um Blockgrafik-Programme sehr einfach auf Systeme mit hoher Auflösung portieren zu können. Bei meinem Spiel habe ich z.B. beim Zielsystem KC85/2-5 davon Gebrauch gemacht.

Das Kompilieren des Testprogrammes erfolgt mittels folgender Befehle:


Quellcode:
zcc +z1013 -create-app plottestkc.c -o plottestkc_z1013
zcc +z9001 -lgfx9001 -create-app plottestkc.c -o plottestkc_z9001
zcc +kc -lndos -pragma-redirect:fputc_cons=fputc_cons_generic -create-app plottestkc.c -o plottestkc_kc85



Bei manchen Zielsystemen wie dem KC85/2-5 muss man eine entsprechende Konsole angeben, damit die Grafikausgabe funktioniert. Ich probiere es immer zuerst ohne Konsole, und wenn es ohne nicht geht, dann gebe ich den Konsolen-Parameter beim Kompilieren dazu.

Und bei machnen Systemen muss man den Grafikmodus erst mal mit clg() aktivieren, aber bei den Robotron-Targets ist das nicht notwendig (es schadet aber auch nicht, wenn man das als Fleißaufgabe macht).

Abschließend: viel Spaß damit. Vielleicht werden wir ja bald das eine oder andere neue Programm sehen. :-)


Quellcode:
/* plot(), Unplot() and Point() Test by RobertK, 2018-11-28 (simple version)

   Compile command for the following targets:
    
   === Robotron Z1013 (64×64) ===
   zcc +z1013 -lm -create-app plottest.c -o plottest_z1013
   Note: top line (plotted pixel at 1,1) was not visible with 1.99B,
   since nightly build 2018-03-22 it works correctly.

   === Robotron Z9001 (80x48) === (almost ok)
   zcc +z9001 -lm -lgfx9001 -o plottest_z9001 -create-app plottest.c
   or
   zcc +z9001 -lm -lgfx9001 -subtype=kcc -o plottest_z9001 -create-app plottest.c
   Use JKCEMU for testing, there you can run either a .TAP or a .KCC file.
   Note: combining -lgfx9001 and -clib=ansi...
   zcc +z9001 -lm -lgfx9001 -clib=ansi -o plottest_z9001_ansi -create-app plottest.c
   ...works only on monochrome systems (on colour machines, characters cannot be
   seen and plotted points are partly invisible)
  
   === Robotron KC85/2..KC85/5 and HC900 (320x256) === (ok)
   zcc +kc -lndos -pragma-redirect:fputc_cons=fputc_cons_generic -lm -create-app plottest.c -o plottest_kc85
   HC900 Issue: program occasionally crashes in the jkcemu emulator. Problem seems to be connected
   to the "Einfügen von Text direkt in den Tastaturpuffer" option. Could be an emulator problem.
      
*/

#include <stdio.h>        // required for printf()
#include <graphics.h>    // contains plot() and point() functions

void myCls()
{
    printf("%c",12);
}

void main()
{
  int x,y;
  int xMax, yMax;
  int mode;
  
  // determine the screen dimensions for this system
  // coordinates go from 0 to this max value
  xMax=getmaxx();
  yMax=getmaxy();
  
  myCls(); // clear the screen  
  printf("\n\n\n\n\n*** plot test (%d x %d) ***\n\n",xMax+1,yMax+1);
  
  printf("press any key to plot and unplot\n\n");
  fgetc_cons();    // wait for keypress
  
  // clg();  // required on some systems to activate graphics mode
    
  plot(1,1);
  plot(3,3);
  plot(40,4);
  plot(5,5);
  unplot(5,5);
  plot(7,7);

  // On some systems the console has colour support
  // Usability of this is limited, because a 4x4 block can only have one colour  
  /*
  for ( y = 0; y < 16; y++ ) {
        textcolor(y);
        plot(10,y*3);
  }
  */
  
  printf("press any key to point-check\n\n");
  fgetc_cons();    // wait for keypress
  
  printf("point(3,3)  (plotted) is %d\n",point(3,3)); // should be 1
  printf("point(40,4) (plotted) is %d\n",point(40,4)); // should be 1
  printf("point(5,5) (unplotted) is %d\n",point(5,5)); // should be 0
  printf("point(10,10)  (blank) is %d\n",point(10,10)); // should be 0

  // check if the screen dimensions for this platform have been defined above
  if (xMax>0 && yMax>0)
  {
      printf("\npress any key to draw border\n");
      fgetc_cons();    // wait for keypress
      for (x = 0; x <=xMax; ++x)
      {
        plot(x,yMax);
        plot(x,0);
      }
      for (y = 1; y <=yMax; ++y)
      {
        plot(0,y);
        plot(xMax,y);
      }
  }
  
  printf("\npress any key to clear screen\n");
  fgetc_cons();    // wait for keypress

  myCls(); // clear the screen
  
    
    
  xMax=xMax/4;
  yMax=yMax/4;  
  printf("\n\n\n\n\n*** c_plot test (%d x %d) ***\n\n",xMax+1,yMax+1);

  printf("press any key to c_plot and c_unplot\n\n");
  fgetc_cons();    // wait for keypress
  
  // clg();  // required on some systems to activate graphics mode
    
  c_plot(1,1);
  c_plot(3,3);
  c_plot(18,4);
  c_plot(5,5);
  c_unplot(5,5);
  c_plot(7,7);

  // On some systems the console has colour support
  // Usability of this is limited, because a 4x4 block can only have one colour  
  /*
  for ( y = 0; y < 16; y++ ) {
        textcolor(y);
        c_plot(10,y*3);
  }
  */
  
  printf("press any key to c_point-check\n\n");
  fgetc_cons();    // wait for keypress
  
  printf("c_point(3,3)  (plotted) is %d\n",c_point(3,3)); // should be 1
  printf("c_point(18,4) (plotted) is %d\n",c_point(18,4)); // should be 1
  printf("c_point(5,5) (unplotted) is %d\n",c_point(5,5)); // should be 0
  printf("c_point(10,7)  (blank) is %d\n",c_point(10,7)); // should be 0

  // check if the screen dimensions for this platform have been defined above
  if (xMax>0 && yMax>0)
  {
      printf("\npress any key to draw border\n");
      fgetc_cons();    // wait for keypress
      for (x = 0; x <=xMax; ++x)
      {
        c_plot(x,yMax);
        c_plot(x,0);
      }
      for (y = 1; y <=yMax; ++y)
      {
        c_plot(0,y);
        c_plot(xMax,y);
      }
  }
  
  printf("\npress any key to clear screen\n");
  fgetc_cons();    // wait for keypress

  myCls(); // clear the screen
    
    
  printf("done.\n");
  fgetc_cons();    // wait for keypress
    
}

Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
005
28.11.2018, 18:39 Uhr
schlaub_01



Hallo Robert,
das ist ja wirklich super aufbereitet und erklärt - vielen Dank! Ich hatte letztens den z88dk Compiler mal installiert, allerdings wurden meine "Hello World"-Programme irgendwie immer riesengroß (>4k). Irgendwas mache ich da scheinbar noch verkehrt. Kenne mich mit den ganzen Makefile-Optionen nicht aus. Aber wäre schön, wenn man den Compiler wirklich für die Z80 Systeme optimiert nutzen könnte. Mein Assembler-"Hello World" war im übrigen nur 19 Byte groß. Wenn mal wieder etwas Zeit ist, muß ich mich mal intensiver damit beschäftigen, denn meine Assembler Kentnisse gehen gegen 0 und C Programme für Mikrocontroller habe ich schon oft gemacht.
Aber trotzdem - super Arbeit! Dankeschön!


Grüße,
Sven.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
006
29.11.2018, 19:27 Uhr
RobertK

Avatar von RobertK

Das mit der Dateigröße ist mir auch schon aufgefallen - ich weiß leider nicht, ob es eine Art "Optimize for speed or size"-Option gibt. Ich werde bei Gelegenheit mal bei den z88dk-Experten nachfragen, denn für mich wäre es eine Herausforderung, Programme für den Standard-ZX81 mit nur 1K RAM zu entwickeln. Doch wie du schon erwähnt hast: das simpelste kompilierte Hello World-Programm hat 4K (wobei das offenbar eine Art Overhead ist, denn danach steigt die Programmgröße linear).

z88dk ist zwar um ein "Eckhaus" schneller als Basic, doch die Geschwindigkeit von purem ASM kann man damit nicht erreichen. Von daher ist z88dk ideal für Leute, denen das Talent für ASM fehlt, aber die dennoch mehr machen möchten als auf den jeweiligen Computern in Basic möglich ist. Z.B. beim ZX81 ist die Ausgabe der Grafikzeichen mit z88dk einfach zu langsam, als dass man damit ein komplexeres Spiel bauen könnte - wenn ich mir ansehe, was andere Leute da in ASM zaubern (mit butterweichen Bewegungen oder gar scrollendem Bildschirm), dann wird man da schon neidisch. Aber dennoch, wie gesagt ist es ein Riesen-Unterschied zu Basic.

Noch zwei Korrekturen zu meinem oberen Teil 3, leider kann ich das Posting nicht mehr bearbeiten:

- Die im Source ganz oben im Kommentar stehende Bemerkung...


Zitat:
=== Robotron Z9001 (80x48) === (almost ok)
[...]
Note: combining -lgfx9001 and -clib=ansi...
zcc +z9001 -lm -lgfx9001 -clib=ansi -o plottest_z9001_ansi -create-app plottest.c
...works only on monochrome systems (on colour machines, characters cannot be
seen and plotted points are partly invisible)


kann man mittlerweile ignorieren, dieses Problem ist mittlerweile behoben, nun funktioniert es am Z9001 in allen Varianten.

- Es betrifft zwar nicht die Robotron-Computer, aber in diesem Kommentar...


Zitat:
// On some systems the console has colour support
// Usability of this is limited, because a 4x4 block can only have one colour


...war natürlich ein 2x2-Block gemeint (also ein Grafikzeichen).

Dieser Beitrag wurde am 29.11.2018 um 19:27 Uhr von RobertK editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
007
08.12.2018, 20:15 Uhr
RobertK

Avatar von RobertK

Noch kurz zur Dateigröße: mittlerweile habe ich erfahren, dass es einige Tricks gibt, damit das kompilierte Programm kleiner wird und weniger Speicher benötigt. Das Ganze ist jedoch alles andere als trivial, denn die Tricks haben alle irgendwelche Nebenwirkungen. Wenn ich das irgendwann einmal alles selber durchblicke, werde ich euch Bericht erstatten.

Als vorläufigen Abschluss meines Tutorials noch ein wichtiges Thema:

Teil 4: Systemabhängiger Code

Da die einzelnen Zielsysteme alle unterschiedliche Möglichkeiten bieten (beispielsweise bietet der KC85/2-5 hochauflösende Grafik, Z1013 und Z9001 aber nicht), muss man seinen Code für "Cross-Development" entsprechend unterschiedlich gestalten. Nun möchte man aber nicht für jedes System eine eigene Source-Datei erstellen, was in weiterer Folge die Wartung des Programms erschweren würde. Stattdessen ist es viel praktischer, eine einzige Source-Datei zu haben, in der bestimmte Codezeilen abhängig vom Zielsystem unterschiedlich gestaltet werden.

Sehen wir uns das gleich anhand eines Beispiels (HalloWelt3.c) an:


Quellcode:
void main()
{
  printf("\n\n\n\nHallo Welt!\n\n\n");
  
  #if defined(__Z1013__)    // Robotron Z1013
    printf("\n\n\n\nRobotron Z1013\n\n\n");
  #elif defined(__Z9001__)    // Robotron Z9001
    printf("\n\n\n\nRobotron Z9001\n\n\n");
  #elif defined(__KC__)        // Robotron KC85/2..KC85/5 oder HC900
    printf("\n\n\n\nRobotron KC85/2-5 bzw. HC900\n\n\n");
  #endif
  
  #if defined(__MEINE_SONDERBEHANDLUNG__)    // Extrawurst
    printf("\n\n\n\nSonderbehandlung...\n\n\n");  
  #endif
  
  printf("Taste druecken zum Beenden...\n");
  fgetc_cons();    // warte auf irgendeinen Tastendruck      
}


Kompiliert wird das einfach so wie unser erstes HalloWelt-Programm:

Quellcode:
zcc +z1013 -create-app -o HalloWelt3_Z1013 HalloWelt3.c
zcc +z9001 -create-app -o HalloWelt3_Z9001 HalloWelt3.c
zcc +kc -lndos -create-app -o HalloWelt3_KC85_2-5 HalloWelt3.c


Das Ergebnis ist, dass jedes der drei Programme zu Beginn den Namen des jeweiligen Systems ausgibt.

Dieses #if...#elif...#endif-Konstrukt ist ja sehr einfach zu verstehen, und genau so kann man das auch in sein eigenes Programm einbauen. Dennoch sollte man wissen, was da im Detail passiert:

Die #-Befehle sind sogenannte Präprozessor-Direktiven: diese Bedingungen werden in einer Art "Vorwaschgang" noch vor dem eigentlichen Kompiliervorgang abgearbeitet, sodass der Compiler nur noch jene Zeilen zu Gesicht bekommt, die aufgrund dieser Abfragen enthalten sein sollen.
Und was genau bedeutet z.B. "#if defined(__Z1013__)"? Hier wird geprüft, ob eine Konstante namens "__Z1013__" definiert ist. Wenn man den Kompiliervorgang für ein bestimmtes System startet, wird automatisch die Library des jeweiligen Systems eingebunden, und darin ist die jeweilige Systemkonstante definiert. Möchte man die Konstante für ein weiteres System herausfinden (für die drei Robotron-Rechner seht ihr sie in obigem Beispielprogramm), kann man im z88dk-Verzeichnis lib\config in der jeweiligen .cfg-Datei nachsehen.

Soweit so gut, doch diese Technik kann man noch für etwas Weiteres nutzen.

Hin und wieder möchte man für ein System verschiedene Varianten des Programms erstellen. Beispielsweise gibt es ja vom Z1013 zwei Varianten: einmal mit 1 MHz und einmal mit 2 MHz, und dafür muss ich bei meinem Spiel H-Tron die Geschwindigkeit unterschiedlich einstellen.
Ursprünglich hatte ich hierfür die Codezeilen vor dem Kompilieren jedes Mal aus- bzw. einkommentiert, was auf die Dauer aber mühsam wurde.
Später habe ich herausgefunden, dass man beim Kompilier-Befehl mittels -D eigene Konstanten definieren kann, und genau das mache ich in meiner Datei compile_htron_z1013_2MHz.bat mit dem Parameter -DZ1013_2MHZ, und in meinem Code prüfe ich das Vorhandensein der Konstante "Z1013_2MHZ".

Und wenn wir obiges Beispielprogramm mit folgendem Befehl...

Quellcode:
zcc +z9001 -create-app -o HalloWelt3_Z9001_Sonderbehandlung -D__MEINE_SONDERBEHANDLUNG__ HalloWelt3.c


...kompilieren, wird auch die eine Sonderbehandlungs-Zeile ausgegeben.

Soviel zu diesem Thema, das aufgrund der drei verschiedenen Robotron-Zielsysteme für euch sicher wichtig sein sollte.

Dieser Beitrag wurde am 08.12.2018 um 20:24 Uhr von RobertK editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
008
02.03.2019, 11:11 Uhr
srn

Avatar von srn

Hallo,

hat von Euch jemand mit dem Compiler schon ein Programm für den KC85/5 erstellt?
Neueste CAOS4.7-Version.

Ich habe hier ein lumpiges Programm:


Quellcode:

#include <math.h>

int main()
{
    float x,y;
    int dx;
    x=6.55;
    y=10.1;
    dx=1023*x/y;

    return 0;
}



Das läuft auch durch, nur kommt die main-Routine nicht sauber zurück.
Nach Beendigung des Programms steht der Cursor (als Unterstrich) in der linken, unteren Ecke.
Das OS reagiert nicht mehr.
Meine Vermutung: Das Programm wird nicht so beendet, daß der Rücksprung zu CAOS korrekt abläuft.
Ich finde aber nirgendwo Hinweise, wie das Beenden richtig zu erfolgen hat.

Weiß jemand von Euch Rat?

Danke.
-René
--
http://www.kc-und-atari.de/ --- M004

Dieser Beitrag wurde am 02.03.2019 um 11:12 Uhr von srn editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
009
02.03.2019, 12:32 Uhr
PIC18F2550

Avatar von PIC18F2550

return 0;

Hinterlässt eine 0 auf dem Stack.

probier mal return;
--
42 ist die Antwort auf die "Frage nach dem Leben, dem Universum und dem ganzen Rest"
Aktuelle Projektdokumentationen
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
010
02.03.2019, 12:55 Uhr
srn

Avatar von srn

Nee, solche Sachen habe ich schon alle probiert.
Das hilft nicht.

Daß das Programm an sich arbeitet kann man daran erkennen, daß dx den Wert 663 enthält.
--
http://www.kc-und-atari.de/ --- M004
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
011
02.03.2019, 13:04 Uhr
RobertK

Avatar von RobertK

Hallo René,

du machst schon alles richtig, aber Bert hat schon weiter oben festgestellt, dass es mit dem KC85/2-5-Target leider noch ein Problem nach dem Programmende gibt, die Zeichen sind hinterher immer "kaputt" - das merkt man auch bei meinem Spiel [url=https://sourceforge.net/projects/h-tron/]H-Tron[/url], wenn man es mit X beendet.

Damit müssen wir vorerst leben, aber ich werde das mal den z88dk-Entwicklern sagen, damit die sich das ansehen.

Hier dein Programm nochmal mit Bildschirmausgabe. Ich war mir nicht sicher, ob es ein Problem darstellt, dass dx als int definiert ist, aber die Zuweisung klappt problemlos.


Quellcode:
#include <stdio.h>
#include <math.h>

int main()
{

    float x,y;
    int dx;
    float dxFloat;
    
    // Bildschirm löschen
    printf("%c",12);
    printf("\x0c");  // the "\x0c" (0x0c character) resets the cursor position to the top left corner

    x=6.55;
    y=10.1;
    dx=1023*x/y;
    dxFloat=1023*x/y;

    printf("Das Ergebnis lautet: %d\n",dx);
    printf("Und noch genauer: %.5f\n",dxFloat);
    fgetc_cons();    // warte auf Tastendruck

    return 0;

}



Das Kompilieren geht so:
zcc +kc -lndos -lm -create-app calc.c -o calc_KC85_2-5
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
012
02.03.2019, 17:57 Uhr
srn

Avatar von srn

Hallo Robert,

danke.
Mir kam dann auch dieser Gedanke, daß es daran liegen wird.
Das ist natürlich sehr schade, zumal sich die Programmerstellung und das Compilieren und Linken sehr einfach gestaltet.

Nun versuche ich das Ganze mit der SDCC-Umgebung, aber das ist eine einzige Katastrophe.
Derart schlecht dokumentiert; da steigt keine Sau durch, außer Esoteriker.
Klar ist alles kostenlos: Aber wenn es nur für "mich" ist, was da geschrieben steht, dann lasse ich es doch sein und veröffentliche es erst gar nicht.
Wenn ich schon lese: "Mir ist es gelungen ...". Und dann kommt nichts mehr. Wem nützt diese Information.
Naja, ich probiere weiter.

Viele Grüße.
René
--
http://www.kc-und-atari.de/ --- M004
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
013
02.03.2019, 18:30 Uhr
Hobi



so kompliziert ist der SDCC nicht. Ich habe die Umsetzung für KC85 Z1013 und BIC schon mal gemacht. Vielleicht können wir uns zusammentun um nicht alles zwei mal zu bauen.
--
-------------------------------------------
Corontäne
-------------------------------------------
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
014
25.12.2019, 14:49 Uhr
RobertK

Avatar von RobertK

Es gibt erfreuliche Nachrichten: der z88dk-Compiler unterstützt nun auch diese vier Zielsysteme:

Hübler/Evert-MC
Hübler-Grafik-MC
Kramer-MC
Robotron A5105 (BIC)

Bei all diesen Systemen wird die generische Konsole unterstützt.

Nähere Details findet ihr auf der z88dk-Plattformliste, folgendes ist davon erwähnenswert:

- Beim Hübler-Grafik-MC wird auch 256x256-Hires-Grafik unterstützt.

- Beim BIC wird bei der Konsolen-Ausgabe auch Farbe unterstützt, diese kann man so setzen:
textcolor(YELLOW);
textbackground(RED);
Ich werde demnächst ein weiteres kleines Spiel veröffentlichen, das davon Gebrauch macht und das schon am BIC läuft.

Meine beiden Programme habe ich nun aktualisiert: H-Tron unterstützt nun den Hübler-Grafik-MC, und der Elite Planet Browser unterstützt alle vier oben genannten Systeme.

Beim Kramer MC reagiert die Tastatur im Emulator ziemlich lahm, aber damit kann man wohl leben.

Beim BIC sollte es irgendwann auch die Möglichkeit für hochauflösende Grafik geben, doch der z88dk-Entwickler (Dom) hatte mit dem uPD7220-Videocontroller (im BIC werkelt ja ein Nachbau davon) bisher ziemlich zu kämpfen, das ist nicht so einfach.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
015
19.10.2020, 21:39 Uhr
ralle



Mich würde das interessieren, wie das unter Ubuntu (Debian und oder Mint) funktioniert?
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
016
20.10.2020, 10:48 Uhr
RobertK

Avatar von RobertK

Unter Linux habe ich keine Erfahrung damit, aber hier gibt es eine Diskussion dazu:
https://www.z88dk.org/forum/viewtopic.php?f=5&t=11418&sid=cb92d9d6d299461a299d844fc0083f55

Und Dom hat daraufhin einen experimentellen Snapshot für verschiedene Linux-Distributionen erstellt:
https://snapcraft.io/z88dk
Das könntest du mal ausprobieren.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
017
20.10.2020, 12:06 Uhr
ralle



Aha. Naja, unter Linux ist ständig ein C++-Compiler aktiv, der GCC. Am einfachsten ist es mit diesem mit einer IDE, aber es geht ein einfacher Texteditor und die Komandozeile. Dieser Compiler wird letztendlich immer bei Kernelupdates benötigt.

Python2 und 3 sind auch aktiv, zahlreiche unter einer GUI funktionierende Programme müssen diese aufrufen, da Python ähnlich eines Interpreter funktioniert.

Deswegen die Frage. C++ müsste ja abwärtskompatibel sein zu C. Ein bissel habe ich auch schon rumgespielt.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
018
09.02.2021, 15:28 Uhr
volkerp
Default Group and Edit
Avatar von volkerp

Hallo RobertK,

Nachfrage zu 007: wie erzeugt man kleinere Programme?

Frage zum Z9001: Damit man ein geladenes Programm erneut starten kann, fehlt ein sogenannter OS-Rahmen ( https://hc-ddr.hucki.net/wiki/doku.php/z9001/programmieren#assembler ). Der könnte in z9001_crt0.asm stehen, nur wie macht man das und wie kompiliert man eine eigene crt0-Datei?


Quellcode:

    org     CRT_ORG_CODE

        jp start
        db 'NAME    ',0     <- hier müsse am besten auch der
                                     Programm-Name eingefügt werden
                                     (Großbuchstaben, 8 Zeichen, mit Leerzeichen auffüllen)
        db 0

start:...


--
VolkerP

http://hc-ddr.hucki.net
(Z9001, Z1013, LC-80, ...)

Dieser Beitrag wurde am 09.02.2021 um 15:28 Uhr von volkerp editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
019
09.02.2021, 20:26 Uhr
Bert




Zitat:
volkerp schrieb
Nachfrage zu 007: wie erzeugt man kleinere Programme?



Ein kleines Testprogramm:

Quellcode:

#include <stdio.h>

int main( int argc, char argv[])
{
    printf( "Hallo Welt!\n");
    return 0;
}



Compilieren und eine TAP-Datei erstellen:

Quellcode:

zcc +z9001 -create-app test.c



Ich nehme mal an, das Du soweit schon gekommen bist, oder?

Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
020
10.02.2021, 08:42 Uhr
volkerp
Default Group and Edit
Avatar von volkerp

klar, einfache Programme zum compilieren funktioniert.

Meine Frage bzgl. 'kleinere Programme' bezieht sich auf
"Noch kurz zur Dateigröße: mittlerweile habe ich erfahren, dass es einige Tricks gibt, damit das kompilierte Programm kleiner wird und weniger Speicher benötigt. Das Ganze ist jedoch alles andere als trivial, denn die Tricks haben alle irgendwelche Nebenwirkungen. Wenn ich das irgendwann einmal alles selber durchblicke, werde ich euch Bericht erstatten."
--
VolkerP

http://hc-ddr.hucki.net
(Z9001, Z1013, LC-80, ...)
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
021
10.02.2021, 10:53 Uhr
Hobi



Ich verstehe das Problem "kleiner Programme" noch nicht so richtig. Kannst du das Map File dazu hier einstellen? Dort steht drin, wer wieviel Platz verbraucht. Normalerweise ist das printf() der Übeltäter. crt0+main sollte nicht mehr als ein paar 100 bytes benötigen.
--
-------------------------------------------
Corontäne
-------------------------------------------

Dieser Beitrag wurde am 10.02.2021 um 11:07 Uhr von Hobi editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
022
12.02.2021, 11:46 Uhr
Rüdiger
Administrator
Avatar von Rüdiger


Zitat:
RobertK schrieb
Hier nun wie versprochen eine kurze Anleitung, wie man mit dem z88dk-Compiler sein erstes kompiliertes C-Programm für einen Robotron-Computer erzeugen kann.




Bring bitte Deine Emailanbindung in Ordnung: Dein Mailserver bewirft mich mit Bouncings (Unknown To address).
--
Kernel panic: Out of swap space.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
023
08.04.2021, 21:55 Uhr
u-held



Kann man auf dem KC 85/2+ eigentlich auch CAOS-Routinen aufrufen? Ich scheitere schon am "Hello World":


Quellcode:

void main()
{
  #asm
    call  $f003
    defb  $23
    defm  "Hallo KC", $d, $a, 0
  #endasm

  fgetc_cons();    // warte auf irgendeinen Tastendruck      
}



Der Text wird nicht ausgegeben. Es wird aber auf den Tastendruck gewartet.

VG, Dietmar
--
Kompetenz simulieren
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
024
10.04.2021, 08:03 Uhr
Bert




Zitat:
u-held schrieb
Kann man auf dem KC 85/2+ eigentlich auch CAOS-Routinen aufrufen?


Natürlich!

Für den SDCC hatte ich mal eine caos.lib geschrieben, welche einige CAOS-Funktionen direkt vom C aus nutzbar macht: https://github.com/anchorz/sdcc-z1013-kc85/blob/master/include/caos.h


Quellcode:

#include <stdint.h>
#include <caos.h>

void main()
{
    // clear screen and set a correct cursor position
    crt( 0x0c);

    OSTR( "Test: KBDZ (space = end)\r\n");
    uint16_t taste_0e;
    do
    {
        taste_0e = kbdz();
        if( taste_0e > 255)
        {
            crt( CCR);
            hlhx( taste_0e);
        }
    } while ( taste_0e != 0x0120); // pressed + space
    crlf();

}



Beim z88dk ist die Reihenfolge der Parameter auf dem Stack anders, aber mit Anpassung geht es auch dort.

Grrüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
025
16.04.2021, 22:44 Uhr
u-held



Vielen Dank, Bert! Sdcc-z1013-kc85 funktioniert problemlos. Z88dk lasse ich erstmal links liegen. (Bin ich dann noch im richtigen Thread?)

Ich habe auf Basis von https://github.com/anchorz/sdcc-z1013-kc85/tree/master/sample_05_kc85_graphic ein eigenes Beispiel für den KC 85/4 geschrieben. Ich wollte einfach mal Vorder- und Hintergrundfarben nebeneinander stellen. Dabei dachte ich mir ganz naiv, wenn ich die Hintergrundfarbe mit colorup einstelle und dann eine Linie mit XOR- oder Löschen-Bit male, dass dann die gerade eingestellte Hintergrundfarbe sichtbar wird. Denkste. Im JKCEmu 0.9.3 wird dann einfach nichts, also Standardblau angezeigt.

Wo liegt mein Fehler?

Das ist das Testprogramm:


Quellcode:

#include <stdint.h>
#include <caos.h>

uint8_t color = 0;
uint8_t y;
uint8_t i, j;

void main() {

  color = 0;
  y = 8;
  for (i = 0; i < 16; i++, y++, color += 8) {
    colorup(2, color, color & 7);
    for (j = 0; j < 3; j++, y++) {
      line(  8, y,  50, y, color);
      line( 42, y,  76, y, color + 1);
      line( 78, y, 110, y, color + 2);
      line(112, y, 144, y, color + 3);
    }
  }

  colorup(2, 7, 1);  
}



So sieht es im Emulator aus:
--
Kompetenz simulieren

Dieser Beitrag wurde am 16.04.2021 um 22:49 Uhr von u-held editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
026
17.04.2021, 10:12 Uhr
ralle



Mist, ich bin noch nicht zum einbinden in den GCC gekommen
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
027
17.04.2021, 10:34 Uhr
Bert



Das liegt am Bildschirmmodus des KC85/4 (und /5).
Im Standardmodus gibt es 320x200 Pixel.
Jeweils acht nebeneinanderliegende Pixel teilen sich die Farbinformation (ein Byte), wobei ein Pixel entweder die Hintergrund- oder die Vordergrundfarbe haben darf. Es gibt 8 Hintergrundfarben und 16 Vordergrundfarben. Mit dem übrigen Bit wird der Blinkmodus (automatischer Wechsel zwischen FG- und HG-Farbe) aktiviert.

Es gibt noch einen Modus in dem jeder Bildpunkt seine eigene Farbe hat, aber dann sind nur 4 Farben möglich (schwarz, rot, türkis, weiß).

Wenn man Dein Programm etwas abändert,

Quellcode:

...
      line(  8, y,  50, y+10, color);
      line( 42, y,  76, y+20, color + 1);
      line( 78, y, 110, y+30, color + 2);
      line(112, y, 144, y+40, color + 3);
...


bekommt man folgendes Bild:


Viele Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
028
18.04.2021, 10:15 Uhr
RobertK

Avatar von RobertK

Leider habe ich die an mich gestellten Fragen erst jetzt endeckt. @Rüdiger: danke für den Hinweis, mein hier verwendeter E-Mail-Alias war nicht mehr gültig, dadurch habe ich auch keine Mail-Benachrichtigungen bekommen. Das habe ich behoben.

Zum Thema "kleinere Programm-Größe" kann ich leider nicht viel beitragen, da ich das selber noch nicht durchschaut habe, aber ich kann euch auf diesen Thread im z88dk-Forum hinweisen, wo Dom ein paar Möglichkeiten zur Verkleinerung aufgelistet hat:

https://www.z88dk.org/forum/viewtopic.php?p=17164#p17164

Offenbar trägt die Methode printf() sehr zur Programmgröße bei.

Noch eine Korrektur zu dieser meiner Aussage im Teil 2 (Konsolen):


Zitat:
RobertK schrieb
Und genauso funktioniert auch die "Generische Konsole":
https://github.com/z88dk/z88dk/wiki/Classic-GenericConsole
Hier kann man die selben Funktionen wie bei VT100 verwenden, jedoch muss man conio.h dazu nicht einbinden.


Mittlerweile habe ich festgestellt, dass man auch bei Verwendung der Generischen Konsole (mittlerweile wird sie in z88dk auch "Portable Konsole" genannt) conio.h einbinden kann und soll. Denn erstens verhindert das Compiler-Warnungen. Und zweitens wird das kompilierte Programm dadurch nicht größer (wie von mir zuerst angenommen), sondern interessanterweise sogar ein wenig kleiner.

Dieser Beitrag wurde am 18.04.2021 um 10:16 Uhr von RobertK editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
029
20.04.2021, 14:12 Uhr
Bert



Übrigens, wenn man vor Programmstart den HiRes-Modus aktiviert (ESC-A), gibt es folgende Ausgabe:


Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
030
16.03.2022, 11:01 Uhr
RobertK

Avatar von RobertK

Ich habe eine erfreuliche Nachricht: der z88dk-Compiler unterstützt nun auch die KRT-Grafik-Erweiterung für den Z1013! Und auch für den Z9001 funktioniert die KRT-Grafik nun vollständig, bisher hatte die Textausgabe im Grafikmodus nicht funktioniert.

Nähere Infos findet ihr in der Doku zu den einzelnen Zielsystemen:
https://github.com/z88dk/z88dk/wiki/Platform

Ich habe ein kleines Beispielprogramm namens "Megatoll" erstellt (bitte entschuldigt den bescheuerten Namen, den habe ich mit 15 Jahren erfunden, damals hatte ich dieses Programm im Informatik-Unterricht auf einem Commodore CBM 720 geschrieben).

Das Beispiel habe ich auf meinem Google-Drive deponiert:
https://drive.google.com/drive/folders/16tojVaY0Tlr9CEoQlxRiL_q6EqH_3zMr
-> megatoll_Robotron.zip

Unterstützt werden folgende Systeme:

Z1013
Z1013 KRT
Z9001
Z9001 KRT
KC 85/2-5 (leider gibt es derzeit noch ein Problem mit den Modellen /4 und /5)
Hübler Grafik-MC



Noch ein paar Worte zu den KRT-Varianten:
- Ich definiere beim Kompilier-Befehl mittels -D__Z1013_KRT__ bzw. -D__Z9001_KRT__ eine Konstante, auf die ich im Programm entsprechend reagiere.
- Bei den KRT-Varianten muss man - so wie auch bei vielen anderen Systemen - den Bildschirmmodus umschalten. Beim KC85 und dem Hübler Grafik-MC ist das nicht notwendig, die können jederzeit Text und Grafik anzeigen.
- Bei Verwendung der KRT-Grafik muss man einen externen Font verwenden:
https://github.com/z88dk/z88dk/wiki/Classic-GenericConsole#defining-a-custom-font
Im Beispiel verwende ich jenen des BBC-Computers.

Ich darf euch um Tests auf der echten Hardware bitten - oft kommen wir nämlich drauf, dass zwar im Emulator alles perfekt läuft und es aber am echten Gerät noch irgendwo hakt. Vor allem der Z1013 mit KRT-Erweiterung würde mich interessieren.

Zum Abschluss noch eine Frage: nehmen wir mal, ich würde den Z1013-128 nachbauen:
https://hc-ddr.hucki.net/wiki/doku.php/z1013:z1013-128
Könnte ich dafür die KRT-Erweiterung bauen und diese damit verwenden? Sind die benötigten Teile alle einfach erhältlich, oder muss man da auf Altbestände zurückgreifen?

Dieser Beitrag wurde am 16.03.2022 um 11:10 Uhr von RobertK editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
031
16.03.2022, 17:20 Uhr
Lötspitze



Ja, der Z1013-128 ist vollständig abwärtskompatibel. Das heißt, alles was mit dem Ursprungsrechner aus den 80ern möglich war, funktioniert auch mit dem neuen (hard- und softwareseitig). Bei den Bauteilen sehe ich kein Problem; nur beim ATtiny für den PS/2-Tastaturanschluß bin ich mir aktuell nicht sicher.

VG Matthias
--
___________________
...geboren, um zu löten.

Wer rennen soll, muß auch mal stolpern dürfen.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
032
28.03.2022, 13:52 Uhr
RobertK

Avatar von RobertK


Zitat:
RobertK schrieb
Das Beispiel habe ich auf meinem Google-Drive deponiert:
https://drive.google.com/drive/folders/16tojVaY0Tlr9CEoQlxRiL_q6EqH_3zMr
-> megatoll_Robotron.zip


Ich habe festgestellt, dass der Zugriff auf mein Google Drive leider nicht funktioniert hatte, das ist nun behoben.
In der Zip-Datei sind übrigens auch die kompilierten Programme im .Z80/.KCC/.TAP-Format enthalten, d.h. man kann das Ergebnis auch ohne z88dk-Compiler ausprobieren.

Dieser Beitrag wurde am 28.03.2022 um 13:52 Uhr von RobertK editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
033
17.10.2022, 22:07 Uhr
Hojoe




Zitat:
RobertK schrieb
du machst schon alles richtig, aber Bert hat schon weiter oben festgestellt, dass es mit dem KC85/2-5-Target leider noch ein Problem nach dem Programmende gibt, die Zeichen sind hinterher immer "kaputt" - das merkt man auch bei meinem Spiel [url=https://sourceforge.net/projects/h-tron/]H-Tron[/url], wenn man es mit X beendet.



Heute wurde ein PR von mir angenommen der das Verhalten hoffentlich berichtigt. Die Änderungen sollten im nächsten Nightly Build enthalten sein.

Vielleicht möchte das dann jemand testen?

Hintergrund:
Soweit ich das richtig gesehen habe sollte in der Funktion clg() ein Fehler behoben werden. In clg() wurde ein cls nach gebaut. Dabei wurde nur der Pixelspeicher gelöscht. Die eingefärbten Pixel vom Cursor bleiben daher stehen. Um das zu beheben wurde der Cursor auf die Position 256,256 verschoben. Damit gibt es dann nach dem Programmende keinen Cursor mehr :-(. (Wenn man nach rechts geht gibt es einen Überlauf und er tauch ganz oben wieder auf (glaub ich)).

Die clg() Funktion verwendet jetzt (wieder) die CAOS Funktion zum Bildschirm löschen. Dadurch kann der Code zum 'unsichtbar machen' des Cursors entfernt werden. Beim 85/4 wird beim Beenden zusätzlich auf den Pixel Ram zurück geschaltet (falls irgendwas mit Grafik gemacht wurde, ist der Farb-RAM aktiv).

Ich wollte ja den Code mit den umgebogenen Interrupts ganz ausbauen, da hat sich aber ein Entwickler gesperrt. Zumindest werden die Interrupts jetzt am Ende wieder zurück geändert.

Holger

Dieser Beitrag wurde am 17.10.2022 um 22:08 Uhr von Hojoe editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
034
18.10.2022, 20:31 Uhr
RobertK

Avatar von RobertK

Hmm, jetzt gibt es allerdings das Problem, dass der Cursor nun auch im eigentlichen Programm sichtbar ist, und da möchte man ihn üblicherweise nicht sichtbar haben. Ausprobiert habe ich es mit meinem Spiel H-Tron.
Zur Not habe ich in meinen Programmen einen Workaround für jene Targets, wo sich der Cursor gar nicht ausblenden lässt (ich positioniere ihn einfach ins Eck, wo er nicht so sehr stört).

D.h. die Positionierung auf 256,256 war sicher gewollt - Dom versucht immer bei jedem neuen Target erst mal den Cursor auszublenden, und hier ging das offenbar nur mit diesem Trick.

Gibt es am KC85/2-5 vielleicht doch eine System-Funktion, um den Cursor auszublenden?

Nach dem Programm-Ende sieht es gut aus, allerdings hat es vorher (ich habe es mit der z88dk-Version von 24.6.2022 probiert) auch nicht so schlecht ausgesehen. Viel früher war der Bildschirm komplett kaputt und es waren gar keine Zeichen mehr sichtbar.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
035
18.10.2022, 23:43 Uhr
Hojoe



Mhm, wo gibt es dein Program? Ah vermutlich https://sourceforge.net/projects/h-tron/ ? Da steige ich jetzt nicht so schnell durch. Ich schaue es mir morgen mal an.

Der Cursor ist meines Wissens nach nichts besonderes. An der Stelle wird nur eine andere Farbe und / oder das Blink Bit gesetzt. Wird der Farbspeicher richtig gelöscht, sollte der Cursor weg sein.

Holger
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
036
19.10.2022, 08:39 Uhr
Hojoe



Ich habe H-Tron gerade ausprobiert. Im eigentlichen Spiel habe ich keinen Cursor gesehen. Im Menü, wenn auf die Taste gewartet wird, dann wird ein Cursor eingeblendet.

In https://github.com/z88dk/z88dk/blob/master/libsrc/target/kc/stdio/fgetc_cons.asm wird auf die CAOS Funktion KBD zugegriffen. Im Handbuch steht

Zitat:
Tasteneingabe mit Einblendung des Cursors, wartet, bis Taste
gedrückt ...



Vielleicht sollte das UP nicht verwendet werden, wenn kein Cursor gewünscht ist. Dann wiederum einen Workarounds einzubauen um den Cursor auszublenden, davon halte ich nichts.

Vermutlich ist es einfacher direkt IX +13 abzufragen oder KBDS in eine Schleife.

Ich werde mal einen Patch vorbereiten.

Holger
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
037
19.10.2022, 15:02 Uhr
Hojoe




Zitat:
Hojoe schrieb
Ich werde mal einen Patch vorbereiten.



ok siehe: https://github.com/z88dk/z88dk/pull/2105
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
038
21.10.2022, 18:51 Uhr
Hojoe




Zitat:
Hojoe schrieb

ok siehe: https://github.com/z88dk/z88dk/pull/2105



Der Patch sollte jetzt im Nightly Build vorhanden sein.

Holger
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
039
22.10.2022, 19:26 Uhr
RobertK

Avatar von RobertK

Ja, jetzt dürfte es richtig funktionieren, der Cursor ist im Programm ausgeblendet, und nach dem Programmende sieht auch alles korrekt aus - vielen Dank.
Ich habe das Builden der z88dk-Binaries unter Windows (in Git Bash) leider nie zum Laufen gebracht...

Vielleicht möchtest du bei Gelegenheit noch versuchen, ob du am Z1013 vielleicht die practic 1/88-Spielhebel zum Laufen bringen kannst? Dom (=Suborb) hat den Code "blind" aus dem JKCEmu-Emulator übernommen (blind deswegen weil er es als Mac-User mit JKCEmu nicht testen kann), aber leider hat es nie funktioniert.

Siehe hier:
https://www.z88dk.org/forum/viewtopic.php?p=20448#p20448

Zum Testen kannst du mein Testprogramm joytest.c verwenden:

https://drive.google.com/drive/folders/16tojVaY0Tlr9CEoQlxRiL_q6EqH_3zMr
-> joytest_2022-05-28.zip
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
040
22.10.2022, 23:00 Uhr
jmueller



RobertK schrieb:

Zitat:
...weil er es als Mac-User mit JKCEmu nicht testen kann



Joysticks werden auch auf einem Mac emuliert,
allerdings werden keine am Mac physisch angeschlossene Joysticks unterstützt.
Das ist nur unter Windows und Linux der Fall
(weil ich keinen Mac habe und auch keine Ahnung habe,
wie man auf einem Mac programmtechnisch Joysticks abfragt).

Zurück zur Joystick-Emulation (gilt für alle Plattformen):
Im JKCEMU das Joystick-Fenster öffnen und darin dann:
- mit der Maus auf die Pfeile bzw. Fire-Knöpfe klicken oder
- mit Cursor-Tasten, Enter/F1 und F2 den ersten Joystick mit der Tastatur bedienen oder
- bei gleichzeitig gedrückter Shift-Taste den zweiten Joystick mit der Tastatur bedienen

Jens

Dieser Beitrag wurde am 22.10.2022 um 23:09 Uhr von jmueller editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
041
23.10.2022, 18:47 Uhr
Hojoe



Vielen Dank für die Klarstellung und auch für den JKCEmu :-). Wir hatten uns das so ähnlich zusammengereimt, nachdem wir den verlinkten Thread und die Hilfe vom JKCEmu gelesen hatte. Vermutlich kann der z88dk Entwickler kein Deutsch, daher ist er nicht auf die Hilfe gestoßen.

Ich schau mir das mal an, kann aber nichts versprechen, da ich bisher nichts mit den Z1013 zu tun hatte.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
042
23.10.2022, 22:29 Uhr
Hojoe



ich habe es gerade ausprobiert:

Was funktioniert denn nicht?

Das einzige was mir aufgefallen ist, die Joysticks sind vertauscht. Die werden durch Bit 5 und 6 unterschieden. Welches Bit wird für Joystick 1 verwendet und welches für Joystick 2?

Dieser Beitrag wurde am 23.10.2022 um 22:30 Uhr von Hojoe editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
043
23.10.2022, 23:44 Uhr
RobertK

Avatar von RobertK

Tatsächlich, es funktioniert grundsätzlich! Keine Ahnung, weshalb es damals bei mir nicht funktioniert hat, es gab damals überhaupt keine Reaktion.
Ja, die beiden Joysticks sind vertauscht, und der zweite Feuerknopf wird auch als Feuerknopf Nr. 1 interpretiert.
Wäre toll, wenn du das beheben könntest...
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
044
25.10.2022, 07:13 Uhr
Bert



Als Referenz-Testprogramm für Joysticks am Z1013 würde ich das hier nehmen:
http://z1013.mrboot.de/software-database/db/5591df18d0d6145646e91d54f4d0637a-joystick_demo/index.html

Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
045
25.10.2022, 09:31 Uhr
RobertK

Avatar von RobertK

Sehr schön! Und jetzt sehe ich, dass es in allen Varianten doch nur einen Feuerknopf gab, dann ist also die Vertauschung doch das einzige Problem.
Luxus wäre es, wenn auch die anderen Joystick-Varianten in z88dk als virtuelle Joysticks unterstützt werden, aber die Variante 1/88 sollte wohl reichen, zumal die ja offenbar am weitesten verbreitet war.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
046
25.10.2022, 09:48 Uhr
Bert



Wenn man sich die Z1013-Softwaredatenbank bzgl. der Joysticks mal näher anschaut, gibt es von vielen Programmen mehrere angepasste Versionen:
http://z1013.mrboot.de/software-database/db/index.html

Grüße,
Bert

P.S.: Ein Joystick am Z1013 dürfte auch keine große Verbreitung gefunden haben, da es die m.E. nicht wirklich zu kaufen gab. Ich habe Joysticks damals nur im Intershop gesehen, wenn überhaupt.
https://de.wikipedia.org/wiki/Intershop_(Handel)

Dieser Beitrag wurde am 25.10.2022 um 09:51 Uhr von Bert editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
047
25.10.2022, 11:39 Uhr
ralle



Der KC8/2 hatte optimal angeordnete Tasten. Dafür keinen expliziten Joystickanschluss. Der Modul kam erst in den Wendejahren. Beim Z1013 gibt es nicht nur viele Lösungen zum Joystick-Anschluss, sondern auch viele zum Stick selber. Das reichte sogar bis zu einer Maus.

Mist, immer noch nicht das Gamepad für den Z1013 gebastelt.
--
Gruß Ralle

Wenn Sie dazu neigen, Bedienungsanleitungen zusammen mit dem Verpackungsmaterial wegzuwerfen, sehen Sie bitte von einem derart drastischen Schritt ab!...
... Nachdem Sie das Gerät eine Weile ausprobiert haben, machen Sie es sich am besten mit dieser Anleitung und ihrem Lieblingsgetränk ein oder zwei Stunden lang in Ihrem Sessel bequem. Dieser Zeitaufwand wird Sie dann später belohnen...

aus KENWOOD-Bedienungsanleitung TM-D700
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
048
25.10.2022, 12:54 Uhr
volkerp
Default Group and Edit
Avatar von volkerp

Was ist ein EFs-Joystick?
Laut Joystick-Demo würde ich vermuten, dass hier ein practic-1/88-Joystick falsch herum gehalten wurde??
--
VolkerP

http://hc-ddr.hucki.net
(Z9001, Z1013, LC-80, ...)
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
049
25.10.2022, 13:59 Uhr
Bert



Ein ERF-Joystick wird ähnlich angeschlossen wie der Joystick nach practic 1/88.
Die Richtungen hoch, runter und links sind miteinander vertauscht.
Genutzt wird das in Programmen bzw. Spielen, die von 'IG ERF-soft' erstellt wurden.

Offensichtlich haben die Jungs aus Erfurt ihren Stick etwas anders vertüdelt.

Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
050
25.10.2022, 21:14 Uhr
Hojoe




Zitat:
Bert schrieb
Als Referenz-Testprogramm für Joysticks am Z1013 würde ich das hier nehmen:
http://z1013.mrboot.de/software-database/db/5591df18d0d6145646e91d54f4d0637a-joystick_demo/index.html



Sehr guter Link. Der Code beantwortet die Frage, welches Steuerbit für welchen Joystick verantwortlich ist.

Ich habe einen Pull Request mit den vertauschen Steuerbits erstellt: https://github.com/z88dk/z88dk/pull/2115

Holger
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
051
26.10.2022, 21:58 Uhr
Hojoe



Ich glaube es ist ein Fehler im JKCEmu in jkcemu.emusys.Z1013 in der Methode putJoyPractic0188ValuesToPort().

Quellcode:

  private void putJoyPractic0188ValuesToPort()
  {
    int value      = 0xFF;
    int joySel     = ~this.pio.fetchOutValuePortA( value );
    int actionMask = 0;
    if( (joySel & 0x20) != 0 ) {        // Joystick 1 selektiert
      actionMask |= this.joy0ActionMask;
    }
    if( (joySel & 0x40) != 0 ) {        // Joystick 2 selektiert
      actionMask |= this.joy1ActionMask;
    }
  ...



pio.fetchOutValuePortA( value ) liefert für Joystick 1 mit Ausgabe 0x20 auf die PIO den Wert 0x3F = 00111111 zurück. Durch die Negation entsteht daraus 0xC0 = 11000000. Damit greift dann aber das 2. if obwohl eigentlich der 1. Joystick abgefragt werden soll.

In meinen Augen ist die Negation falsch.

@Jens liest du noch mit? Kannst du das nachvollziehen?

Holger
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
052
02.11.2022, 17:37 Uhr
Dirk mit KC-4



Hallo,
ich habe mir gestern Abend diesen C-Compiler nightly runtergeladen und das Hallo Welt ausprobiert.
Die Zeile:

set path=%PATH%;%z88root%bin\
musste ich ändern, habe WinXP:
set path=%PATH%;%z88root%bin.x86\

raus kam die HalloWord.kcc

Fehlermeldung bzw. Warnhinweis beim Kompelieren kam dazu:

HalloWelt.c:5:9: warning: Implicit definition of function 'printf' it will retur
n an int. Prototype it explicitly if this is not what you want. [-Wimplicit-func
tion-definition]
HalloWelt.c:7:13: warning: Implicit definition of function 'fgetc_cons' it will
return an int. Prototype it explicitly if this is not what you want. [-Wimplicit
-function-definition]

Nun versucht diese HalloWord.kcc mit dem JKCEMU zu laden:
JKCEMU gestartet, KC84/4 ausgewählt, dann auf "Datei" "Laden" und die HalloWord.kcc ausgewählt und es passiert nix. Unten im JKCEMU steht noch:
"Datei nach 1000-1FF3 geladen", aber sonst passiert nix.

Was mache ich falsch, wie starte ich die .kcc mit dem JKCEMU richtig?
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
053
02.11.2022, 18:10 Uhr
Bert




Zitat:
Dirk mit KC-4 schrieb
Fehlermeldung bzw. Warnhinweis beim Kompelieren kam dazu:

HalloWelt.c:5:9: warning: Implicit definition of function 'printf' ...
HalloWelt.c:7:13: warning: Implicit definition of function 'fgetc_cons' ...


Auch wenn es nur Warnungen sind, hier sind sie gravierend.
Er findet printf und fgetc_cons nicht. Ersteres steckt in der stdio.
Wie genau hast Du den Übersetzungsvorgang gestartet?

Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
054
02.11.2022, 18:31 Uhr
Hojoe




Zitat:
Dirk mit KC-4 schrieb
ich habe mir gestern Abend diesen C-Compiler nightly runtergeladen und das Hallo Welt ausprobiert.


Seht gut :-)


Zitat:

set path=%PATH%;%z88root%bin\
musste ich ändern, habe WinXP:
set path=%PATH%;%z88root%bin.x86\


ja stimmt bei 32 Bit x86 Systemen ist das nötig.


Zitat:

HalloWelt.c:5:9: warning: Implicit definition of function 'printf' it will retur
n an int. Prototype it explicitly if this is not what you want. [-Wimplicit-func
tion-definition]
HalloWelt.c:7:13: warning: Implicit definition of function 'fgetc_cons' it will
return an int. Prototype it explicitly if this is not what you want. [-Wimplicit
-function-definition]

Nun versucht diese HalloWord.kcc mit dem JKCEMU zu laden:
JKCEMU gestartet, KC84/4 ausgewählt, dann auf "Datei" "Laden" und die HalloWord.kcc ausgewählt und es passiert nix. Unten im JKCEMU steht noch:
"Datei nach 1000-1FF3 geladen", aber sonst passiert nix.

Was mache ich falsch, wie starte ich die .kcc mit dem JKCEMU richtig?



Welches Hallo World hast du verwendet? Wie Bert schon geschrieben hat, es fehlt vermutlich am Anfang ein
Quellcode:
#include <stdio.h>


Alternativ habe ich hier auch ein https://github.com/Hojoe42/KC-z88dk-Demos/tree/main/HelloWorld Da gibt es auch ein paar Erklärungen zum Starten.

Der C Compiler erzeugt von sich aus keinen Eintrag im Menü. Daher kannst du dein Programm nicht manuell starten. Die KCC Dateien haben einen Autostart. Wenn du im JKCEmu 'Starten' anstelle von 'Laden' verwendest, dann solltest du auch etwas sehen können.

Um einen Menüeintrag zu erzeugen verwende ich üblicherweise folgenden Code am Anfang eines Programms:


Quellcode:
char START[] ={ 0x7f, 0x7f, 'T', 'E', 'S', 'T', 0x01, 0xcd, 0x00, 0x10, 0xc9 };



Damit wird ein Menüeintrag erzeugt und ein Sprung auf 1000H ausgeführt. Dort fangen die C Programme beim KC normalerweise an.

Holger

Dieser Beitrag wurde am 02.11.2022 um 19:15 Uhr von Hojoe editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
055
02.11.2022, 19:02 Uhr
Dirk mit KC-4



Dank für die Hilfe,

der Fehler oben ist weg, klar include fehlte.
Programm sieht nun so aus:


#include <stdio.h>

char START[] ={ 0x7f, 0x7f, 'T', 'E', 'S', 'T', 0x01, 0xcd, 0x00, 0x10, 0xc9 };

void main()
{

printf("\n\n\n\nHallo Welt!\n\n\n");
printf("Taste druecken zum Beenden...\n");
fgetc_cons(); // warte auf irgendeinen Tastendruck
}


Die char Zeile ist die richtig so, vor dem void main oder gehört die als erste Zeile in das void main?

Nun versucht diese HalloWord.kcc mit dem JKCEMU zu laden:
JKCEMU gestartet, KC84/4 ausgewählt, dann auf "Datei" "Laden" und die HalloWord.kcc ausgewählt und es passiert nix. Unten im JKCEMU steht noch:
"Datei nach 1000-2006 geladen", aber sonst passiert nix.
kein Menüeintrag nach einem reset. Wo liegt jetzt noch der Fehler?


Zitat:
Der C Compiler erzeugt von sich aus keine Eintrag im Menü. Daher kannst du dein Programm nicht manuell starten. Die KCC Dateien haben einen Autostart. Wenn du im JKCEmu 'Starte' anstelle von 'Laden' verwendest, dann solltest du auch etwas sehen können.



habe starten gefunden, erst Datei-Laden anklicken dann HalloWelt auswählen und dort Starten anklicken. Funktioniert :-)
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer

Dieser Beitrag wurde am 02.11.2022 um 19:15 Uhr von Dirk mit KC-4 editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
056
02.11.2022, 19:11 Uhr
Hojoe




Zitat:
Dirk mit KC-4 schrieb
...
Die char Zeile ist die richtig so, vor dem void main oder gehört die als erste Zeile in das void main?


Sieht für mich gut aus. Ich schreib das ebenfalls so. z.B. https://github.com/Hojoe42/KC-z88dk-Demos/blob/main/ClsTest/ClsTest.c


Zitat:

Nun versucht diese HalloWord.kcc mit dem JKCEMU zu laden:
JKCEMU gestartet, KC84/4 ausgewählt, dann auf "Datei" "Laden" und die HalloWord.kcc ausgewählt und es passiert nix. Unten im JKCEMU steht noch:
"Datei nach 1000-2006 geladen", aber sonst passiert nix.
kein Menüeintrag nach einem reset. Wo liegt jetzt noch der Fehler?



Hast du das Menü noch einmal aufgerufen? Der Menüeintrag erscheint erst beim manuellem Aufruf von MENU. Selbst wenn TEST noch nicht angezeigt wird, sollte bei Eingabe von %TEST<Enter> das Programm starten.

Holger
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
057
02.11.2022, 19:19 Uhr
Dirk mit KC-4




Zitat:
Hast du das Menü noch einmal aufgerufen? Der Menüeintrag erscheint erst beim manuellem Aufruf von MENU. Selbst wenn TEST noch nicht angezeigt wird, sollte bei Eingabe von %TEST<Enter> das Programm starten.



Funktioniert!!

Also entweder "Datei"-"Laden"-Datei auswählen, dann "Starten" anklicken

oder

"Datei"-"Laden"-Datei auswählen, dann "OK" anklicken
und MENU eingeben, dann TEST eingeben.
(warum heißt der Menüeintrag "Test" und nicht "HalloWelt"?
Kann ich im Quellcode das ändern, dass der Menüeintrag zu HalloWelt wird?)

Beides funktioniert :-)

Ich werde heute nacht noch etwas rum probieren, Fragen werden bestimmt noch weitere kommen, vielen Dank
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer

Dieser Beitrag wurde am 02.11.2022 um 19:25 Uhr von Dirk mit KC-4 editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
058
02.11.2022, 19:45 Uhr
Hojoe




Zitat:
Dirk mit KC-4 schrieb
(warum heißt der Menüeintrag "Test" und nicht "HalloWelt"?
Kann ich im Quellcode das ändern, dass der Menüeintrag zu HalloWelt wird?)



Was angezeigt wird ist hier definiert.

Quellcode:
char START[] ={ 0x7f, 0x7f, 'T', 'E', 'S', 'T', 0x01, 0xcd, 0x00, 0x10, 0xc9 };


Nach dem 2. 0x7f bis zu dem ersten 0x01 stehen die einzelnen anzuzeigenden Buchstaben. Achtung bei Kleinbuchstaben wird das Menüwort nicht angezeigt, das Programm lässt sich aber mit der passenden Eingabe starten.

Die genaue Beschreibung findest du im Systemhandbuch im Kapitel 3.4 Menükonzept. Das aktuelle findest du z. B. hier: http://www.kc85.info/index.php/download-topmenu/viewdownload/35-handbuecher/401-kc85-5-systemhandbuch.html

Holger

Dieser Beitrag wurde am 02.11.2022 um 19:46 Uhr von Hojoe editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
059
02.11.2022, 19:51 Uhr
Dirk mit KC-4



ok verstanden, danke.

Ich werde rumprobieren, Fragen kommen bestimmt noch einige :-)
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
060
18.11.2022, 00:37 Uhr
Dirk mit KC-4




Zitat:
https://www.robotrontechnik.de/html/forum/thwb/showtopic.php?threadid=20319

23 Quelltext-Focal Programme hab ich, die ich, incl. Hamurabi (und zusammen mit dem Original Focal-Handbuch von DEC) mal hier hochgeladen habe.
https://anonfiles.com/L2dfS9H2yb/Focal_Quelltexte_zip
https://1fichier.com/?l19wwxu6w6uvp0ng61dk


Zitat:
Da liegt es doch eher Nahe einen FOCAL-Interpreter für den KC85 zu entwickeln, um die Originale dort laufen zu lassen...




Ich hab mal etwas gestöbert und bin fündig geworden. Der Original source Code in C für den Focal-Compiler.
Focal wurde ja 1968 von der Firma DEC entwickelt. Ich denke mal Focal-81, ist die "letzte Version" von 1981.

Die Frage ist jetzt, ob jemand von euch aus diesen C sources mit Hilfe von z88dk eine KC85 /3 /4 Datei machen kann, natürlich am besten eine .kcc Datei

Ich hab das ganze mal hier hochgeladen:
https://anonfiles.com/M8jdZ9Hey2/focal_zip
https://1fichier.com/?wcdf253vspjkblgimzm5

in der focal.zip gefunden sich:
4x .c Dateien
2x .h Header Dateien, einmal die focal.h und einmal die proto.h

bekommt ihr daraus eine KC85 .kcc Datei?

zusätzlich sind noch 2 kleine Mathe Focal source-Programme dabei.
Dateiendung ist .foc
Oben in der .zip datei sind 23 Focal sources-Programme, hier nun 2 weitere, ergibt 25 Focal source-Programme. Eine Programmiersprache von der noch 25 Focal source-Programme erhalten sind, da soll noch einer was sagen..
Das ist ja schon fast Computer-Archäologie

Wäre natürlich toll, wenn ihr den Focal Compiler in c mit z88dk compelieren könnt und es dann einen Focal Compiler auf dem KC85 gibt
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer

Dieser Beitrag wurde am 18.11.2022 um 00:41 Uhr von Dirk mit KC-4 editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
061
18.11.2022, 08:51 Uhr
Bert




Zitat:
Dirk mit KC-4 schrieb
bekommt ihr daraus eine KC85 .kcc Datei?


Na ganz so einfach ist es nicht.

Selbst unter Linux compiliert das aktuell nicht, weil gets() mit C11 aus dem Standard geflogen ist:
https://en.wikipedia.org/wiki/C_file_input/output#gets

Außerdem muß für Datei einlesen auf dem KC85 ein Ersatz gefunden werden und man muß prüfen, ob die dynamischen Speicherzugriffe (malloc) funktionieren.

Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
062
18.11.2022, 10:30 Uhr
Dirk mit KC-4



ich hör schon ich hab im richtigen Thread gefragt :-)

aber dazu eine grundsätzliche Frage:
gets, Reads a byte string from stdin until a newline or end of file is encountered (deprecated in C99, removed from C11)
liest byteweise von stdin ein bis zu einer newline oder ende der Datei/File

warum haben die den Befehl rausgeschmissen? Das macht doch keinen Sinn Befehle rauszuschmeißen.

und wenn das bis zur Version c11 verfügbar war, macht es dann nicht Sinn für sich auf neue Versionen zu verzichten und bei c11 für sich privat zu bleiben?
(oder sich eine geänderte header datei .h zu basteln und da getc für sich weider einzufügen wenn man neue Versionen benutzt).
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
063
18.11.2022, 18:06 Uhr
Ordoban




Zitat:
Dirk mit KC-4 schrieb
warum haben die den Befehl rausgeschmissen? Das macht doch keinen Sinn Befehle rauszuschmeißen.


Wenn Befehle kreuzgefährlich sind, und immer wieder schlimme Fehler verursachen, dann schon.
Siehe https://www.proggen.org/doku.php?id=c:lib:stdio:gets
Zitat:

Quellcode:

gets() liest einen String durch Benutzereingaben ein. Da sie aber für ihre Pufferüberlaufsschwächen gefürchtet ist, sollte sie nie benutzt werden. Stattdessen sollte auf die Funktion fgets() ausgewichen werden.


--
Gruß
Stefan
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
064
18.11.2022, 18:56 Uhr
Dirk mit KC-4



Hallo,
die Seite proggen hatte ich beim suchen nach einem Grund schon gefunden und sogar so in etwa verstanden, was da steht. Übrigens gut beschrieben, auch mit dem Beispiel.

Aber dieses
Da sie aber für ihre Pufferüberlaufsschwächen gefürchtet ist, sollte sie nie benutzt werden. Stattdessen sollte auf die Funktion fgets() ausgewichen werden.

Möchtets du eine ehliche Meinung dazu hören?`Ich finds völlig übertrieben, es könnte passieren.. Dann sollen die Ängstlichen sich doch ne Schreibmaschine kaufen und ihre Computer verkaufen
Immer wenn ich so etwas lese, frage ich mich, würde Columbus heute überhaupt noch Männer für seine Mannschaft finden, die mit ihm bis zum Abgrund des Meeres segeln würde?
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer

Dieser Beitrag wurde am 18.11.2022 um 18:57 Uhr von Dirk mit KC-4 editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
065
18.11.2022, 19:54 Uhr
Ordoban




Quellcode:

char    abuf[128];            /* Ask buffer */
char    *ctp;                /* Current text pointer */
...
if (gets(abuf) == NULL) {



Sprich: wenn der Anwender des Programms mehr als 128 Zeichen (=anderthalbe Zeile) eingibt, dann wird der Zeiger *ctp überschrieben, und das Programm bzw. das gesamte System wird warscheinlich craschen.
Bei einem privaten Spielzeug-Rechner ist das vielleicht noch lustig, aber bei einem Produktiv-System ist das ein ernstes Problem. Und glaub ja nicht, dass niemand mehr Zeichen als notwendig in so ein Eingabefeld eingeben würde! Ich hab da schon Sachen gesehen...
Wenn mich jemand davor bewahrt, mir selber in Knie zu schießen, dann finde ich das schon OK. Es ist ja nicht so, dass es für gets keinen Ersatz gibt.
--
Gruß
Stefan
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
066
18.11.2022, 20:57 Uhr
Bert



So langsam sollte für das Thema mal ein neuer Faden aufgemacht werden.

Meinen Kollegen ist noch eingefallen, das man beim gcc die gewünschte Version angeben kann.
Mit einem zusätzlichen -std=c99 compiliert das dann und man kann damit auf der Kommandozeile spielen:

Quellcode:

$ ./focal                                                                                                                        
*lib call sieve.foc
*g
    2    3    5    7   11   13   17   19   23   29   31   37   41   43   47   53   59   61
   67   71   73   79   83   89   97  101  103  107  109  113  127  131  137  139  149  151
  157  163  167  173   179  181  191  193  197  199  211  223  227  229  233  239  241
  251  257  263  269  271  277  281  283  293  307  311  313  317  331  337  347  349
  353  359  367  373  379  383  389  397  401  409  419  421  431  433  439  443  449
  457  461  463  467  479  487  491  499  503  509  521  523  541  547  557  563  569
  571  577  587  593  599  601  607  613  617  619  631  641  643  647  653  659  661
  673  677  683  691  701  709  719  727  733  739  743  751  757  761  769  773  787
  797  809  811  821  823  827  829  839  853  857  859  863  877  881  883  887  907
  911  919  929  937  941  947  953  967  971  977  983  991  997
Number of primes in 2..1000 is 168



Wie wäre es denn Dirk, wenn Du Dich in den KC85 und den C-Compiler etwas einfuchst und das Ganze selbst versuchst zu portieren?

Viele Grüße,
Bert

Dieser Beitrag wurde am 18.11.2022 um 20:59 Uhr von Bert editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
067
18.11.2022, 21:04 Uhr
Dirk mit KC-4



siehst du es crasht und wie du schreibst, beim Privatanwender der das auch noch selber programmiert, der startet dann einfach das Programm neu, bzw. den Debugger und sucht den Fehler.

Das Argument "Beim Anwender.. in einer Firma" ist ein vorgeschobenes Argument. Weil Programme, bevor sie verkauft werden eigentlich ausführlich gestet sind, bzw. sein sollten. "Geben sie 1, 2 oder 3 ein" Der Bug-Tester gibt -1 ein, er gibt 4 ein, er gibt abc ein, er gibt +-* ein und schaut ob das Programm diese Fehleingaben abfängt.
Realistisch kosten Bug-Tester viel Zeit und auch viel Geld. Also gehen (oft) Programme raus die voller Bugs sind. Dann gibt es update von v1.01 zu v1.02 usw. Alles altbekannt.

Aus diesem Grund aber einen kompletten C Befehl zu entfernen halte ich für falsch. Ich hab gelesen der Compiler gab bei Benutzung von gets schon immer eine Warnung aus, der Profi-Entwickler der das beruflich macht, wird das also wissen, und diese trivalen Fehler wie Buffer overflow durch Falscheingabe von gets in der Fehlerabfrage abfangen.

Aber die Entwickler haben ab c11 getc entfernt, nun ist das so. Der Anwender kann das hinnehmen oder er verwendet eine alte stdio.h, wo gets noch drin vorkam.
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
068
18.11.2022, 21:08 Uhr
Dirk mit KC-4




Zitat:
Mit einem zusätzlichen -std=c99 compiliert das dann und man kann damit auf der Kommandozeile spielen:



Glückwunsch, das ist doch mal eine gute Nachricht.

Der Tag ist fast historisch, du hast jetzt auf deinem Computer einen lauffähigen Focal-Compiler!! und 25 Focal Quelltext Programme!
Zusammen archäologisch wertvoll, super selten!! - ernsthaft.

Wenn du den jetzt noch in den z88dk für den KC85 umsetzen kannst..
:-)

selber krieg ich das mit dem z88dk nicht hin, eine c. Datei kompelieren krieg ich ja hin, aber nicht 4 .c dateien. Wobei ich gar nicht weiß warum da überhaupt 4 .c Dateien drin sind.

Versuch bitte den Focal mit dem z88dk für den KC85 zu compelieren
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer

Dieser Beitrag wurde am 18.11.2022 um 21:12 Uhr von Dirk mit KC-4 editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
069
19.11.2022, 07:02 Uhr
Bert




Zitat:
Dirk mit KC-4 schrieb
Versuch bitte den Focal mit dem z88dk für den KC85 zu compelieren


Ne, selbst ist der Mann...
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
070
19.11.2022, 10:06 Uhr
Dirk mit KC-4



Bert, jetzt nicht dein ernst, oder? Ich schick dir das du sagst nein? Hättest du auch gleich sagen können..
Abgesehen davon weißt du ganz genau das ich das compelieren nicht hinbekomme, du hast hier ja weiter oben selbst gesehen das ich grad mit Mühe das hallo Welt hinbekommen habe.
Aber ist ok, alles Gute
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer

Dieser Beitrag wurde am 19.11.2022 um 10:08 Uhr von Dirk mit KC-4 editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
071
19.11.2022, 10:15 Uhr
Bert




Zitat:
Dirk mit KC-4 schrieb
Bert, jetzt nicht dein ernst, oder?


Doch. Ist es.

1. Ist es hier ein Hobby und keine Wunschhotline und
2. schrieb ich schon, das es m.E. nicht trivial ist, weil mindestens die Dateigeschichte angepasst werden muß.

Wenn Du wirklich etwas willst, dann knie Dich rein und tu was dafür. Wenn es dann klemmt, kannst Du immer noch Fragen stellen... (ohne Anspruch auf Dir genehme Antworten.)

Grüße,
Bert
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
072
19.11.2022, 10:22 Uhr
Dirk mit KC-4



ist ok, spar dir das weitere schreiben, ist durch
--
Ich kann 2 Dinge wirklich nur gut, zum einen war es die Fallschirmjägerei und zum anderen Computer. Fragt man, was ich nun besser kann, würden einige sagen das eine, andere würden das andere sagen. Aber im Grunde ist beides gleich: ein großes Abenteuer
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
073
22.11.2023, 20:32 Uhr
jmueller




Zitat:
Hojoe schrieb in [051]
Ich glaube es ist ein Fehler im JKCEmu in jkcemu.emusys.Z1013 in der Methode putJoyPractic0188ValuesToPort().

Quellcode:

  private void putJoyPractic0188ValuesToPort()
  {
    int value      = 0xFF;
    int joySel     = ~this.pio.fetchOutValuePortA( value );
    int actionMask = 0;
    if( (joySel & 0x20) != 0 ) {        // Joystick 1 selektiert
      actionMask |= this.joy0ActionMask;
    }
    if( (joySel & 0x40) != 0 ) {        // Joystick 2 selektiert
      actionMask |= this.joy1ActionMask;
    }
  ...



pio.fetchOutValuePortA( value ) liefert für Joystick 1 mit Ausgabe 0x20 auf die PIO den Wert 0x3F = 00111111 zurück. Durch die Negation entsteht daraus 0xC0 = 11000000. Damit greift dann aber das 2. if obwohl eigentlich der 1. Joystick abgefragt werden soll.

In meinen Augen ist die Negation falsch.

@Jens liest du noch mit? Kannst du das nachvollziehen?

Holger



Ich lese hier im Forum schon lange nicht mehr mit.
Nun bin ich aber über diesen Beitrag gestolpert und möchte,
wenn auch mit einem Jahr Verspätung, darauf antworten.

Hier kann man sich den Schaltplan des Joystick-Anschlusses ansehen:
https://hc-ddr.hucki.net/wiki/lib/exe/fetch.php/z1013/literatur/practic-88-113.jpg?cache=

Man sieht, dass die Kathoden der Dioden an den Joystick-Buchsen liegen.
Die Joysticks werden somit mit einem L-Pegel über PA5 bzw. PA6 aktiviert.
Und deshalb enthält mein Programmcode beim Zuweisen der Variable joySel
die Negation, da ich weiter unten nämlich mit
Quellcode:
!= 0

auf H-Pegel teste.
Ich könnte genauso gut auf die Negation verzichten und dann auf L-Pegel testen:


Quellcode:

  private void putJoyPractic0188ValuesToPort()
  {
    int value      = 0xFF;
    int joySel     = this.pio.fetchOutValuePortA( value );
    int actionMask = 0;
    if( (joySel & 0x20) == 0 ) {        // Joystick 1 selektiert
      actionMask |= this.joy0ActionMask;
    }
    if( (joySel & 0x40) == 0 ) {        // Joystick 2 selektiert
      actionMask |= this.joy1ActionMask;
    }
  ...



Das hätte exakt die gleiche Funktion (...und wäre vielleicht sogar logischer implementiert).
Ich bin und bleibe deshalb der Meinung, dass mein Programmcode im JKCEMU korrekt ist
und funktional 1:1 dem Schaltplan in der practic-Veröffentlichung entspricht.
Joystick 1 im JKCEMU ist der obere in dem Schaltplan.

Jens

Dieser Beitrag wurde am 22.11.2023 um 20:34 Uhr von jmueller editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
Seiten: -1-     [ Technische Diskussionen ]  



Robotrontechnik-Forum

powered by ThWboard 3 Beta 2.84-php5
© by Paul Baecher & Felix Gonschorek