Aus dem Interrupt vorzeitig rausspringen?

[RichieRich (Gast)]

Hallo,

ich habe eine kleine Frage an die GCC experten.

Und zwar möchte ich, durch einen externen Interrupt(INT0) in die 
Interruptroutine reinkommen (was kein Problem ist) und bei einem 
erneuten externen Interrupt am INT0 wieder zum Anfang der 
Interruptroutine gelangen.

Geschieht dies dadurch, dass ich in der Interruptroutine folgendes 
Register zu 1 setze?

GIFR = 1 << INTF0;

geht das auch mit sei(); im Interrupt?

P.S. Es handelt sich um einen ATMega32.


Danke

[Sven P. (Gast)]

Das geht eigentlich nur mit sei(). Aber davon lässt du bitte die Flossen 
und liest dir stattdessen mal die Beschreibung zu 'ISR' durch.

[sven (Gast)]

Das passiert von alleine. Jedoch musst Du zusehen, dass Du vor dem 
nächsten Ausführen deine ISR verlassen hast.

Sollte das für Dich nicht machbar sein, ist deine Architektur falsch.

[Sven P. (Gast)]

sven schrieb:
> Das passiert von alleine. Jedoch musst Du zusehen, dass Du vor dem
> nächsten Ausführen deine ISR verlassen hast.
Nein, eben nicht. Interrupts dürfen und können problemlos 
'verschachtelt' werden.

Ich sag ja -- Dokumentation lesen hilft ungemein.

[Jörg G. (joergderxte)]

> Und zwar möchte ich, durch einen externen Interrupt(INT0) in die
> Interruptroutine reinkommen (was kein Problem ist) und bei einem
> erneuten externen Interrupt am INT0 wieder zum Anfang der
> Interruptroutine gelangen.
Wie meinst du das?
Du kannst mit "return" jederzeit aus der ISR (wie auch aus jeder anderen 
Funktion) 'aussteigen' - wenn die Bedingung für den Externen Interrupt 
noch/wieder besteht, landest du wieder in der ISR.

> Geschieht dies dadurch, dass ich in der Interruptroutine folgendes
> Register zu 1 setze?
>
> GIFR = 1 << INTF0;
Damit löschst du das Flag, das macht man normalerweise, damit die 
Hardware es wieder setzen kann (Schau noch mal in Datenblatt, wie die 
die Flags für den externen Interrupt funktionieren)
> geht das auch mit sei(); im Interrupt?
Damit geht einiges, aber wahrscheinlich viel ungewolltes.


hth, Jörg

[RichieRich (Gast)]

Danke erstmals für die Hinweise!

Die Grundidee war, beim erster Sprung ins Interrupt (ausgelöst durch 
INT0, extern) eine variable zu inkrementieren und dann 500ms zu warten 
ob ein zweiter Interrupt kommt.
Falls kein weiteres externes Interrupt kommt sollte eine Funktion_1 
aufgerufen werden. Sollte jedoch ein weiteres Interrupt kommen, kehrt 
das Programm zum Anfang des Interrupt zurück und die variable wird 
nochmals inkrementiert und es wird eine Funktion_2 aufgerufen.

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

Im Interrupt-Handler 500ms warten? Urgs... Total falscher Ansatz.

[Sven P. (Gast)]

Dann haste nen Konzeptfehler. In einer Interrupt-Routine 500ms zu 
warten, das is ne Katastrophe.

[Karl H. (kbuchegg)]

RichieRich schrieb:
> Danke erstmals für die Hinweise!
>
> Die Grundidee war, beim erster Sprung ins Interrupt (ausgelöst durch
> INT0, extern) eine variable zu inkrementieren und dann 500ms zu warten
> ob ein zweiter Interrupt kommt.
> Falls kein weiteres externes Interrupt kommt sollte eine Funktion_1
> aufgerufen werden. Sollte jedoch ein weiteres Interrupt kommen, kehrt
> das Programm zum Anfang des Interrupt zurück und die variable wird
> nochmals inkrementiert und es wird eine Funktion_2 aufgerufen.

Dachte ich mir schon:
Falscher Ansatz.

Die komplette Auswertung machst du in main().
Die ISR signalisiert der Hauptschleife in main() nur, dass der Interrupt 
eingetreten ist.

In einer ISR auf irgendetwas zu warten, ist eigentlich fast immer ein 
sicherer Weg ins Chaos.

Wenn die ISR aufgerufen wird, setzt sie eine globale Variable auf 1.
Die Hauptschleife sieht sich ständig diese Variable an. Wird sie 1, dann 
setzt sie die Variable zurück auf 0 und startet sie den Timer (oder was 
du sonst benutzt um die 500ms abzuzählen). Nach Ablauf des Timers kann 
mann dann zb. nachsehen ob die globale Variable durch die ISR noch mal 
auf 1 gesetzt wurde und entsprechend reagieren.

Wie misst du denn die 500ms? Je nachdem welche Methode du benutzt, 
bietet sich ein anderer Ansatz an.

[Falk B. (falk)]

Siehe Interrupt.

[Mark B. (markbrandis)]

Ist das dann ein Interruptus interruptus? :-)

[P. S. (Gast)]

Sven P. schrieb:

> Dann haste nen Konzeptfehler. In einer Interrupt-Routine 500ms zu
> warten, das is ne Katastrophe.

Was passiert dann, explodiert der Controller?

[Sven P. (Gast)]

Ja, es kommt dann meistens zur Kernfusion.

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

Peter Stegemann schrieb:

> Was passiert dann, explodiert der Controller?

Nein, aber der Programmierer, vor Frust und Verzweiflung.

[PJ (Gast)]

> Was passiert dann, explodiert der Controller?

Nee, aber vielleicht der Stack.

Wenn man es schlau genug macht, kann man das aber verhindern.

Es gibt nichts, was prinzipiell dagegen spricht. Aber man muss sehr 
sorgfältig vorgehen.

[Karl H. (kbuchegg)]

PJ schrieb:

> Aber man muss sehr
> sorgfältig vorgehen.

Du sagst es, Bruder!