wann schlägt der Interrupt zu

[Amir B. (sticky)]

Hallo!
Ich habe da ein paar Verständissfragen zu Interrupts.

1. kann innerhalb einer ISR ein Interrupt in eine weitere ISR führen 
(also eine verschachtelung statt finden)?

2. folgender pseudo code liegt vor.

cli();
read_adc();   //hier soll noch kein sprung in die ISR erfolgen
sei();        //aber hier  <-- würde der Sprung in die ISR erfolgen 

// ISR(USART_RXC_vect)

Gruß Sticky

[Michael U. (amiga)]

Hallo,

ich gehe mal davon aus, das es ein AVR-µC ist und der Code mit GCC 
übersetzt wird (wenn man sowas dazuschreibt, kann man auch gezielter 
abtworten...).

Innerhalb einer ISR sind die Interrupts gesperrt und werden erst durch 
RETI wieder freigegeben.
Wenn also

cli();
read_adc();   //hier soll noch kein sprung in die ISR erfolgen
sei();        //aber hier  <-- würde der Sprung in die ISR erfolgen

innerhalb einer ISR steht, ist cli/sei überflüssig.

Nach dem Ende einer ISR wird noch ein Befehl des Hauptprogramms 
ausgeführt, bevor ein anstehender Interrupt bearbeitet wird.

Gruß aus Berlin
Michael

[Mark .. (mork)]

Hallo Sticky,

>kann innerhalb einer ISR ein Interrupt in eine weitere ISR führen

Ja, das ist möglich, aber nur wenn man in der ISR die Interrupts manuell 
aktiviert. Ansonsten sind sie, wie Michael geschrieben hat, in der ISR 
gesperrt und werden erst nach ihrer Abarbeitung wieder freigegeben.

MfG Mark

[Falk B. (falk)]

Siehe Interrupt

[Oliver (Gast)]

Bleibt noch die (durchaus wichtige) Frage:

Warum willst du das?

Oliver

[Amir B. (sticky)]

Danke erstmal für die Antworten.

@Michael
Ja AVR µC. ja GCC (sorry hab ich vergessen)

@oliver
Ich will eine LIN UART Kommunikation herstellen und überlege, ob ich die 
Kommunikation mit interrupts oder durch Polling realisiere. bei der 
LIN-Kommunikation zeigt das "Framing Error" - FLAG an, dass ein Header 
zur initialsierung der Kommunikation anliegt.

werde es wohl mit interrupts machen und innerhalb der ISR abfragen ob 
das Flag gestz ist.

@allgemein
nochmal vertändlicher.

main(){
cli();
read_adc();   //hier soll noch kein sprung in die ISR erfolgen.  
sei();        //aber hier  <-- würde der Sprung in die ISR erfolgen? 
}

 ISR(USART_RXC_vect){
  do-Stuff;
}

der grund meiner fragen zielt auf folgendes ab. ich will ADC-werte über 
LIN versenden. wie bereits erwähnt initialisiert die Kommunikation ein 
Master mit seinem Header (was zu einem intterupt führt).

meine Bedenken sind nun:
während der aufnahme und verarbeitung der daten soll kein interrupt 
ausgelöst werden dürfen. würde ich den Interrupt verpassen können oder 
liegt er noch an? (siehe code in main)

gibt es ein gcc pendant zu reti? also reti() oder so

danke nochmal

Gruß Sticky

[Falk B. (falk)]

@  Amir B-a (sticky)

>Ich will eine LIN UART Kommunikation herstellen und überlege, ob ich die
>Kommunikation mit interrupts oder durch Polling realisiere.

Geht beides.

>main(){
>cli();
>read_adc();   //hier soll noch kein sprung in die ISR erfolgen.
>sei();        //aber hier  <-- würde der Sprung in die ISR erfolgen?
>}

Du hast ein komisches Kopnzept bzw. Vorstellungen von einem 
Interrupt.

>während der aufnahme und verarbeitung der daten soll kein interrupt
>ausgelöst werden dürfen. würde ich den Interrupt verpassen können oder
>liegt er noch an? (siehe code in main)

Kommt auf die Zeitdauer der Sperrung an, siehe Artikel oben. Prinzipiell 
solle man Interrupts nur GANZ KURZ sperren.

>gibt es ein gcc pendant zu reti? also reti() oder so

Nein, das brauchst du auch nicht. Das macht der GCC allein.

MFG
Falk

[Peter D. (peda)]

Amir B-a wrote:

> gibt es ein gcc pendant zu reti? also reti() oder so

Ein RETI darf man niemals nicht in C aufrufen!!!

Der Effekt ist, daß Du irgendwo hin springst, wo zufällig die Variablen 
stehen, die in der Funktion gepusht wurden.

Ein RETI ist also unter C eine völlig unsinnige Operation.

In C benutzt man "return".
Das räumt erstmal den Stack auf und macht dann RET bzw. RETI.


Peter

[P. S. (Gast)]

Ich wuerde mal einen Blick in die aktuelle Dokumentation von interrupt.h 
werfen:

http://www.gnu.org/savannah-checkouts/non-gnu/avr-libc/user-manual/group__avr__interrupts.html

Da finden sich dann auch blockende und nichtblockende Interrupt-Handler, 
reti(), etc...