flexible Rotine schreiben, aber wie ?

[albundy]

Hallo,

ich arbeite mich gerade in die Atxmega Serie ein und suche nach einer Möglichkeit,
um den Printbin Befehl der Atmegas nachzuempfinden, da ich mit unterschiedlicher
Anzahl binäre Daten (Konstanten und Variablen) übertragen muss.

(Printbin wird bei Atxmegas im Moment noch nicht unterstützt)

Die Routine ist ja eigendlich sehr einfach.



_data = &HAA

+00000061: LDI R24,0xAA Load immediate
+00000062: STS 0x0101,R24 Store direct to data space

Printbin _data ; &HBB ; &HCC

+00000064: LDI R19,0x01 Load immediate
+00000065: LDI R26,0x01 Variable _data ins X-Register
+00000066: LDI R27,0x01

+00000067: CALL 0x00000076 Call subroutine

+00000069: LDI R24,0xBB Load immediate
+0000006A: CALL 0x0000007B Call subroutine

+0000006C: LDI R24,0xCC Load immediate
+0000006D: CALL 0x0000007B Call subroutine

+0000006F: NOP No operation
+00000070: NOP No operation
+00000071: NOP No operation
------------------------------------------------------------------------------------------
Do
Loop
+00000072: JMP 0x00000072 Jump

End
+00000074: CLI Global Interrupt Disable
+00000075: RJMP PC-0x0000 Relative jump
------------------------------------------------------------------------------------------
+00000076: LD R24,X+ Load indirect and postincrement
+00000077: RCALL PC+0x0004 Relative call subroutine

+00000078: DEC R19 Decrement
+00000079: BRNE PC-0x03 Branch if not equal
+0000007A: RET Subroutine return

+0000007B: LDS R0,0x00C0 Statusregister TxD
+0000007D: SBRS R0,5 springe wenn TxD Ready

+0000007E: RJMP PC-0x0003 sonst weiter Status abfragen
+0000007F: STS 0x00C6,R24 Daten senden
+00000081: RET Subroutine return



Aber ich frage mich, woran erkennt der Compiler, wie oft er die Subroutine für das
Senden aufrufen muss.
Um das ebenso flexibel umzusetzen fehlt mir im Moment eine Idee.

Vielleicht hat ja jemand einen Vorschlag.
Ich würde mich freuen.

[PicNick]

Bascom tut sich da leicht: Beim Kompilieren generiert er für jedes Argument für printbin einen Call auf die Printbin-Routine.
Also, in Wirklichkeit wird aus


PRINTBIN arg1 ; arg2; arg3
im Code
PRINTBIN arg1
PRINTBIN arg2
PRINTBIN arg3
PRINT <CRLF> ' (für den nicht angegebenen Strichpunkt)


Die Sache ist also nur über den Kompilier flexibel.

Um das nachzumachen, müsstest du eine Printbin-funktion stricken mit nur EINEM Argument und es dann eben so wie Bascom verwenden.

Um das zur LAUFZEIT flexibel zu machen, brauchst du einen CALL-Standard, der auch die Anzahl der Argument an die Funktion übergibt.
Erst dadurch kannst du auch nach der Funktion den Stack ordentlich zusammenräumen.

Ich würde raten, es lieber wie Bascom zu machen.

[albundy]

Hallo PicNick,


Beim Kompilieren generiert er für jedes Argument für printbin einen Call auf die Printbin

Das ist genau der springende Punkt.
Nach welchem Motto zählt Bascom die Argumente ?
Das ";" kann es ja nicht sein, denn das gibt es ja auch als Binär.


Um das zur LAUFZEIT flexibel zu machen, brauchst du einen CALL-Standard, der auch die Anzahl der Argument an die Funktion übergibt.

Die Anzahl der Argumente mit anzugeben ist nicht so optimal, da
ich vorher nicht weiss, wieviele es sind.
Das heisst ich müsste sie vorher noch zählen. Aber das eben sollte
die Subroutine selber auszählen können.
Das Problem ist nur, dass ich kein Trennzeichen definieren kann, da
von 0 bis 255 alles auftreten kann.

[PicNick]

Moment, mit direkt-binär is da nix. Du kannst nur Variable angeben oder eben &H00 oder sowas. d.h. der strichpunkt kann da nicht vorkommen

Übrigens: denk an die möglichkeit PRINT CHR(val) zu schreiben

[albundy]

Ich glaube wir reden aneinander vorbei.
Wenn der Compiler das ";" als Trennzeichen nimmt, wie kommt er dann mit
Printbin &H11;&H3B;&H11 klar ? &H3B ist das";" ???

Aber ich probiere im Moment eine andere Methode.
Ich erweitere die Xmega.lib um den Printbin Befehl.
Das hat den Vorteil, dass der Compiler den Befehl erkennt und
mit der Variablen oder Konstanten in R24 meine Routine anspringt.
Auch der Usart Kanal wird mit übergeben. Eigendlich schon recht komfortabel.
Mit einem Argument klappt das schon prima, nur mit mehreren Argumenten
springt er beim 2.Mal ein paar Bytes zu weit.
Ich muss mal probieren, ob der Abstand immer gleich ist, dann könnte ich
meine Routine anpassen. Wenn nicht dann ???

Hast du eine Ahnung wo Printbin definiert ist ?
In der Mcs.lib leider nicht.