Variabelen binnen interruptroutine

daar heeft men globale variabelen voor uitgevonden...

die gebruik ik overigens meestal in interrupt routines. Ander pointers

Het probleem is namelijk dat variabelen declareren tijd kost. En een interrupt wil ik meestal zo kort mogelijkhouden, dus variabelen aanmaken zoveel mogelijk BUITEN de interrupt.

Voor zover ik weet moeten variabelen die worden gebruikt binnen een interruptroutine, gedeclareerd worden aan het begin van de interruptroutine. Zodus krijgen die variabelen telkens een initiële waarde bij het oproepen van de interrupt.

Nee hoor, je hoeft niet te declareren binnen een ISR.
Dus als je main programma de variabelen niet veranderd, dan behouden je variabelen de waarde uit de vorige ISR.

Bedankt

Maar waar moet ik ze dan declareren? Als ik ze onder de main declareer werkt het niet, want dan krijg ik een error voor elke variabele.

Vóór de ISR geeft geen fout, maar het werkt niet zoals verwacht. (De fout kan mogelijk ook ergens anders liggen)

Ben ik correct als ik het volgende doe:

#include....

#define ....

int VARIABELE

ISR (...) {

gebruik van VARIABELE

}

int main (void) {

...

}

ja

Maak daar maar "volatile int VARIABELE" van.

Als je ze alleen in de interrupt gebruikt kan je ze ook lokaal (in je interrupt routine) declareren. Heeft niks met snelheid te maken.
Als je ze zowel in je main als interrupt gebruikt moet je in je main je interrupts disabelen op het moment dat je die variabele benadert (lezen of schrijven) anders kan je data corrupt zijn.
Volatile is alleen om ervoor ze zorgen dat de variabele niet weggeoptimaliseerd wordt.
Tijdens debuggen kan je hem dan misschien niet zien.

@pros: je hebt gelijk

@Red Tiger: delareren kost ook tijd!

Als je de variabelen 1 keer wilt initialiseren, en je hebt ze alleen in de ISR nodig kan je ze gewoon als "static" declareren.

dus:

void ISR(void)
{
  static unsigned char test = 0;
  
  ....
}

Je variabele wordt de eerste keer dat de ISR wordt aangegroepen aangemaakt en geinitialiseerd, en blijft daarna binnen de ISR beschikbaar.

Ik denk dat dit misschien eerder compiler afhankelijk is. Bij mijn weten maakt mijn compiler alleen geen public symbol aan.
Want wat is dan het verschil tussen static en volatile in jou voorbeeld?

ehmmm static en volatile hetzelfde???
dat zijn EXACT tegenpolen zover ik weet:
static = je zet het 1x en daaran nooit meer:
bijv:

static float pi = 3.1415;

als je later dit bijv zou doen:
pi = 6;

dan zou je compiler hier een error op moeten geven.

ECHTER

als je zoiets doet

volatile int pietje;

(interrupt routine)
pietje = 6;
(einde interrupt)

main

pietje++;

dat mag gewoon.

volatile is zoiets als vluchtig, snel veranderlijk.
static wil zeggen: vast, gedefnieerd.

nogal tegengestelden dus!

Heb het even getest en is bij toch anders:

dit:

volatile float pi = 3.1415;

void main(void){
	pi = 4.123;
	while(pi--);
}

zorgt ervoor dat ik de pi wel kan veranderen doordat de variabele in ram ligt.
Dit:

static float pi = 3.1415;

void main(void){
	pi = 4.123;
	while(pi--);
}

zorgt ervoor dat de code im rom ligt en daardoor niet veranderd kan worden.
Beide comileren overigens zonder warning of error.
Static kan je dus alleen gebruiken voor bijvoorbeeld reeksen met vaste waarde (look-up oid)

het verbaasd me enigszins dat het door de compiler komt

verder voldeed mijn beschrijving aan de door u vastgestelde eisen.

Met 'volatile' verel je je compiler niets anders dan dat de compiler niet de enige is die aan die variabele trekt. Bijvoorbeeld bij ISRs of variables op een fixed address die feitelijk een hardware status weergeven ofzo. Hierdoor haalt de compiler het ding ook elke keer op / schrijft ook elke keer als de inhoud nodig is / veranderd wordt en voorkom je dat door optimization het spul in registers bewaard wordt (wat in deze context ongewenste effecten kan hebben).

Met een 'static' zeg je feitelijk dat het ding niet op de local stack gemikt moet worden (en dus weg is aan het einde van de routine), maar 'heel' moet blijven. Feitelijk maak je dus een global met een local scope.

Dat voorbeeld van die rooie tijger klinkt erg raar. Naar mijn persoonlijke smaak zou het beiden moeten werken. Compiler quirck?

De "static" van Mr. SnuGGelS is inderdaad een goede methode.

@High met Henk: je bent waarschijnlijk in de war met : "const".

Global is minder juist. Het zou wel kunnen, maar de static declaratie kun je mooi lokaal houden als deze variabele echt alleen binnen de ISR wordt gebruikt. Als je meerdere ISR's zou hebben zouden die namelijk allen dezelfde variabele naam kunnen gebruiken, de scope is namelijk alleen de betreffende ISR.

Gebruik je de variabele ook buiten de ISR, dan is een global "volatile" beter.

@jojo: idd const en static even gewisseld....