Problem mit Interrupt RET und RETI

[M. M. (mrmcchicken)]

Hallo miteinander,
ich habe eine kurze frage zu Interrupts.
Mit dem 16 Bit Timer des ATmega8 möchte ich gerne ein Zahl hoch zählen.
Der Interrupt funktioniert soweit auch. Allerdings habe ich das Problem, 
dass der Interrupt nur ein einziges mal ausgeführt wird und dann nichts 
mehr.

Kann ich innerhalb eines Interupthandlers bestimmte Funktionen mir rcall 
aufrufen und dann mit RET wider zurück springen? Wenn der Interrupt in 
einer Endlosschleife ausgelöst wurde springe ich dann mit RETI zurück in 
diese Schleife oder zurück zur Interrupt Adresse?

[(prx) A. K. (prx)]

Konrad M. schrieb:
> Kann ich innerhalb eines Interupthandlers bestimmte Funktionen mir rcall
> aufrufen und dann mit RET wider zurück springen?

Ja.

> Wenn der Interrupt in
> einer Endlosschleife ausgelöst wurde springe ich dann mit RETI zurück in
> diese Schleife oder zurück zur Interrupt Adresse?

RETI springt exakt dorthin zurück, wo untergebrochen wurde. Interrupts 
halten also den Programmfluss im Hauptprogramm nur temporär auf, ändern 
ihn aber nicht.

[Falk S. (falkschilling)]

Konrad M. schrieb:
> Kann ich innerhalb eines Interupthandlers bestimmte Funktionen mir rcall
> aufrufen und dann mit RET wider zurück springen?

Kannst du, aber ob du das solltest, müsstest du dich selbst 
hinterfragen. Um ein halbwegs gescheites Timing hinzukriegen sollten 
deine ISRs auch von einer überschaubaren Komplexität sein.

> Wenn der Interrupt in
> einer Endlosschleife ausgelöst wurde springe ich dann mit RETI zurück in
> diese Schleife oder zurück zur Interrupt Adresse?

Vergegenwärtige Dir doch mal, was die eigentliche Aufgabe von RET ist 
(was passiert da auf dem Stack). Da die Interruptbehandlung eine 
Unterbrechung des normalen Programmablaufs ist, erfordert diese einen 
speziellen Befehl um wieder in den normalen Programmablauf 
zurückzuspringen - und das macht RETI.

[M. M. (mrmcchicken)]

Danke soweit für die Hilfe.
Das Timing ist nicht ganz so kritisch. Das größere Problem was ich habe, 
ist, dass der Interrupt nur einmalig ausgeführt wird obwohl ich ein RETI 
am ende des Interupthandlers habe und momentan auch keine weiteren 
Adressen im Interrupt anspringe.

[(prx) A. K. (prx)]

Das kann sich durch diese Fragen auch nicht beantworten lassen.

[M. M. (mrmcchicken)]

Eventuell kann mir von euch jemand sagen was das faul im Programm ist.
Das soll jetzt ein erster versuch werden ein LCD anzusteuern. Ich würde 
im Grunde nur ganz gerne  eine Zahl hoch zählen und ausgeben. Leider 
wird der Interrupt nur einmalig ausgelöst. Mir ist bewusst, dass 
pause_lang kürzer ist als pause_weniger_lang, dass sollte bei diesem 
Problem aber nichts ändern.

/*
 * PD5 = E (enable)
 * PD4 = RS (register select | Befehle / Daten)
 * PD0 = DB4
 * PD1 = DB5
 * PD2 = DB6
 * PD3 = DB7
 *
 */ 


.org 0x000
rjmp main

.org 0x007
rjmp interrupt




main:
 
;------------------------------- Variablen
.def temp = r16
.def temp1 = r18
.def temp3 = r3
.def temp4 = r17
.def temp5 = r4
.def lcd1 = r20
.def lcd2 = r21

.def zahl = r22

;------------------------------- Stackpointer
ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

;------------------------------- PORTD Ausgang
ldi temp, 0xff
out DDRD, temp
out DDRB, temp
out PORTB, temp
ldi zahl, 0x30

;------------------------------- Timer 1
ldi temp, (1<<OCIE1B)                                      ; Interupt bei clear timer on compare match
out TIMSK, temp
ldi temp, (1<<WGM12) | (1<<CS12) | (0<<CS11) | (1<<CS10)   ; CTC Modus einschalten, so wie vorteiler setzen
out TCCR1B, temp

ldi temp, HIGH(1000)                                       ; CTC wert
out OCR1BH, temp
ldi temp, LOW(1000)
out OCR1BL, temp



;------------------------------- Vor initialisierung Pause machen
rcall pause_lang


lcd_init:                     ; LCD Initialisierung
ldi lcd1, 0b00000011          ; muss 3mal hintereinander gesendet
out PORTD, lcd1               ; werden zur Initialisierung
rcall lcd_enable              ; 1
rcall pause_lang 
rcall lcd_enable              ; 2
rcall pause_lang
rcall lcd_enable              ; 3
rcall pause_lang 

ldi lcd1, 0b00000010          ; 4bit-Modus einstellen
out PORTD, lcd1
rcall lcd_enable
rcall pause_lang

ldi lcd1, 0b00101000          ; 4Bit / 2 Zeilen / 5x8
rcall lcd_command
ldi lcd1, 0b00001111          ; Display ein / Cursor ein /  Blinken
rcall lcd_command
ldi lcd1, 0b00000100          ; inkrement / kein Scrollen
rcall lcd_command
ldi lcd1, 0b00000010          ; Cursor home
rcall lcd_command
ldi lcd1, 0b00000001          ; LCD clear
rcall lcd_command
sei
rjmp loop



lcd_enable:
sbi PORTD, 5                  ; Enable high
nop
nop
nop
cbi PORTD, 5                  ; Enable low
ret

;-------------------------------- Ausgabe des Bytes als Befehl
lcd_command:                  
mov lcd2, lcd1                ; Kopie für Übertragung des zweiten Nibbles
swap lcd1                     ; Vertauschen (erst Bit 4 - 7 Ausgeben!) --> LCD Datenleitungen DB4 bis DB7 angeschlossen
                              ; ARV Datenleitungen PD0 bis PD3 angeschlossen.
andi lcd1, 0b00001111         ; Rest auf 0 setzen (RS = 0 also befehl)
out PORTD, lcd1               ; Ausgabe Bit 4 - 7
rcall lcd_enable
andi lcd2, 0b00001111         ; Das gleich mit den Bits 0 - 3 wiederholen
out PORTD, lcd2               ; Kein vertauschen nötig. Nibble bereits an richtiger stelle
rcall lcd_enable
rcall pause_lang
ret

;-------------------------------- Ausgabe eines Bytes als Befehl
lcd_data:
mov lcd2, lcd1               ; Kopie für Übertragung des zweiten Nibbles
swap lcd1                    ; Vertauschen (erst Bit 4 - 7 Ausgeben!) --> LCD Datenleitungen DB4 bis DB7 angeschlossen
                             ; ARV Datenleitungen PD0 bis PD3 angeschlossen.
andi lcd1, 0b00001111        ; Rest auf 0 setzen
sbr lcd1, 1<<4               ; RS = 1, also Daten!!!
out PORTD, lcd1              ; Ausgabe Bit 4 - 7
rcall lcd_enable
andi lcd2, 0b00001111        ; Das gleich mit den Bits 0 - 3 wiederholen
sbr lcd2, 1<<4               ; RS = 1, also Daten!!!
out PORTD, lcd2              ; Kein vertauschen nötig. Nibble bereits an richtiger stelle
rcall lcd_enable
rcall pause_lang
ret





loop:

ldi lcd1, 0x01
rcall lcd_command
mov lcd1, zahl
rcall lcd_data
rcall pause_weniger_lang

rjmp loop




interrupt:
inc zahl
reti






pause_lang: 
ldi temp4, 0x00        
ldi temp, 0x05
mov temp5, temp
pause_l_w:
ldi temp, 0x00
pause_2:
inc temp
cpi temp, 0xFF
breq pause_3
rjmp pause_2
pause_3:
inc temp4
cp temp4, temp5
breq pause_ende
rjmp pause_l_w
pause_ende:
ldi temp4, 0x00
ret

pause_weniger_lang: 
ldi temp, 0xFF
mov temp5, temp
pause_wl_w:
ldi temp, 0x00
pause_wl_2:
inc temp
cpi temp, 0xFF
breq pause_wl_3
rjmp pause_wl_2
pause_wl_3:
inc temp4
cp temp4, temp5
breq pause_wl_ende
rjmp pause_wl_w
pause_wl_ende:
ldi temp4, 0x00
ret

[Markus W. (Firma: guloshop.de) (m-w)]

Konrad M. schrieb:
> Allerdings habe ich das Problem,
> dass der Interrupt nur ein einziges mal ausgeführt wird und dann nichts
> mehr.

SP wurde richtig initialisiert? Besteht das Hauptprogramm wirklich nur 
aus einer Endlosschleife? Falls nicht, könnte es sein, dass die ISR 
Auswirkungen auf den Lauf des Hauptprogramms hat -- alle doppelt 
genutzten Register müssen gesichert werden.

Vielleicht liegt der Fehler aber auch in Zeile 42...? ;-)

[Falk S. (falkschilling)]

Vergleiche doch einfach mal deinen Code mit etwa:

http://www.mikrocontroller.net/articles/AVR-Tutorial:_Uhr

Was ist mit SREG beim Interruptaufruf?

[Peter II (Gast)]

> interrupt:
> inc zahl
> reti

du musst doch das Prozessor Register (SREG) sicher und wiederherstellen. 
inc verändert es.

[M. M. (mrmcchicken)]

Habe den Fehler beseitigen können.
Ich fürchte da war wohl irgend eine Schwarze Magie am werk.

Habe den Abschnitt Timer1 in folgendes umgeändert:

;------------------------------- Timer 1
ldi temp, (1<<OCIE1A)                                      ; Interupt bei clear timer on compare match
out TIMSK, temp
ldi temp, (1<<WGM12) | (1<<CS12) | (0<<CS11) | (1<<CS10)   ; CTC Modus einschalten, so wie vorteiler setzen
out TCCR1B, temp

sei

ldi temp, HIGH(1000)                                       ; CTC wert
out OCR1AH, temp
ldi temp, LOW(1000)
out OCR1AL, temp

Also ich benutze nun den CTC Kanal A. Wieso das nun einen Unterschied 
macht weiß ich auch nicht. Kann mir das evtl. jemand erklären?
Natürlich habe ich die Interruptadresse auch geändert.

[Stefan E. (sternst)]

Konrad M. schrieb:
> Also ich benutze nun den CTC Kanal A. Wieso das nun einen Unterschied
> macht weiß ich auch nicht. Kann mir das evtl. jemand erklären?

Es gibt kein "CTC Kanal B". Wenn du den CTC-Modus wählst, und OCR1A auf 
0 lässt (wie in deinem ersten Code), dann zählt der Timer nur 
0-0-0-0-0-... und erreicht nie die 1000 um den OCR1B-Interrupt 
auszulösen.