interrupts op AVR

Is gewoon nog sei() en cli() althans voor de atmega's en atxmega's die ik gebruik.

Misschien #include <avr/interrupt.h> vergeten, en vervolgens niet de moeite gedaan om naar de compiler-warnings te kijken?

dank je pros, dat was hem, warnings zeiden allen implicit declaration of function ofzo..

En sei(); was toevallig geen functie

het is wel een functie uiteraard, maar eentje in de header file

uit de header file

Enables interrupts by setting the global interrupt mask. This function
actually compiles into a single line of assembly, so there is no function
call overhead.

Het is dus geen functie maar een define.

Als ie niet gedeclareerd wordt, denkt de compiler dat het een functie aanroep is, en maakt ie de functie call code. Die kan de linker dan weer niet vinden.

Let op je waarschuwingen!!!

@ rew: kun jij me dan het exacte verschil tussen en functie en een define vertellen, want ik moet eerlijk zijn dat het mij nooit helemaal duidelijk geworden is.

overigens komt bovenstaande quote (waarin ze het een functie noemen dus) gewoon uit de header file interrupt.h zelf weten ze het dus blijkbaar ook niet, want ze noemen het zelf ook functie )

define: macro maken. Wat er achter staat wordt vrijwel letterlijk in je code geplakt door de preprocessor.

function: 1x maken en er wordt een call naartoe gedaan.

Macro is dus puur iets voor de pre-processor. Compiler weet niet eens dat die dingen bestaan, is een soort van 'search en replace' (met een hele trucendoos er omheen als je dat wilt).
Function is iets voor de compiler (en later de linker).

Een macro zonder parameters maar met () is dus eigenlijk zinloos - strikt syntactisch gesproken. Code wordt er wel leesbaarder van (het impliceert dat hetgeen wat daar staat ook wat doet).

Macro's kun je naar 'niks' laten evalueren. Dat kan soms handig zijn voor debug code (die je weer kwijt wilt in productie); of dat een handige manier van development is laat ik in het midden.

Voor die sei() en cli(): het zou net zo goed in een function kunnen. Nadeel daarvan is dat het een stel instructies worden (in elk geval een call en een ret), terwijl die macro naar 1 enkele assembly instructie evalueert. Als je naar de definitie kijkt, zal het wel wat inline worden.

Voor wat betreft dat commentaar wat het nog over een function heeft: dat zou wel eens 'oud zeer' kunnen zijn. Het zou mij niets verbazen als het oorspronkelijk functions waren, waarbij later iemand iets had van 'dit kan slimmer'.

EricP je kunt ook een constante definen. Dat kende ik wel, het verhaal van de macro snapte ik niet helemaal (nu wel)

Nog een hele kleine toevoeging...

Bij het aanroepen van een macro ziet het er uit alsof het een functieaanroep is.

Normaal maak je er hoofdletters van, maar soms wil je dat juist niet. Bijvoorbeeld als je met de preprocessor wil regelen dat een andere functie aangeroepen wordt dan dat in de code staat.

#if DEBUG
#define dprintf printf
#else
#define dprintf (void)
#endif

Maar je moet je realiseren dat het een text-substitutie spelletje is.

#define dist(x,y) sqrt(x*x+y*y)

Lijkt een leuke definitie, toch? Maar doe je dan iets als

   d = dist (x++, y); // sla de afstand op, en ga 1 hokje naar rechts. 

Dan ziet de compiler:

   d = sqrt (x++ * x++ + y * y); 

En zoals je ziet: x wordt nu twee keer opgehoogd! Dus bij macros moet je uitkijken met deze sideeffects.

Als laatste... tegenwoordig heb je ook:

static double inline dist (double x, double y) 
{ 
   return sqrt (x*x, y*y);
}

Met de "inline" geef je aan dat de compiler de code gewoon in de aanroepende functie moet plaatsen. Met de "static" geef je aan dat deze functie niet ook nog eens ergens als functie aangeroepen wordt. Dus dan hoeft hij hem niet OOK als aanroepbare functie te maken. Nu werkt de code met x++ dus wel.

dat sideeffect voorkom je dus als je dit zou doen

d = dist (x, y); // sla de afstand op
x++;             // en ga 1 hokje naar rechts. 

Dat klopt. Maar aan de 'functie'^* zie je niet of dat nodig is of niet. Dat is dus eng. Macro's zijn heel krachtig, maar je kunt er ook hele enge dingen mee doen. Blijf jezelf altijd heel goed realiseren dat het een intelligente 'search & replace' is en maakt het niet complex.
Zelf ben ik niet zo van x++ achtige dingen als x ook parameter is - enige 'voordeel' is dat je source korter wordt. In de gegenereerde code maakt het doorgaans geen zak uit.

^*Naamgeving rammelt. Staat hier dus voor functie of macro.