LED´s sollen aufeinander zu laufen und "abprallen"

[Tim (Gast)]

hey, ich bin grad beim schreiben meines ersten eigenen programms und 
will erreichen, dass ein 4 bit lauflicht von led 7 nach led 4 läuft und 
dort "abprallt" udn wieder zurück zu 7 ... und imme rso weiter.

das gelcihe mit led 0 - 3.

also dass die 4 leds aufeinander zulaufen und aneinander "abprallen"..

hab leider erst geringe erfahrung im mc bereich und brauche dringend 
hilfe.


hier der code, der übrigends überhaupt nicht funktioniert !


.def rechts = R17       ;festlegen von register 16 als rechtslauf
.def links = R18      ;festlegen von register 17 als linkslauf
.def temp = R16        ;festlegen von register 15 als zwischenablage


  ldi temp, 0xFF      ;
  out DDRB, temp      ;ddrb als output festlegen

rechtslauf:

  ldi rechts, 0b0000111  ;bit für LED 8 (7) setzen

  dec rechts        ;erniedrige um 1

  eor rechts, 0b0000100  ;wenn rechts nidriger als "4" springe zu 
linkslauf

  breq linkslauf

  out PORTB, rechts    ;ausgabe des aktuellen wertes


linkslauf:

  ldi links, 0b00000000  ;bit für LED 1(0) setzen.

  inc rechts        ;erhöhe um 1

  eor links, 0b00000011  ;wenn links höher als "3" springe zu rechtslauf

  eor rechts, 0b0000100  ;wenn rechts nidriger als "1" springe zu 
linkslauf

  breq rechtslauf

  out PORTB, links    ;ausgabe des aktuellen wertes



Tim

[Tim (Gast)]

achja, stk500 atmel mega 8 515l

[Tim (Gast)]

hab die registe rnochmal geändert deswegen stimmt die erleuterung nicht!

[Stefan T. (_distance_07)]

Hallo Tim, ich bin zwaz auch erst seit gestern dabei, aber das dein Code 
nicht funktionieren kann, erkenne ich schon jetzt.

Die eor Verknüpfung ist so ..- glaube ich- ... auch nciht richtig.

Zumal du nicht festgelegt hast wann der wider zurücklaufen soll, sprich 
nahc dem Abprallen.

Wäre es nicht irgendwie einfacher, nen Wert festzulegen, der die ledßs 4 
mal nach recht und 4 mal nach links laufne lässt ? Und dass dan für 
beide Seiten ?


Aber ich kann dir da wirklich auch nicht helfen, da ich absoluter 
Neuling bin.


MFG

Stefan

[Magnus Müller (Gast)]

Tim wrote:
> achja, stk500 atmel mega 8 515l
                             ^^^^
                             Häää?

[Stefan T. (_distance_07)]

Das letzte soll nen "L" sein glaube ich... habe ich auch auf meinem 
Controller stehen

MFG

Stefan

[Thomas (kosmos)]

ldi temp, 0b10000001
out portx, temp

ldi temp, 0b01000010
out portx, temp

...
...

dazwischen halt entsprechende Pausen sonst siehst du von den geflimmere 
nichts

du kannst auch ein Bit nach links oder rechts schieben

ldi temp, 0b00000001
rol temp             ;dann wird daraus 0b00000010
out portx,temp
rol temp             ;dann wird daraus 0b00000100

eleganter wäre es aber du legst es in eine Tabelle und arbeitest mit dem 
Befehl lpm

zum umrechnen von binär nach dezimal kannst du einfach den Windows 
Taschenrechner in der Wissenschaftlichen Ansichst benutzen.

http://www.atmel.com/dyn/resources/prod_documents/doc0856.pdf 
Befehlsübersicht
http://www.atmel.com/dyn/resources/prod_documents/doc1233.pdf LPM 
Beispiel
http://www.atmel.com/dyn/resources/prod_documents/doc1925.pdf ziemlich 
zum Schluss ist das Beispielprogramm von Atmel das du dir dazu auch mal 
anschauen kannst

[Florian (Gast)]

Hallo Tim.

Probier mal das hier. Das müßte funktionieren

.include"m8def.inc"

.def  temp1  =  r16

.org 0x00
rjmp reset


reset:
;stack init
ldi  temp1,low(ramend)
out spl,temp1

ldi temp1,high(ramend)
out  sph,temp1

;portb als Ausgang
ldi  temp1,0b11111111
out  ddrb,temp1

;Hauptschleife

main:
ldi zl,low(tabelle*2);Zeiger auf tabelle laden
ldi zh,high(tabelle*2)

loop:
lpm temp1,z+;Wert aus tabelle holen
tst temp1;testen ob Wert 0 ist
breq main;wenn ja, neu anfangen
out portb, temp1;auf portb ausgeben
rcall pause;1 sek pause
rjmp loop;nächstes Muster ausgeben


;1 Sekunde Pause bei 8 Mhz
pause:
; ============================= 
;   Warteschleifen-Generator 
;     8000000 Zyklen:
; ----------------------------- 
; warte 7999992 Zyklen:
          ldi  R17, $48
WGLOOP0:  ldi  R18, $BC
WGLOOP1:  ldi  R19, $C4
WGLOOP2:  dec  R19
          brne WGLOOP2
          dec  R18
          brne WGLOOP1
          dec  R17
          brne WGLOOP0
; ----------------------------- 
; warte 6 Zyklen:
          ldi  R17, $02
WGLOOP3:  dec  R17
          brne WGLOOP3
; ----------------------------- 
; warte 2 Zyklen:
          nop
          nop
; ============================= 

ret



tabelle:
.db 0b10000001,0b01000010,0b00100100,0b00011000,0b00100100,0b01000010,0,0

gruß Florian

[Herr M. (herrmueller)]

Halli Hallo,

Tabellen oder Spaghetticode find ich zu langweilig zum lernen ;-)

Ich habe nach einigem Überlegen eine Schleifen-Lösung gefunden, da hat 
der Tim was zu knobeln:

  .def  Temp=  R16
  .def  Leds=  R17
  .def  Hilfs=  R18
  .def  Zaehl=  R19

RESET:                           
      ldi temp,low(Ramend)
      out SPL,temp
      ldi temp,high(Ramend)
      out SPH,temp

  ldi temp,$FF
  out DDRB,temp

Start:
  ldi Leds,$18
  ldi Hilfs,$18

  ldi Zaehl,6
Loop:
  out PORTB,Leds
                          ;rcall Delay  
  cpi Zaehl,4
  brge OutLoop
  add Leds,Hilfs
  lsl Hilfs
  lsr Leds
  rjmp Inloop
OutLoop:
  lsr Hilfs
  lsl Leds
  sub Leds, Hilfs
InLoop:
  dec Zaehl
  brne Loop

Endlos: rjmp Start

Das Programm kann man mit dem AVR Studio testen. Zum im Prozessor 
auführen -muss noch die Delay Routine eingefügt werden und für den 
STK500 die Leds invertiert werden, anstatt Out PortB,Leds :  mov 
temp,Leds -  com Temp -  Out PortB,temp



Zum Selbertüfteln hab ich keine Kommentare eingefügt. Viel Spass.

[Arno H. (arno_h)]

Hallo,
da die LED symmetrisch leuchten sollen, können jeweils 2 parallel 
betrieben werden und die Ansteuerung beschränkt sich auf das Hoch- und 
Runterzählen von 4 Ausgängen.

Arno

[whatever (Gast)]

Es gibt bei dem ganzen ein menschliches Problem. Das Gehirn kann 2 
Zustände in das Gesehene interpretieren: 2 LEDs die aneinander 
vorbeilaufen und 2 die aneinander abprallen. Welchen von beiden Du 
wahrnimmst ist sowohl zufällig als auch von äußeren Umständen 
beeinflussbar. Würdest Du zB einen kurzen Knackton ausgeben wenn die 
LEDs in der Mitte sind, würdest Du die Wahrnehmung vom abprallen 
erhöhen. Generell kannst Du mit diesem zweideutigen Muster aber keine 
eindeutige Wahrnehmung erzeugen!

[Chris (Gast)]

über mir: da is was dran :P

[Tim (Gast)]

vielen vielen dnak an alle die ihren senf dazugegeben haben.

.. das mit dem abprallen soll keine visuell reell wahrnehmbare sache 
sien, sondern möchte ich einfach mal versuchen etwas herum zu 
programmieren.

tim

[Gast (Gast)]

grübel machste kleine Gummi-Ringe um die LEDs, dann wird das mit dem 
Abprallen schon klappen. Aber wie kriegst Du sie dazu, auf ihren zwei 
ungleich langen Beinchen aufeinander zuzulaufen..? Schwierig, 
schwierig.. ;-)

Trotzdem schönes WE

[ju (Gast)]

an gast
mach dir ein gummiring an die birne, dann klappt es bei dir auch.
sonst bin ich immer höflich

[Christian L. (lorio)]

Es kommt drauf an...find ich:

1. o------o
2. -o----o-
3. --o--o--
4. ---oo---
5. --o--o--
6. -o----o-

Ich fine dies erzeugt eher den "Abprall-"Effekt, und:

1. o------o
2. -o----o-
3. --o--o--
4. ---oo---
5. ---oo---
6. --o--o--
7. -o----o-

erscheint mir eher als "Durchlauf-"Effekt.

Gruß
Christian

[Michael G. (linuxgeek)]

Das koennte optisch wirklich krass sein... das muss ich doch glatt mal 
ausprobieren ;)

[Michael G. (linuxgeek)]

Schaut Euch das mal an: ich sehe einen Abpralleffekt. Sieht jemand von 
Euch den Lauf-Effekt?

http://coremelt.net/passthrough.php?path=files%2Fpics%2Fvideos%2Favr%2Fbouncing_leds.avi

[Oops (Gast)]

Ich finde die Geschwindigkeit zu gleichmäßig um den Abpralleffekt 
erkennbar zu machen.
Das Abprallen in der Realität beruht ja auf Elastizität und 
Beschleunigung.
Die Geschwindigkeit sollte also irgendwie nach dem Abprallen anwachsen.

Gruss
Oops

[Michael G. (linuxgeek)]

Ja... das ist wohl wahr... ;) Koennte man sogar berechnen, Stichwort 
elastischer Stoss. Aber das is mir dann doch nen bissel zu bloede 
jetzt... war ja nicht meine Idee (=

[whatever (Gast)]

Bei dem Video stimmt es, die längere Pause in der Mitte erzeugt 
abprallende LEDs. Sehr interessant! Danke!

[Michael G. (linuxgeek)]

Komischerweise sollte da keine Pause sein... ich hab naemlich extra 
diese Stelle nich zwei mal gemacht ;D

Hier der Code:

    while (1)
    {
       for (i=0; i<5; i++)
       {
         PORTB = ~((1 << i) | (1 << (7-i)));
         for (a=0; a<4; a++)
           _delay_ms(50);
       }

       for (i=2; i>=0; i--)
       {
         PORTB = ~((1 << i) | (1 << (7-i)));

         for (a=0; a<4; a++)
           _delay_ms(50);
       }
    }

Verbessern kann man das jetzt noch indem man die laufgeschwindigkeiten 
dynamisch so anpasst, dass der Apralleffekt realistischer wirkt. 
Allerdings ist das bei einem Stoss in der Tat verhaeltnismaeszig 
gleichmaeszig, also ohne dass die abprallenden Koerper da nochmal 
quadratisch beschleunigen wuerden oder so nen Krampf ;) Durch 
Reibungsverluste werden die halt langsamer wenn sie sich voneinander 
entfernen... das sollte man irgendwie beruecksichtigen. Aber schneller 
werden sie nach dem abprallen keinesfalls.

Michael

[Magnus Müller (Gast)]

Michael G. wrote:
> Komischerweise sollte da keine Pause sein... ich hab naemlich extra
> diese Stelle nich zwei mal gemacht ;D

Ändere mal die Werte der ersten for-Schleife wie folgt:


aus

>        for (i=0; i<5; i++)

machst du

for (i=0; i<4; i++)

Gruß,
Magnetus