funktionen in interrupts (msp430 + C)

[Test (Gast)]

Hallo,

ich hätte eine Frage zu interrupts beim msp430. Ich programmiere den uC 
in C und benutze CCS.

Ich schicke über UART Befehle an den uC und greife diese über den RX 
interrupt ab. Über Kontrollstrukturen kann ich dann z.B. bei Empfang 
eines 'A' Port 1.0 auf high legen.

Da ich es gewohnt bin meinen Code in Funktionen aufzuteilen und das für 
die Übersicht und sich wiederholende Aufgaben auch angenehmer ist, 
wollte ich das hier auch machen.
Aber anscheinend gibt es Probleme aus interrupts Funktionen aufzurufen.

Diesen Hinweis bekomme ich:
"ISR USCI0RX_ISR_HOOK calls function tx. Recommend moving function call 
away from ISR, or inlining the function, or using pragmas"

Inlining bringt auch nichts.

Gibt es eine Möglichkeit oder muss man den kompletten Code in den 
interrupt stopfen?

[Dominik R. (vision)]

Am besten ist es, in der ISR so wenig wie möglich zu machen, da in 
dieser Zeit keine weiteren Interrupts ausgelöst werden können und du 
somit ein Ereignis verpassen könntest. Wenn du umfangreicheren Code bei 
einem Ereignis ausführen möchtest, definiere am besten eine globale 
Variable als Flag, die du dann in der ISR setzt. Damit bist du dann 
schnell aus der ISR wieder raus. In der Hauptschleife pollst du dann 
diese Variable und wenn die Flag gesetzt ist, rufst du die entsprechende 
Funktion auf und löscht die Flag wieder.
Wenn in der Funktion aber nur wenig Code ausgeführt wird und du dir 
sicher bist, kein Interrupt zu verpassen, kannst du die Compilerwarnung 
auch ignorieren.

[Coder (Gast)]

das ist doch noch nur ein hinweis vom code composer?. Ausserdem kann der 
code composer inlinen. Ich weiss nicht,  ob es von der optimierungsstufe 
abhängt.

[foo (Gast)]

Natürlich kann man in einer ISR auch mit Funktionen arbeiten.
Sollten halt hinreichend kurz sein.
Wie inline bei deinem Compiler funktioniert, verrät das manual.

Vielleicht schon so:

static inline foo(void)
{
/* so something */
}

[Ulrich H. (lurchi)]

Funktionsaufrufe in einer ISR sollte man vermeiden, weil der Compiler 
dann realtiv viele Register retten muss, einfach schon um die standard 
Aufrufkonvention einzuhalten. Da bei einer allgemeinen Funktion auch 
erst der Linker den Code zusammensetzt muss der Compiler da viele ggf. 
gar nicht benötigte Register retten. Das kostet Laufzeit und Speicher 
auf dem Stack


Der einfache Weg is es einfach kein Funktionsaufrufe zu verwenden. Die 
Vermeidung von Funktionsaufrufen vermeidet nebenbei auch das Problem mit 
ggf. nicht reentranten Funktionen.
Ersatzweise kann man ggf. #Define nutzen um Teile optisch aufzuteilen - 
das hat aber auch nachteile bei der Lesbarkeit und Fehlersuche.
Es kann helfen, wenn man die Funktionen static inline definiert. Der 
Compiler kann dann den Code einfach direkt einfügen, ohne den Overhead 
für den Aufruf - ob der Compiler die Möglichkeit nutzt ist von der 
Optimierungseinstellung und dem Compiler abhängig.

So sehr viel Code hat man inder Regel nicht in der ISR - es gibt aber 
natürlich auch Ausnahmen.

[Amateur (Gast)]

>"ISR USCI0RX_ISR_HOOK calls function tx. Recommend moving function call
>away from ISR, or inlining the function, or using pragmas"

Ich kann dem Compiler nur zustimmen.

Natürlich kannst Du die, von den Meisten akzeptierte (auch vom Compiler) 
Meinung, "Fasse Dich kurz" ignorieren.

Sogar hierzu gibt Dir der Compiler hinweise...