C-Compiler für die C-Control

Hallo,

ich hab mir mal die Arbeit gemacht einen C-Compiler für die C-Control (Vor allem für den Robby, da ich den habe) zu schreiben. Er hat nen recht lustigen Namen bekommen, ccccc, was dann für C-Control/C-Cross-Compiler steht. ccc und cccc waren bei sourceforge.net, wo ich ihn als Projekt eröffnet habe, schon belegt :P
Derzeit ist nur eine Linux-Version verfügbar, werd mal schauen dass ich eine für Windows compilier aber ich bin hier ja hoffentlich nicht der einzige der Linux verwendet ;)
Ein Programmlader für Linux fehlt bis jetzt auch noch (Hab im Internet einen gefunden aber der funzt wohl nicht). Der sollte aber relativ schnell zu schreiben sein, werd ich demnächst mal machen. Daher muss man bis jetzt noch den originalen mit Wine ausführen oder ins Windows gehen.

Der Compiler hat mehrere Vorteile zum CC-Basic-Compiler von Conrad (Eigenlob stinkt aber egal :D) wie z. B. die Möglichkeit Schleifen mit mehreren Zeilen zu machen, Headerdateien einzubinden und richtige Funktionen zu schreiben.
Headerdateien für die Verwendung mit dem Robby und ein kleines Lauflicht-Beispielprogramm sind dabei. Die Assemblerroutinen hab ich verändert weshalb ihr diese mit hochladen müsst (Sind aber in der examples/01_leds.dat schon drin). Da ist jetzt um einiges mehr Platz für weitere Assemblerroutinen da ich die unwichtigen (bzw. durch die erweiterten Funktionen vom Compiler überflüssigen) rausgeworfen habe. Ist jetzt nur noch ein bisschen mehr als die Hälfte wie davor, 138 Bytes um genau zu sein.

Hilfe gibts bis jetzt noch nicht wirklich eine. In der Readme stehen ein paar grundsätzliche Sachen und Funktionen (Die schon ein Stück weit reichen wenn man C bereits kann), die ist aber auch noch nicht fertig geschrieben.

Bugs sind warscheinlich noch haufenweise drin aber ihr könnt ihn ja mal testen (Falls ihr Linux habt) und sagen wie er euch bis jetzt gefällt.

Hier die URL: http://sourceforge.net/project/showf...roup_id=165854

PS.: Ich übernehm keine Garantie dass er funzt wie er soll und euer Robby nicht durch nen Bug die Treppe runter fährt oder sonstwas macht ;)

Hab jetzt die Windows-Version fertig gebracht. Hat ne Weile gebraucht weil ich die letzten Tage fast keine Zeit gehabt hab und zuerst noch nen Bug drin gehabt hab der im Windows ein schönes Fehlerbericht senden Fenster verursachte ;)

Die Packete wo es gibt sollten sich durch den Namen selbst erklären, aber trotzdem: Das -linux ist fürs Linux, das -win32 fürs Windows und das -src ist der Quellcode falls sichs jemand selber compilieren will ;)

Entpackt das Archiv einfach in irgendeinen Ordner und geht in der Konsole (Oder Eingabeaufforderung im Windows) in das Verzeichnis und gebt dort:
bin/ccccc -a asm/ccrp5.s19 -l examples/01_leds.c
bzw. für Windows:
bin\ccccc.exe -a asm/ccrp5.s19 -l examples/01_leds.c
ein, damit könnt ihr das Testprogramm compilieren und die Assemblerroutinen in die ausgegebene dat-Datei einbinden (Das geht nicht wie im CCBASIC im Quellcode, da man den sonst immer ändern muss, sondern über den Parameter -a).

Falls ihr irgendwas nicht kapiert könnt ihr hier gern fragen.

edit: Ich hab mal ein pdf-Handbuch erstellt, das gibts auch auf der Download-Seite weiter unten bei handbook
noch ein edit: Im Linux-Archiv lief wohl was schief, deshalb war der Ordner gleich 3x drin. Habs geändert.

Ich hab inzwischen den Data-Loader fertig gebracht, geht grad alles nicht so schnell weil ich bei dem Wetter auch besseres zu tun hab ;)
Der Data-Loader ist nur für Linux verfügbar da eine Windows-Version aufgrund des Zugriffs auf den COM-Port nicht so einfach geht und es unter Windows ja bereits CCDL.EXE direkt von Conrad gibt (Wenn ihr die Programme mit der Robby Installations-CD installiert liegt er im Installationsordner unter CCE glaub ich).
Um das Beispielprogramm unter Linux mit dem Data-Loader hochzuladen geht ihr wieder mit der Konsole in den ccccc-Ordner und gebt dort folgendes ein wenn euer Robby an COM1 hängt:
bin/ccdl -d /dev/ttyS0 -sc examples/ccrp5/be/01_eleds.dat
Für COM2 z.B. braucht ihr -d /dev/ttyS1

Nen Header für den Robby mit Basiserweiterung hab ich auch noch erstellt.
Mit nem neuen Handbuch schauts noch schlecht aus, werd ich demnächst mal schreiben.
Der Assemblertreiber für den Robby ist noch ein bisschen geschrumpft da ich 2 sinnlose Zeilen raus hab. Er hat jetzt noch 134 Byte.

P.S.: Ihr dürft hier immer noch gern eure Meinung schreiben oder Fragen stellen ;)

Wow, da hast du dir ja heftig Arbeit gemacht!

Wie ich sehe hast du alles selber implementiert, angefangen beim Lexen und Parsen...

Jup, war schon ein gutes Stück Arbeit. Ist eigentlich mein erstes richtiges Programm in C++ :)

Die ccintern-Infosammlung hat mir einiges dabei geholfen, saupraktisch um die C-Control genauer zu erforschen, kann ich nur empfehlen. Die Idee für die erweiterten Funktionen wie z. B. setregister und getregister hab ich auch dort abgeschaut.

Naja, von der CC hab ich keine Ahnung, eher etwas Einblick in Compilerbau.

Ich hoff ich habs halbwegs so gemacht wie es üblich ist, hab nämlich einfach "drauf los" programmiert ohne davor irgendwelche speziellen Compilerbau-Bücher o. ä. zu lesen O:)

edit: Hab ein neues Handbuch hochgeladen, dort sind auch die Header-Dateien erklärt.

Ich hab eine neue Version mit nem neuen Data-Loader fürs Linux und Header-Dateien mit weniger Bugs gemacht (Da ging eigentlich das meiste garnicht wirklich :P)

Am Handbuch hat sich auch ein bisschen was verändert.

Ich hoff jetzt sind die Headers bugfrei, ich hab noch 2 Beispielprogramme gemacht die gut funktioniert haben (ACS und Motoren).

edit: In den Assemblerroutinen war auch ein Bug, also bitte neu hochladen.

Hallo Olli,

ich finde Deinen Compiler recht gut. Da hast Du Dir richtig viel Arbeit gemacht (ich weiß wovon ich spreche ;) ) Auch die Tatsache, dass Dein Compiler Open Source ist spricht meiner Meinung nach für das Projekt. Mir ist jedoch aufgefallen, dass der Compiler teilweise merkwürdigen Code erzeugt.

Code:

---

void main(){
 int[0] i = 1;
}

void x(){
int[0] i = 1; return i;
}


CCTRL-BASIC
19
20 0 1 0 26 0 0 255 20 0 1 0 26 0 0 23 0 6 6
0

---

Sofern die "0" nach jeder Anweisung ignoriert würde (ob das bei allen Controllern so ist, kann ich nicht sagen) ist das zusätzliche Zeichen zumindest ineffizienter.

Außerdem frage ich mich, ob der Compiler nicht innerhalb einer VOID Funktion ein RETURN mit Rückgabewert verbieten sollte.

Wie sieht es eigentlich mit Pointern und structs aus. Geht das? Ich fürchte, dass man zumindest Pointer mit unter nur mit zusätzlichen Assemblerroutienen realisieren kann.

Gruß,

Stefan

Oh, da muss ich mal schauen was da schief läuft, danke dass du mich drauf aufmerksam gemacht hast. Vielleicht ists nur im Windows, da hätte ich es selber warscheinlich ewig nicht gefunden...
Die 0 wird aber von der C-Control 1.1 ignoriert (Sowas wie NOP in Assembler), weshalb die Programme trotzdem laufen sollten (Aber wie du schon sagtest, die verlangsamt das ganze und muss raus).

Das verbieten von einer Rückgabe in void-Funktionen werde ich noch reinbauen, da der Compiler in der Alpha ist fehlen da noch einige Warnungen die rein sollten.

Pointer gehen leider allein mit den Tokens der C-Control nicht, müssen also mit Assemblerroutinen realisiert werden.
structs werde ich später noch implementieren, ich schreibs hier rein sobald ich es hab (Kann aber noch eine Weile dauern).

edit: Hab den Bug gefunden, die Nullen waren einmal beim Befehl und einmal bei der Adresse davor drin wenn die Variable direkt bei der Deklaration initialisiert wurde. Ich mach noch ne Fehlermeldung rein wenn ne void etwas zurückgeben soll und lad es dann hoch.

Code:

---

CCTRL-BASIC
15
20 0 1 26 0 255 20 0 1 26 0 23 0 6 6
0

---

Hallo Olli,

was die Pointer angeht, so kannst Du zumindest auf der 2.03 und 2.04 davon ausgehen, dass der Controller das kann. Schau dir mal den Quellcode von BASIC++ an. Dort ist in der TokenToName.bas eine Tokenübersicht gegeben. Die Pointer Token lauten 36 x. Vielleicht ist das was für Dich.

Gruß,

Stefan

Hallo Stefan,

Danke für die Info, werd vielleicht später mal den Compiler auch mit speziellen Funktionen von der CC 2.x ausrüsten (Hab selber nur den Robby mit der CC 1.1, mal schauen wie ich das anstell da ich keine CC 2.x zur Verfügung habe oder gibt es irgendwo einen Simulator mit dem ich die dat-Datei direkt testen kann?).

Wie schaut es dann eigentlich mit dem Handshake-Befehl von der CC 1.1 aus, der hat auch das Token 36 (Conrad schreibt doch eigentlich die CC 2.x wäre vollständig abwärtskompatibel zur 1.1).

Den Quelltext zum BASIC++-Compiler hab ich runtergeladen (Musste die exe zwar erst mal mit Wine ausführen aber hat gefunzt). Schaut nützlich aus und ich find mich halbwegs zurecht drin obwohl ich mit VB schon länger nicht mehr programmiert hab ;)

Hab die neue Version ohne den Bug und mit Fehlermeldung bei void-Funktionen mit Rückgabe hochgeladen.

edit: Hab grad gesehen dass ich vergessen hab beim Compiler die Versionsnummer zu aktualisieren, jetzt wird immer noch 0.1.0.1 angezeigt und die _CCCCC_-Konstante hat auch den falschen Wert. Aber es ist die Version 0.1.1.3 auch wenn sie es selber noch nicht weiß ;)

Zitat:

---

Zitat von OlliH

Ich hoff ich habs halbwegs so gemacht wie es üblich ist, hab nämlich einfach "drauf los" programmiert ohne davor irgendwelche speziellen Compilerbau-Bücher o. ä. zu lesen O:)

---

Üblich ist das, was man tut ;-)

Wenn man alles selber macht ist der Lerneffekt zumindest am grössten und man muss sich nicht mit fremdem Zeug rumschlagen.

Gerne wird bei solchen Aufgaben ein existierender Compiler genommen und angepasst. Genaugenommen ist dein Compiler kein Compiler, sondern ein Transpiler, wenn ich's recht sehe: er soll C-Code nach BASIC (Byte-)Code übersetzten.

Als freien, anpassbaren C-Compiler wäre der tcc (tiny C compiler) zu erwähnen. Da muss man für unterschiedliche Aufgaben Ausgabe-Schnippsel angeben. Die werden in den Ausgabe-Strom als ASCII, Object-Code oder was immer man gerne hätte, eingefügt.

Du wirst bei deinem ccccc gemerkt haben, daß es eine recht aufwändige und nervige Angelegenheit ist, den Eingabestrom (Quelle) in eine brauchbare interne Darstellung zu bekommen und Syntax-Fehlermeldungen mit der richtigen Stelle anzeigen zu lassen. Wenn z.B eine schliessende Klammer fehlt, und man merkt das erst am Ende der Datei, dann sucht sich der Anwender den Wolf nach der Stelle, wenn der Fehler immer das Dateiende angibt.

Nun sind alle Programmiersprachen auf einer sprachlich-formalen Ebene ziemlich gleich. Man definiert dort z.B., wie ein gültiger Ausdruck aussieht:

So sind alle Zahlen und Variablen gültige Ausdrücke. Steht A für einen Ausdruck, dann erhält man weitere gültige Ausfrücke (in C), indem man gültige Ausdrücke weiter kombiniert:
A -> A + A
A -> A * A
A -> A / A
A -> A - A
A -> - A
A -> (A)
A -> (A) ? A : A
...
Indem man die Regeln nacheinander anwendet, kommt man zu allen möglichen (unendlich vielen) Ausdrücken, die die Sprache erlaubt, etwa
A+A*(A+(A/A))-A
Die Regeln, nach der ein neues A aus vorhandenen gebildet werden kann, sind leicht zu durchschauen. Ein Compiler muss aber zu Anfang den umgekehrten Weg gehen. Aus einer Zeichenkette muss die Struktur des Ausdrucks wiederhergestellt werden. Das ist eine recht nervige Angelegenheit, die schnell unübersichtlich wird. Änderungen sind da nur schwer einzuflicken.

Zu diesem Zwecke gibt es fertige Parser wie zB den bison. Bison wird mit der Sprachbeschreibung gefüttert! Also damit, wie die Sprache entsteht, ohwohl er genau die umgekehrte Aufgabe zu lösen hat! Zudem kann man für Operationen Prioritäten angeben, so daß ein
a+b*c nicht gelesen wird wie ein (a+b)*c, wie es billige Taschenfalschrechner gerne machen.
Was für Ausdrüche zutrifft, gilt auch genauso für einen C-Block, eine C-Funktion, Argumentliste, Deklaration, Definition, etc. Man sagt dem Parser nur, wie sie gebildet werden, und er dröselt die Quelle dementsprechend auf.

Zur Vorverdauung lässt man lex oder flex die Eingabe in Tokens (Schlüsselworte) zusammenfassen. flex kann man in verschiedenen Modi betreiben: in einem Kommentar oder einem String haben Zeichen eine andere Bedeutung als ausserhalb. Kommentare in Strings oder Strings im Kommentaren oder Kommentare in Kommentaren sind damit leicht und übersichtlich zu handhaben.

Die Tokens werden an bison geliefert, den man verwendet, um das Programm intern Darzustellen: Anweisungen, Ausdrücke, Deklaratoren, etc.

Dadurch kann man sich beim Compilerbau ganz auf die eigentliche Aufgabe konzentrieren.

Übrigens gibt es auch Parser und Lexer für andere Sprachen als C, etwa jflex und cup für Java.

Zitat:

---

Zitat von SprinterSB

Zitat:

---

Zitat von OlliH

Ich hoff ich habs halbwegs so gemacht wie es üblich ist, hab nämlich einfach "drauf los" programmiert ohne davor irgendwelche speziellen Compilerbau-Bücher o. ä. zu lesen O:)

---

Üblich ist das, was man tut ;-)

Wenn man alles selber macht ist der Lerneffekt zumindest am grössten und man muss sich nicht mit fremdem Zeug rumschlagen.

---

Das stimmt und am Ende merkt man nicht selten, dass seine eigenen Lösungen oft Ähnlichkeit zu Lösungstrategieen haben, die auch konventionell eingesetzt werden.

Gruß,

Stefan

Danke für die kleine Einführung in fertige Compilerteile. Wenn ich mir das so anschau kommt es mir so vor dass es mehr Arbeit wäre wenn ich fertige Sachen nehme wie wenn ichs komplett selber schreib :D
Und wie du schon sagtest, der Lerneffekt ist der größte wenn ichs komplett selber schreibe.

Zitat:

---

Zitat von SprinterSB

Genaugenommen ist dein Compiler kein Compiler, sondern ein Transpiler, wenn ich's recht sehe: er soll C-Code nach BASIC (Byte-)Code übersetzten.

---

Doch, ist schon einer (Falls ich es recht sehe ;) ). Ein Transpiler würde ja den C-Quelltext in BASIC-Quelltext umwandeln. Der ccccc macht aber aus dem C-Quelltext Bytecode (Befehle für die C-Control, z. B. sowas wie das Byte 20 und danach in 2 Bytes einen Integer um etwas in den Rechenstack zu schieben).

Würde ihn mal nach Wikipedia als Single-pass-Cross-Compiler einordnen :D

Also wenn ich die Definition noch richtig im Kopf habe beschreibt ein Compiler einfach ein Programm, dass von einer Quellsprache in eine Zielsprache übersetzt. Im Deutschen nennt man das daher auch übersetzter. Daher sollte CCCCC ein Compiler sein, zumal Bytecode ja auch vom Java Compiler erzeugt wird.

Stimmt, eigentlich ist ein Transpiler (Abk.: Transcompiler) ja nur eine Sonderform eines Compilers aber auch ein Compiler. Aber da der ccccc Bytecode erzeugt ist er, wie der Java-Compiler, sowieso einer.

Aber ist auch relativ Wurst was es für ein Compiler ist ;)

Habe gerade die erste Beta-Version hochgeladen

Hier die wesentlichen Neuerungen:
- Die wichtigsten Direktiven (z. B. #ifdef, #ifndef, #elifdef und andere) sind verfügbar
- Alle Funktionen für die serielle Schnittstelle sind implementiert
- Ausgabe der Daten wahlweise als normale dat, im Intel-Hex-Format oder auch wie die Assemblerdaten im Motorola S-Record Format
- Der Data Loader kann Daten hoch- und runterladen in allen drei Formaten

Ich hoffe im Windows werden die Umlaute nun richtig dargestellt, bin jetzt zu faul es selber zu testen aber es sollte eigentlich nun passen.

Das Handbuch ist auch wieder ein bisschen gewachsen, gibts wie immer weiter unten auf der Downloadseite

Hi,
kann mir einer ein Code-Beispiel geben, bei dem der ACS-Interrupt genutzt wird bzw. mir erklären, wie ich eine Funktion schreiben kann, die bei einem Interrupt ausgeführzt wird?

Hallo Flash_64,

Interrupts kann der Compiler bis jetzt noch nicht. Ich schau mal dass ich bis zur nächsten Version Interrupts implementiere. Ich werde dann auch ein Beispielprogramm beilegen wo das Verwenden von Interrupts erklärt wird.

Wenn eine neue Version draussen ist schreib ichs wieder hier rein.

alles klar. Ich danke dir schonmal im vorraus.

sind eigentlich case-anweisungen implementiert, oder muss man äquivalente if-anweisungen nutzen?

bei dem versuch eine case-anweisung (nach iso-c) zu implementieren, gab der compiler mir eine fehlermeldung...

case fehlt bis jetzt auch noch, musst du also bis jetzt mit if-Anweisungen machen. Wird es warscheinlich frühestens in der übernächsten Version geben.
In der nächsten kommt jetzt erst mal eine Formeloptimierung rein (Dann wird z. B. auch 5 + 5 als konstanter Wert genommen weil der Compiler es gleich ausrechnet) und mit & vorne dran kann die Adresse von einer Variablen oder einer Funktion abgefragt werden. Dann ist nicht mehr viel zu machen dass auch der Interrupt verwendet werden kann.
Aber es kann noch ne Weile dauern bis eine neue Version rauskommt, mal schauen ob ich sie bis zum 20. fertig hab, ab dem 21. bin ich nämlich ne Woche weg und dann würde das ganze noch ein Stück in die Länge ziehen.

Ansonsten hat bis jetzt alles geklappt, oder?

ich werde heute abend noch ausgiebig programmieren und geb dir danach nochmal eine antwort

Die neue Version (2.1.0) ist endlich fertig. Hat jetzt verdammt lange gedauert da ich Abi usw. gehabt hab, ne Weile im Urlaub war und bei dem Wetter nicht so viel Lust hatte. Eigentlich hatte ich vor gestern damit fertig zu werden aber da hab ich Abends bis um 12 Zeugnisausgabe und was dazu gehört gehabt.
In der neuen Version ist wie schon gesagt die Formeloptimierung drin, es können mit & vorne dran die Adressen von Variablen und Funktionen ermittelt werden und Interrupts sind möglich. Wie immer ist alles weitere im Handbuch erklärt.
Der Quelltext ist bis jetzt nicht verfügbar da ich da noch ein paar Probleme habe aber ist auch nicht so sonderlich wichtig.

Wenn ihr irgendwelche Bugs findet könnt ihr euch melden, viel Spaß beim Programmieren ;)
Hier noch der Link zu den Downloads: http://sourceforge.net/project/showf...roup_id=165854

Guten Tag! Ich muss erstmal sagen, dass ich den ccccc (übrigens ein wundervoller name :P ) echt ziemlich genial finde, C is meiner Meinung nach wirklich ein wenig besser für sowas^^
naja, was solls, auf jeden fall hab ich da ein kleines Problem, weil ich irgendwie nich wirklich eine gute abfrage der ACS-Sensoren hinbekomme....wie habt ihr das implementiert bzw. mit welchen funktionen war das gedacht? also wie gesagt, ich finde bisher alles echt klasse was du geleistet hast mit dem ccccc, aber damit hab ich irgendwie meine probleme^^ (liegt wahrscheinlich nur daran dass ich was überlesen habe oder einfach nen kleinen denkfehler habe...:P)

Sorry, ein bisschen (oder eher ziemlich) spät aber:

Du kannst erst mal die Empfindlichkeit mit acs_power() einstellen, einfach als Argument ACSLO, ACSHI oder ACSMAX angeben.
Dann wird mit subsys_getstate() beim Subsystem der Status abgefragt, in dem zurückgegebenen Byte sind auch 2 Bits für die Abstandssensoren dabei (Bit 0 und 1).

Entweder kann man also wie im Beispiel 02_acs.c Bitvariablen an der gleichen Stelle im RAM wie eine Bytevariable anlegen. Wenn man dann das zurückgegebene Byte in die Bytevariable speichert kann man über die Bitvariablen die Bits für die Sensoren abfragen.

Eine andere Möglichkeit ist über ein binäres Und das einzelne Bit aus dem Byte zu holen. Also z. B. so:

Code:

---

if(subsys_getstate() & SS_ACSL)
{
  // Sachen die er machen soll wenn der linke Sensor anspricht
}

---

SS_ACSL ist auch eine in ccrp5.h definierte Konstante.

Die obere Methode ist sinnvoller normalerweise weil man einmal den Status abfragt und die Bit-Variablen danach so oft nimmt wie man will. Die zweite Möglichkeit macht eigentlich nur Sinn wenn man nur einmal einen Sensor abfragen will und das kommt wohl so gut wie nie vor.

Also einfach eine Bytevariable machen und 2 Bitvariablen, machen wir mal auf Byteadresse 4:

Code:

---

char[4] subsysstate;
bool[32] acsl, acsr;

---

32 weil du ja immer * 8 nehmen musst wegen Byte/Bit.

Und dann die Rückgabe von subsys_getstate() in die Bytevariable schreiben damit die aktuellen Sensordaten drin sind.

Code:

---

subsysstate = subsys_getstate();

---

Danach kannst du aus acsr und acsl die Sensorzustände rauslesen wo du willst, war in den CCBASIC-Routinen glaub ich sogar auch so.

Ich hoffe du hast jetzt mehr kapiert, sonst kannst du gern nochmal fragen bei den Sachen die unverständlich waren, ich werd schauen dass ich ein Stück früher antworte ;)

Viel Spaß beim programmieren, Oliver

Herzlichen Danke für die (schnelle :P) Antwort...naja ich hab ja jetzt auch nich direkt geantwortet, was? also ich muss da mal gleich noch ein wenig rumprobieren, meine erste version hat nich ganz so gut funktioniert, aber das wird sicherlich ich weiß ja jetzt wenigstens wie ich das richtig machen kann^^

Hallo,
ich bin seid einigen Tagen stolzer Besitzer eines RP5.

Das Programmieren und Übertragen mit der Conrad-IDE funktioniert (LINUX+WINE).

An liebsten würde ich den RP5 mit C programmieren können nur leider kriege ich die Daten wohl nicht richtig auf den RP5.

also folgendes habe ich gemacht:
code übersetzen:
bin/ccccc -a asm/ccrp5.s19 -l examples/ccrp5/01_leds.c

AUSGABE:
Logbuchdatei: examples/ccrp5/01_leds.log
Quellcodedatei: examples/ccrp5/01_leds.c
Ausgabedatei: examples/ccrp5/01_leds.dat
Assemblerdatei: asm/ccrp5.s19

Dann der Übertragungsversuch:
bin/ccdl -d /dev/ttyUSB0 -sc examples/ccrp5/01_leds.dat

AUSGABE:
/dev/ttyUSB0: Port geöffnet
C-Control-Version korrekt
Programm wird ÃŒbertragen...
356 Bytes
Assemblerdaten werden ÃŒbertragen...
/dev/ttyUSB0i: Fehler: Timeout erreicht

wenn ich ein Linux von ttyUSB0 auf ttyS0 lege ist das Ergebnis das selbe nur ohne 'i' nach den Gerätenamen

Das Programm ohne '-a asm/ccrp5.s19' zu kompilieren funktioniert und auch bei der Übertragung gibt es dann keine Fehler aber der Robby macht dann rein gar nichts :-(

was mache ich falsch

Bitte helft mir, ich hab keine Lust das Ding mit BASIC zu programmieren.

Hallo,

ich bin sehr interessiert an deinem c compiler für den RP5.
Da hier ja nur Spezialisten versammelt sind, verzeit bitte schon im Voraus meine Unwissenheit.
Also ich komme mit der Kommandozeile für die Windows Eingabeaufforderung nicht so recht klar. Kannst du das eventuell noch mal genau schreiben, wie
das funktioniert? Außerdem habe ich nicht so genau gecheckt, was nach der Ausführung des Compilers geschieht. Wo legt er die Datei an, in der das compilierte Programm vorhanden ist.
Weist du zufällig wie das mit dem Loader von Conrad funktioniert, damit ich die Pragramme dann in den Robby bringe?

Danke für die Mühe

Bernhard