Kniffliges Assemblerprogramm

[Roland N. (eroli)]

Hallo zusammen,

ich hänge gerade an einem etwas kniffligem Assemblerprogramm...

An PortB und PortD sind LEDs angeschlossen und ich möchte nun so eine 
wandernde "Snake" mittels Timer2 über die LEDs huschen lassen.

Die LEDs sind so angeordnet:

PB0   PB1   PB2   PB3   PB4   PB5   PB6   PB7

PD0   PD1   PD2   PD3   PD4   PD5   PD6   PD7

Und die Schlange sollte sich so bewegen:

1   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0

dann

1   1   0   0   0   0   0   0
0   0   0   0   0   0   0   0

dann
1   1   1   0   0   0   0   0
0   0   0   0   0   0   0   0

dann
0   1   1   1   0   0   0   0
0   0   0   0   0   0   0   0

[usw]

0   0   0   0   0   1   1   1
0   0   0   0   0   0   0   0

dann
0   0   0   0   0   0   1   1
0   0   0   0   0   0   0   1

dann
0   0   0   0   0   0   0   1
0   0   0   0   0   0   1   1

dann
0   0   0   0   0   0   0   0
0   0   0   0   0   1   1   1

und so weiter. Am anderem Ende sollte sie wieder genau so umbrechen, wie 
schon vorgezeigt. Das sollte sich dann so lange wiederholen, bis Timer2 
gestoppt wird.

Ich habe versucht das Ganze mit 3 Registern zu lösen, aber noch läuft es 
nicht wirklich, habe auch eben wieder alles gelöscht, was ich schon 
hatte.

Hat einer von euch eine Idee, wie man das relativ eleganz umsetzen kann?

Ciao,
Roland

[Der E. (rogie)]

z.B. mit Tabellen kann man das sehr gut umsetzen.

[spess53 (Gast)]

Hi

Das knifflige ist eigentlich nur der Anfang. Die drei Bits über zwei 
Register rotieren geht so:

          ldi r16,7

aaa:      bst r17,7
          lsl r16
          rol r17
          bld r16,0
                      
          out PortB,r16
          out PortD,r17

          rjmp aaa

MfG Spess

[Uwe (Gast)]

mit rotieren bzw. shift operationen und pb7 wird immer an pd7 kopiert 
pd0 immer an pb0. Das solte reichen.

[spess53 (Gast)]

Hi

Mit 'Softstart':

         ldi r16,0b00000111
         clr r17
         out PortB,r17
         out PortD,r17

aaa:     tst r16
         breq aaa10

         lsr r16
         rol r17
         out PortB,r17
         rjmp aaa

aaa10:   bst r17,7
         lsr r16
         rol r17
         bld r16,7
         
         out PortB,r17
         out PortD,r16

         rjmp aaa10

MfG Spess

[Ralf (Gast)]

spess53 schrieb:
> Das knifflige ist eigentlich nur der Anfang. Die drei Bits über zwei
> Register rotieren geht so:

und warum nicht nur so?

  ldi r16, 7
  ldi r17, 0
xx:
  rol r16
  rol r17
  out PortB, r16
  out PortD, r17
  rjmp xx

[xydllfehltmalwieder (Gast)]

Kann man zweimal Rechtshift für negative machen? Wenn man zuerst 80 
eingibt, und zweimal für negative shiftet, erhält man die Hexwerte 
80->C0->E0. Dann normal nach rechts weiter shiften bis Übertrag ->Reg2. 
Reg1 normal weitershiften, reg2 wieder negativ shiften, dann normal, 
Übertrag nach reg1.

Ansonsten wäre das elganteste wohl 1 Register + Ladebefehle, z.B. mov 80 
nach reg1 mov C0 nach reg1 usw oder eben die Werte aus dem Speicher oder 
aus anderen Registern lesen.

[spess53 (Gast)]

Hi

>und warum nicht nur so?

Weil dann die 'Snake' teilweise nur 2 LEDs lang ist.

>xx:
>  rol r16
>  rol r17

Das Bit, das aus r17 ins Carry-Flag geschoben wird taucht erst beim 
nächsten Durchlauf in r16 auf. Außerdem stimmt der Anfang nicht. Die 
Vorgabe fängt nicht mit drei LEDs an.

MfG Spess

[bitte löschen (Gast)]

Ich würde das so machen:

Anfang:
 ldi r16,0
 ldi r17,0
 ldi r18,0
 rcall AusgabeUndWarten
 ldi r16,0b10000000
 rcall AusgabeUndWarten
 ldi r16,0b11000000
 rcall AusgabeUndWarten
 ldi r16,0b11100000
 rcall AusgabeUndWarten
Scheife:
 lsr r16 ; rechtes Bit ins C-Flag, 
 rol r17 ; C-Flag von rechts in r17 übernehmen, linkes Bit von 17 ins C-Flag
 ror r18 ; Dieses in Bit 7 von r18 merken
 lsl r16 ; nochmal nach links, um
 rol r18 ; das linke Bit aus r18
 ror r16 ; beim Rechtsschieben zu übernehmen
 rcall AusgabeUndWarten
 rjmp Scheife

[Thomas T. (knibbel)]

Hier eine Lösung für beliebige Anfangsbitmuster:

        LDI    r20,0b11100000
        LDI    r17,0
        LDI    r16,0

Loop:   MOV    r19,r20
        ANDI   r19,0b10000000
        MOV    r18,r16
        ANDI   r18,0b10000000
        OR     r18,r19

        LSL    r20

        LSR    r17
        OR     r17,r18
        ROL    r16

        OUT    PortB,r17
        OUT    PortD,r16
        RCALL  Wartendasonstzuschnell

        RJMP   Loop

Kurzer, knackiger Code! Ist sowas Kunst? :-)

Gruß, Thomas

PS: Kommentare hinter den Befehlen bitte als Hausaufgabe ... :-)

[Roland N. (eroli)]

         LDI    r20,0b11100000   ; beliebiges Anfangsmuster
         LDI    r17,0
         LDI    r16,0
 
 Loop:   MOV    r19,r20          ; Einmalige Einsengenerierung ("Softstart")
         ANDI   r19,0b10000000

         MOV    r18,r16          ; War bei mir immer 0? Oder zu kurz debugged?
         ANDI   r18,0b10000000

         OR     r18,r19          ; Hier haben wir genau so oft 0b1000 0000
                                 ; stehen, wie Einsen im Anfangsmuster sind

         LSL    r20              ; Anfangsmuster wegrotieren, damit stoppt
                                 ; einmalige Einsengenerierung ("Softstart")

         LSR    r17              ; Eigentliche Rotation

         OR     r17,r18          ; Ab dem dritten mal ohne Einfluss

         ROL    r16              ; Verschwundene Einsen wieder auftauchen lassen
 
         OUT    PortB,r17        ; Ausgabe
         OUT    PortD,r16
         RCALL  Wartendasonstzuschnell
 
         RJMP   Loop

> Kurzer, knackiger Code! Ist sowas Kunst? :-)
>
> Gruß, Thomas
>
> PS: Kommentare hinter den Befehlen bitte als Hausaufgabe ... :-)

So in ETWA ist mir der Code jetzt klar. Habe mir ne Din A4-Seite 
geschnappt und die Bitmuster Befehl für Befehl aufgeschrieben :-D

Wirklich sehr sehr clever, wie bist du auf diese Idee gekommen?

Damit hat Thomas das Rennen gemacht, dieser Snippet ist meinem Programm 
gelandet :-D

Vielen Dank für eure fleißige Hilfe :-)

[Thomas T. (knibbel)]

Gerngeschehen!

Wenn Bedarf besteht kann ich den Code gern Zeile für Zeile erklären. 
Aber erst morgen, ist schon spät (für mich...)

Gruß,
Thomas

[Thomas T. (knibbel)]

Roland Moch schrieb:
> OR     r17,r18          ; Ab dem dritten mal ohne Einfluss

Deine Kommentare sind leider nicht ganz korrekt.

Hier wird z.B. das Anfangsbitmuster (die ersten drei "1"-Bits), aber 
auch das MSB der unteren Zeile eingesetzt. Und zwar immer! Nur nach dem 
dritten Durchgang gibt es für das Anfangsbitmuster ausschließlich 
"0"-Bits. Die MSB aus der unteren Zeile kommen jedoch immer wieder...

Du solltest dir den Code wesentlich länger im Debugger (Simulator) 
anschauen...

Gruß,
Thomas

[Roland N. (eroli)]

Das wäre nett. Ich hab zwar oben einige Kommentare geschrieben, aber ich 
glaube die sind nicht alle 100%ig treffend.

Interessant wäre vielleicht auch dein Vorgehen gewesen, wie du auf diese 
Idee gekommen bist.

Nochmal Danke und eine gute Nacht :-)

[bitte löschen (Gast)]

Philipp Klostermann schrieb:
> Ich würde das so machen:
> ...

Ist natürlich quatsch, da die LEDs links das LSB haben.
Also logisch umdrehen:

Anfang:
  ldi r16,0
  ldi r17,0
  ldi r18,0
  rcall AusgabeUndWarten
  ldi r16,0b1
  rcall AusgabeUndWarten
  ldi r16,0b11
  rcall AusgabeUndWarten
  ldi r16,0b111
  rcall AusgabeUndWarten
 Scheife:
  lsl r16 ; "rechtes" Bit (HSB) ins C-Flag,
  ror r17 ; C-Flag von "links" in r17 übernehmen, "linkes" Bit von 17 ins
 C-Flag
  rol r18 ; Dieses in Bit 0 von r18 merken
  lsr r16 ; nochmal nach "links", um
  ror r18 ; das "linke" Bit aus r18
  rol r16 ; beim "Rechts"-schieben zu übernehmen
  rcall AusgabeUndWarten
  rjmp Scheife

Habe das ganze gerade noch im Debugger getestet, und es scheint zu 
funktionieren.

Ich frage mich nun, was an knibbels 9 Befehlen mit 5 involvierten 
Registern, die zu verstehen und zu kommentieren einigen schwer zu fallen 
scheint, so viel genialer (sorry: "knackiger") ist, als meine 6 Befehle, 
die mit 3 Registern klar und einfach ein paar Bits rotieren. und nicht 
mal einer Erwähnung wert zu sein scheinen. :-?

[spess53 (Gast)]

Hi

>Ich frage mich nun, was an knibbels 9 Befehlen mit 5 involvierten
>Registern, die zu verstehen und zu kommentieren einigen schwer zu fallen
>scheint, so viel genialer (sorry: "knackiger") ist, als meine 6 Befehle,
>die mit 3 Registern klar und einfach ein paar Bits rotieren. und nicht
>mal einer Erwähnung wert zu sein scheinen. :-?

Geht mir mit 4 Befehlen und 2 benutzten Registern auch so.

MfG Spess

[bitte löschen (Gast)]

OK, Du hast ein Register weniger, aber einen bedingten Sprung. Das mit 
dem T-Flag ist natürlich eine Idee. :) Ich werde das mal im Hinterkopf 
köcheln lassen.

Ich finde, dass sich die eigentliche Lösung zu vielen Threads irgendwo 
mittendrin befindet, und unbeachtet in Flame-Wars oder gegenseitigem 
Lobgehuddel anderer User untergeht. :D

[Roland N. (eroli)]

Hey Leute,

ganz ganz ruhig. Ich hab eure Lösungen auch zu Kenntnis genommen und mir 
überlegt sie einzubauen. Zumindest mit der Lösung von Spess ging es 
nicht soo einfach (da müsste ich noch ein zusätzliches Register 
einbauen), da ich das sonst mit meinem Timer nicht hinkriege.

Die 6 Befehle mit 3 Register sind bei mir SO auch nicht so einfach 
unterzubringen, da ich keine AusgabeUndWarten-Funktion habe, sondern 
einfach alles über den Timer machen will und da bräuchte ich dann auch 
wieder ein Register und mehrere Branches, damit ich das benutzen kann.

Natürlich ist das alles kein Aufwand das so umzubiegen, aber wozu, wenn 
Thomas Lösung quasi per Copy and Paste funktioniert...

Versteht mich nicht falsch, ich bin für jeden Beitrag dankbar ;-)

[bitte löschen (Gast)]

Roland Moch schrieb:
> , da ich keine AusgabeUndWarten-Funktion habe, sondern
> einfach alles über den Timer machen will und da bräuchte ich dann auch
> wieder ein Register und mehrere Branches, damit ich das benutzen kann.

Die mehreren Branches brauchst Du nur, um den Ablauf am Anfang zu 
realisieren. Ansonsten ist es doch egal, ob Du den Rumpf-Code in einer 
Schleife hast, oder aus einer ISR heraus aufrufst. Wozu brauchst Du dann 
ein zusätzliches Register? Als Flag, ob das Intro vorbei ist?

[Roland N. (eroli)]

Philipp Klostermann schrieb:
> Wozu brauchst Du dann
> ein zusätzliches Register? Als Flag, ob das Intro vorbei ist?

Ganz genau

[spess53 (Gast)]

Hi

>Philipp Klostermann schrieb:
>> Wozu brauchst Du dann
>> ein zusätzliches Register? Als Flag, ob das Intro vorbei ist?

>Ganz genau

Geht auch ohne.

MfG Spess

[Roland N. (eroli)]

spess53 schrieb:
>>Philipp Klostermann schrieb:
>>> Wozu brauchst Du dann
>>> ein zusätzliches Register? Als Flag, ob das Intro vorbei ist?
>
>>Ganz genau
>
> Geht auch ohne.

Und wie?

Worum geht es hier überhaupt noch? :-D

[bitte löschen (Gast)]

Es geht darum, auf ein unnötiges Flag zu verzichten.

Schau Dir mal folgende Tabelle an:

  r16      r17      r16 + r17 
  00000001 00000000 00000001 (1)
  00000011 00000000 00000011 (3)
Wiederholung:
  00000111 00000000 00000111 (7)
  00001110 00000000 00001110 (14)
  ...
  11100000 00000000 11100000 (224)
  11000000 10000000 01000000 (64, C)
  10000000 11000000 01000000 (64, C)
  00000000 11100000 11100000 (224)
  ...
  00000000 00000111 00000111 (7)
  00000001 00000011 00000100 (4)
  00000011 00000001 00000100 (4)
  Weiter mit Wiederholung

Die Bedingung in-Intro liegt vor, wenn r16 + r17 (vorzeichenlos) kleiner 
4 ist.

[Loonix (Gast)]

Roland Moch schrieb:
> Worum geht es hier überhaupt noch? :-D

Philipp Klostermann schrieb:
> Es geht darum, auf ein unnötiges Flag zu verzichten.

Jo, wenn schon Assembler dann gscheit.

[spess53 (Gast)]

Hi

>Und wie?

In dem du eine RAM-Zelle benutzt. Das Ganze als Interrupt:

         .dseg
intro:   .byte 1
         .cseg

         .....
         ldi r16,0b00000111
         sts intro,r16
         .....

interrupt:
         push r16
         in r16,SREG
         push r16
         push r17

         lds r16,intro

aaa:     tst r16
         breq aaa10

         in r17,PortB       ; Intro
         lsr r16
         rol r17
         out PortB,r17
         sts intro,r16
         rjmp aaa20

aaa10:   in r16,PortD       ; Rotieren
         in r17,PortB

         bst r17,7
         lsr r16
         rol r17
         bld r16,7
         
         out PortB,r17
         out PortD,r16

aaa20:   pop r17
         pop r16
         out SREG,r16
         pop r16
         reti

Außerhalb der Routine wird kein Register benötigt.

MfG Spess

[Roland N. (eroli)]

Also, da ihr mir keine Ruhe gelassen habt und ich die Erklärung mit der 
Tabelle von Philipp so gut fand, hab ich mir die für mich logischste und 
am einfachsten zu verstehende Lösung zusammengebastelt:

snake:   ;(befindet sich im Timer-Interrupt)
  mov temp, porb
  add temp, pord
  cpi temp, 4
  brsh nointro
    ; Schlange aufbauen
  com porb  ; Eine 1 rein
  lsl porb
  com porb
  out portB, porb
  out portD, pord
  rjmp exit
nointro:
    lsl porb ; "rechtes" Bit (HSB) ins C-Flag,
    ror pord ; C-Flag von "links" in r17 übernehmen, "linkes" Bit von 17 ins C-Flag
    rol temp ; Dieses in Bit 0 von r18 merken
    lsr porb ; nochmal nach "links", um
    ror temp ; das "linke" Bit aus r18
    rol porb ; beim "Rechts"-schieben zu übernehmen

  out PortB, porb
  out PortD, pord
  rjmp exit

Um ehrlich zu sein, denke ich, dass ich mich jetzt lange genug mit 
diesem Thema aufgehalten habe, nehmt es mir nicht übel ;-)

[bitte löschen (Gast)]

spess53 schrieb:
> In dem du eine RAM-Zelle benutzt.

Oder so. :)

Roland M. schrieb:
> Um ehrlich zu sein, denke ich, dass ich mich jetzt lange genug mit
> diesem Thema aufgehalten habe, nehmt es mir nicht übel ;-)

Wir auch. Dann kannst Du noch die paar Minuten investieren, meine 
abschließende Lösung zu inspizieren. :-)

Ich habe es jetzt wie folgt: (Debugger-getestet)

RESET: ldi r16,high(RAMEND); Main program start
  out SPH,r16 ; Set Stack Pointer to top of RAM
  ldi r16,low(RAMEND)
  out SPL,r16
  ldi r16, 0
  out TCNT2, r16
  ; ldi r16,(1 << CS22) | (1 << CS21) | (1 << CS20) ; prescaling = /1024
  ldi r16, (0 << CS22) | (0 << CS21) | (1 << CS20) ; no prescaling fürs Debuggen
  out TCCR2, r16
  ;Interrupt für Timer 2 Aktivieren:
  ldi r16, (1<<TOIE2)
  out TIMSK, r16

/* ; Für Echtbetrieb unkommentieren
  ldi r16,0xff
  out DDRB, r16
  out DDRD, r16
*/

   ldi r16,0
  ldi r17,0

  sei ; Enable interrupts

MAINLOOP:
  rjmp MAINLOOP
  
TIMER_ISR:
  ; folgende Abfolge:
/*
  r16      r17      r16 + r17 
  00000001 00000000 00000001 (1)
  00000011 00000000 00000011 (3)
Wiederholung:
  00000111 00000000 00000111 (7)
  00001110 00000000 00001110 (14)
  ...
  11100000 00000000 11100000 (224)
  11000000 10000000 01000000 (64, C)
  10000000 11000000 01000000 (64, C)
  00000000 11100000 11100000 (224)
  ...
  00000000 00000111 00000111 (7)
  00000001 00000011 00000100 (4)
  00000011 00000001 00000100 (4)
  ab hier Wiederholung
*/
  push r18
  in r18, SREG
  push r18
  sei ; Die eigentlichen Aufgaben nicht stören
  mov r18, r16
  add r18, r17
  cpi r18, 4
  brlo Timer_ISR_Intro
  lsl r16 ; "rechtes" Bit (HSB) ins C-Flag,
  ror r17 ; C-Flag von "links" in r17 übernehmen, "linkes" Bit von 17 ins C-Flag
  rol r18 ; Dieses in Bit 0 von r18 merken
  lsr r16 ; nochmal nach "links", um
  ror r18 ; das "linke" Bit aus r18
  rol r16 ; beim "Rechts"-schieben zu übernehmen
  rjmp Ende_Timer_ISR
Timer_ISR_Intro:
  sec
  rol r16
Ende_Timer_ISR:
; Für Echtbetrieb unkommentieren
  ; out PORTB, r16
  ; out PORTD, r17
  pop r18
  out SREG, r18
  pop r18
  reti

[Roland N. (eroli)]

Das komplette Programm wäre nicht nötig gewesen ;-)

  sec
  rol r16

Das hab ich jetzt noch übernommen (also eigentlich fast gleich :-D)

Nochmals Danke an alle Antwortenden und ich denke wir sollten das Thema 
jetzt ruhen lassen ;-)

Einen schönen, sonnigen Mittwoch an Alle :-)

[Ralf (Gast)]

Was, schon aufgegeben? ;-)
Wie sieht's mit einem Outro aus?

duck und wech...