Druckbare Version
Vielen Dank für die genaue Beschreibung des Timers!Zitat:
Zitat von A.Hoffmann
Und danke für die Version mit der Ansteuerung für alle LED's ...
Sowas habe ich heute mit Hilfe deines ersten Codes auch geschafft ...
Nun werde ich die mal vergleichen ... ;)
Kann es sein, dass wenn ich 255 ms warte, dass das zu schnell für den Roboter ist?
EDIT:
Habe meinen Fehler gefunden ... :D
Da stand noch ldi temp2, 1 ... ](*,)
der prozessor schafft ziemlich genau 8 millionen befehle pro sekunde (da die meisten befehle der avrs SINGLE-CYKLE (schreibt man das so?) sind.). in 255 millisekunden als immer noch gute 2 millionen befehle... =) da sieht man mal was 8 megahertz sind...
Einen Dank nochmals an A.Hoffmann, aber kann es sein, dass der Zähler nicht ganz korrekt arbeitet?Zitat:
Zitat von A.Hoffmann
Am meisten bei kleineren Zahlenwerten?
Ich habe zum Beispiel 1 Sekunde testen wollen, aber der braucht viel länger!
Entschuldigung A.Hoffmann!
Dein Programm arbeitet super!
Ich habe nur das ldi zu spät gesetzt, dadurch entsteht eine Verzögerung ... ](*,)
@A.Hoffmann:
Ich habe mal ne Frage:
Was bringt folgender Code:
Code:;*********************************************************
;* Interrupt Routine für Timer 0 *
;*********************************************************
delay:
push ZH
push ZL
push temp2
push temp
in temp, SREG
push temp ; sichern
lds temp, timer_6 ; Milisekunenden
inc temp ; Zähler
sts timer_6, temp ; + 1
adiw r25:r24, 1 ; Counter + 1
ldi temp, 0xE8 ;0xE8 ; 0x03E8 = 1000
ldi temp2, 0xFF ;0x03
cp r24, temp ; Counter Low / 16 Bit compare
cpc r25, temp2 ; Counter High
brne next_step ; noch keine Sekunde vergangen
lds temp, timer_1 ; erhöhe die Sekunden Zähler um 1
inc temp
sts timer_1, temp
ldi r24, 0
ldi r25, 0
next_step:
ldi temp, 131 ; Counter Register
out TCNT0, temp ; neu Vorbelegen
pop temp ; Register
out SREG, temp
pop temp
pop temp2
pop ZL
pop ZH ; wieder herstellen
reti
Hallo H3IIGhost
Für die Zeitmesser wird der Timer/Counter0 Verwendet.
Er wird so Programmiert, daß er jede Millisekunde einen Interrupt auslöst.
Wenn dieser Interrupt ausgelöst wird, dann wird die dazugehörige Interrupt
Service Routine ausgeführt.
Dieser Interrupt Vektor an der Adresse 9 ( Timer/Counter0 Overflow ) zeigt auf delay.
In diesem Programmteil werden dann der timer_1 ( 8 Bit Sekunden
Zähler 1 - 255 ) und der timer_6 ( 8 Bit Millisekunden Zähler 1 - 255 )
um 1 erhöht. Wobei der timer_6 immer um 1 erhöht wird der timer_1 jedoch nur, wenn eine Sekunde Vergangen ist. Dafür wird in den Registern 25:24 ein Zähler mitgeführt der bis 1000 zählt.
Dabei fällt mir auf in dem Programm ist ein Fehler,
der Zähler geht von 0 - 1000, er müßte aber von 1 - 1000 Zählen.
Die Zähler timer_1 und timer_ 6 werden von den
Unterprogrammen wait_timer_1 und wait_timer_6 benutzt. Sie setzten den
jeweiligen Zähler auf 0 und warten dann, bis der Zähler den in temp2
übergebenen Wert erreicht hat.
Dann kehren sie zum aufrufenden Programm zurück.
MfG
A.Hoffmann
Danke für die Antwort ...
Ist ganz schön kompliziert ...
Habe nun selber ein Programm geschrieben:
Was mich da aber stört ist, dass er nicht sofort mit dem Blinken startet.Code:.include "m8def.inc"
.def temp = r16 ;Arbeitsregister setzen
.def flag = r17 ;Flagregister setzen
.equ TIMERWERT = 65535-976 ;Timerwert auf etwas setzen
;********************************************************
;* Init Timer / Counter 1 *
;********************************************************
ldi temp, (1 << CS10) | (1 << CS12) ;Setze Prescalerwerte
;CS10 auf Null und CS11 und CS12 auf Eins Divisionsfaktor = 1024
out TCCR1B, temp ;Übergebe den Wert an das Timer/Counter1 Control Register B
;********************************************************
;* Init LED's *
;********************************************************
cbi PORTD7, PD7
cbi DDRD, DDD7 ;Back-LEDs wirklich ausschalten
;********************************************************
;* MAIN *
;********************************************************
main:
rcall front_led_on
rcall timer_countdown
rcall front_led_off
rcall timer_countdown
rjmp main
;********************************************************
;* Funktionen *
;* ********** *
;********************************************************
;********************************************************
;* Timer Countdown *
;********************************************************
timer_countdown:
loop:
in temp, TIFR
sbrs temp, TOV1
rjmp loop
rcall timer_reset
ldi temp, (1<<TOV1)
out TIFR, temp
ret
;********************************************************
;* Timer Reset *
;********************************************************
timer_reset:
ldi temp, HIGH(TIMERWERT)
out TCNT1H, temp
ldi temp, LOW(TIMERWERT)
out TCNT1L, temp
ret
;********************************************************
;* Front LED On *
;********************************************************
front_led_on:
sbi PORTD, PD6
sbi DDRD, DDD6
ret
;********************************************************
;* Front LED Off *
;********************************************************
front_led_off:
cbi DDRD, DDD6
ret
Warum nicht?
@A.Hoffmann:
Kann man dein Programm auch auf die Art schreiben, wie ich meinen Timer benutze?
Guten Tag H3IIGhost.
Du hast keinen Stack eingerichtet.
Das ist aber unbedingt Notwendig, denn bei einem rcall wird der Programmzähler, eine 16 Bit Adresse auf dem Stapel abgelegt.
Bei einem ret wird der Programmzähler wieder hergestellt und das Programm geht an der Stelle weiter, die dem rcall Aufruf folgt.
In etwa so.
Anweisung: rcall front_led_on
Aktion: Rücksprungadresse auf den Stack sichern und dann das Unterprogramm Ausführen.
Am ende des Unterprogramms (ret) den Programmzähler wieder herstellen und mit der nächsten Anweisung im Programm fortfahren.
Anweisung: rcall timer_countdown
Ohne initialisierten Stackpointer ist es reiner Zufall, wo das Programm nach der Rückkehr aus dem Unterprogramm weitermacht.
Außerdem wird das TOV1 Bit bei einem Timer Überlauf zwar gesetzt, aber nicht automatisch zurückgesetzt.
Zurückgesetzt wird das Bit, auch wenn es sich Merkwürdig anhört, indem du eine 1 an die Adresse des Bits schreibst.
Auserdem solltest du das Unterprogramm timer_reset vor main einmal aufrufen, ansonsten fängt der Timer bei Null an zu zählen.
Du solltest auch deine Programme im AVR Studio im Debug Modus Testen, dann fallen dir solche Fehler direkt auf.
Zur Frage zwei. Ja. In meinem Programm wird das Timer Overflow Flag nur durch ein Interrupt Programm behandelt.
MfG
A.Hoffmann
Danke danke ...
Ich benutze auch das AVR Studio aber die Fehlermeldung vom Debugger habe ich wohl falsch interpretiert.
Wärst du eigentlich so nett, dass du mir das mal auf meine Art schreibst?
Und warum funktioniert folgendes Programm so langsam ...
Code:.include "m8def.inc"
.def temp = r19
.def temp2 = r17
.def temp3 = r18
LDI R16, HIGH(RAMEND) ;setzt R16 auf den höchsten wert 1024 (0x0400)
OUT SPH, R16 ;setzt es in Stack Pointer (zwischenspeicher)
LDI R16, LOW(RAMEND) ;setzt R16 + 95 (0x005F) also wird niedrigster wert dazu addiert
OUT SPL, R16 ;setzt es in Stack Pointer (zwischenspeicher)
;Front LED an
main:
ldi temp2, 0x0F
rcall front_led_on
RCALL warte ; Aufruf des Unterprogramms "warte"
rcall front_led_off
RCALL warte ; Aufruf des Unterprogramms "warte"
rjmp main
;FRONT-LED an als Unterprogramm
front_led_on:
SBI PORTD, PD6
SBI DDRD, DDD6
ret
;FRONT-LED aus als Unterprogramm
front_led_off:
CBI DDRD, DDD6
ret
;Warteschleife als Unterprogramm
warte:
dec temp2
mov temp, temp2
LDI R17, 0xFF ;setzt R17 auf 255
LDI R18, 0xFF ;setzt R18 auf 255
loop1: DEC R17 ;
BRNE loop1 ;wenn nicht gleich, springt zu loop2
DEC R18
BRNE loop1
DEC temp
BRNE loop1
RET ;automatischer Rücksprung zum Hauptprogramm
Hallo H3IIGhost.
Warum ist das Programm so langsam?
Dein Problem dürfte von dieser Routine verursacht werden.
Zerlegen wir doch mal das Programm in seine Bestandteile.
In Zeile 2 wird der in temp2 Übergebene Wert um 1 Vermindert
Und in Zeile 3 in temp Übertragen. Temp enthält jetzt 0x0E .
In den Zeilen 4 und 5 werden die Register 18:17 mit FF Vorbelegt.
In den Zeilen 6 und 7 wird das Register 17 auf Null herunter gezählt.
Danach wird in Zeile 8 das Register 18 um eins Vermindert.
Wenn es nicht Null ist Verzweigt das Programm in der Zeile 9
zu Zeile 6 ( loop1 ).
Dort wird aber wieder Register 17 um eins Vermindert.
0x00 - 1 = 0xFF
Das hat zur Folge, daß das Register 17 jetzt wieder 0xFF enthält.
Dadurch wird aber die Bedingung in der Zeile 7 wieder wahr
und die ganze Schleife wird wiederholt. Das war doch sicherlich
nicht Beabsichtigt ? (255 * 255) * 14 = 910350 Durchläufe.
;Warteschleife als Unterprogramm
1: warte:
2: dec temp2
3: mov temp, temp2
4: LDI R17, 0xFF ;setzt R17 auf 255
5: LDI R18, 0xFF ;setzt R18 auf 255
6: loop1: DEC R17
7: BRNE loop1 ;wenn nicht gleich, springt zu loop2
8: DEC R18
9: BRNE loop1
10: DEC temp
11: BRNE loop1
12: RET ;automatischer Rücksprung zum Hauptprogramm
Nun zu deiner Zweiten Frage. Natürlich kann man das Programm
anpassen, aber ich kann darin keinen Sinn erkennen.
Du solltest im Gegenteil soviel wie möglich von
Interrupt Routinen erledigen lassen. Da bleibt dir mehr Zeit für
Zusätzliche Programmfunktionen. Auch sind diese Programme nur
als Beispiel zu sehen.
MfG
A.Hoffmann