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.