Verständnisfrage Interrupt-Programmierung

[René J. (renej)]

Hallo!

Beschäftige mich seit kurzem mit Interrupts, habe bisher nur ohne 
programmiert. Jetzt möchte ich ein wenig rumprobieren, aber irgendwie 
hängts noch irgendwo.

Beispiel: Ich möchte alle paar Sekunden eine LED mehrmals kurz blinken 
lassen um mir per Blink-Code einen Status anzeigen zu lassen. So wie 
z.B. beim PC die BIOS-Piep-Codes beim booten.

Dazu habe ich jetzt mal stumpf folgenden kleinen Code 
zusammengeschustert um es auszuprobieren:

#include "TimerOne.h"    // Timerlibrary
const int ledPin = 13;   // Pin der LED
int alle_x_sekunden = 5; // Intervallzeit in Sekunden

void blinken() {  // Funktion für Blink-Code
  int i = 0;
  do { 
    digitalWrite(ledPin, digitalRead(ledPin) ^ 1);  // Wenn aus, dann an
    delay(200);
    digitalWrite(ledPin, digitalRead(ledPin) ^ 1);  // Wenn an, dann aus
    delay(200);
    i++;
  } while (i < 3);  // Beispielhaft: 3x
  
}

void setup()   {
  pinMode(ledPin, OUTPUT);
  Timer1.initialize(alle_x_sekunden * 1000000);
  Timer1.attachInterrupt(blinken);
}

void loop(){}

Allerdings blinkt jetzt die LED nur "alle_x_sekunden" einmal kurz auf.

Setze ich blinken() in die loop-Funktion, funktioniert blinken() wie 
erwartet.

Warum blinkt meine LED nicht alle 5 Sek 3x kurz auf?

PS: Ich bin mir bewusst, dass der interrupt-code so kurz als möglich 
sein sollte, delay() benutze ich jetzt nur zum probieren...

[Karl H. (kbuchegg)]

Die Frage ist, was delay() eigentlich alles intern macht.

Aber eigentlich erübrigt sich die Frage, denn das weitaus stärkere 
Prinzip lautet: delay() und Interrupt Handling passen grundsätzlich 
nicht zusammen. Die willst in einer Interrupt Routine keinen delay 
haben, weil das das ganze Interrupt System ad absurdum führt.

Was du statt dessen haben willst:
Du willst, dass dein Timer alle 200 Millisekunden (um bei deinem 
Beispiel zu bleiben) die Interrupt Funktion aufruft. Dort zählst du mit, 
der wievielte Aufruf das ist und je nach dieser Zahl, schaltest du die 
LED ein oder aus bzw. tust ganz einfach nichts. Kein delay notwendig.

[BirgerT (Gast)]

René J. schrieb:

> Beispiel: Ich möchte alle paar Sekunden eine LED mehrmals kurz blinken
> lassen um mir per Blink-Code einen Status anzeigen zu lassen. So wie
> z.B. beim PC die BIOS-Piep-Codes beim booten.

Hier wird ein ähnlich gelagerter Fall "behandelt".. könnte helfen

Beitrag "Hindernis ausweichender Roboter mit Arduino"

[René J. (renej)]

Vielen Dank, das klingt beim ersten überfliegen vielversprechend. Ich 
werde die verlinkten Infos durcharbeiten und nachher hier posten, wie 
ich das gelöst habe (wenn ichs hinkrieg ;) ), falls jemand mal die 
gleiche Frage googlet und diesen Thread hier findet :D

[Falk B. (falk)]

Siehe Multitasking.

Das geht auch mit Arduino ;-)

[René J. (renej)]

So, ich habe jetzt etwas Zeit gehabt, das Ganze durchzulesen und es 
scheint so, als ob ich es hinbekommen habe. Allerdings vermute ich sehr 
stark, dass ich eher umständlich programmiert habe.

So sieht mein Ansatz für "alle 3 Sekunden zweimal kurz (100ms) 
aufblinken" aus. Macht man das so?

#define ledPin 17   // LED die blinken soll
int i = 0;          // counter, der pro interrupt incrementiert wird

void setup()
{
  pinMode(ledPin, OUTPUT);
  
  // initialize timer1 
  noInterrupts();           // disable all interrupts
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1  = 0;
  
  // 16MHz/256 = 62500 für eine Sekunde, 6250 fuer 100ms
  OCR1A = 6250;             // compare match register 16MHz/256/2Hz  
  TCCR1B |= (1 << WGM12);   // CTC mode
  TCCR1B |= (1 << CS12);    // 256 prescaler 
  TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
  interrupts();             // enable all interrupts
}

ISR(TIMER1_COMPA_vect)          // timer compare interrupt service routine
{
   // Mein Interrupt-Code, der jede 100ms ausgeführt wird:
   
   // wenn 100ms, dann LED an
   if(i==1) digitalWrite(ledPin, ! digitalRead(ledPin));
   
   // wenn 200ms, dann LED aus
   if(i==2) digitalWrite(ledPin, ! digitalRead(ledPin));
   
   // wenn 300ms, dann LED an
   if(i==3) digitalWrite(ledPin, ! digitalRead(ledPin));
   
   // wenn 400ms, dann LED aus
   if(i==4) digitalWrite(ledPin, ! digitalRead(ledPin));
   
   // nach 30x 100ms wieder von vorne anfangen
   if(i>=30) i=0;
   
   i++;  // pro 100ms 1x hochzählen
}

void loop()
{
  
 // Als Vergleich geht im Hauptprogramm alle 3 Sekunden eine andere LED an und aus.
 TXLED0; 
 delay(3000);              // wait for a second
 TXLED1;
 delay(3000);              // wait for a second
}

[BirgerT (Gast)]

Nun ja.. Nee

Geht es Dir um die Interrupt Programmierung oder um das "Multitasking"?

Die verlinkten Arduino Beispiele verwenden doch schon die Systemfunktion 
millis();
warum zapfst Du die nicht an?

Hast Du das auch gelesen (und verstanden)?
https://learn.adafruit.com/multi-tasking-the-arduino-part-1

Da ist zwar auch noch der Wurm drin - nach einem Überlauf alle 2^32ms 
wird's einen Aussetzer geben, aber bei LEDs?!

[Falk B. (falk)]

@ René J. (renej)

>scheint so, als ob ich es hinbekommen habe. Allerdings vermute ich sehr
>stark, dass ich eher umständlich programmiert habe.

In der Tat.

>So sieht mein Ansatz für "alle 3 Sekunden zweimal kurz (100ms)
>aufblinken" aus. Macht man das so?

Nein. Lies den Artikel Multitasking noch einmal und mach es richtig. 
Nebenbei solltest du dich auch mit dem switch Konstrukt beschäftigen, 
das verbessert die Struktur und Lesbarkeit deines Programms.

[René J. (renej)]

Der Artikel "Multitasking" ist für mich wie chinesisch zu lesen.

Beispiel:

    UBRRH = UBRR_VAL >> 8;
    UBRRL = UBRR_VAL & 0xFF;
    UCSRB = (1<<RXEN) | (1<<TXEN);

ja ne is klar :D Für mich sind Interrupts schon nicht leicht zu 
verstehen, da sind Variablennamen wie UBRRH, UBRRL und UCSRB natürlich 
unheimlich hilfreich ;)

Das Adafruit-Tutorial ist eher mein Ding, ich werds einfach noch 2-3mal 
durchackern... Irgendwann muss der Groschen ja fallen :D

[Falk B. (falk)]

@ René J. (renej)

>Der Artikel "Multitasking" ist für mich wie chinesisch zu lesen.

Weil du dich auf Nebensächlichkeiten konzentrierst!

>    UBRRH = UBRR_VAL >> 8;
>    UBRRL = UBRR_VAL & 0xFF;
>    UCSRB = (1<<RXEN) | (1<<TXEN);

Das ist die Initialisierung des UARTs per "Hand". Darum muss man sich 
beim Arduino nicht kümmern.

>Das Adafruit-Tutorial ist eher mein Ding, ich werds einfach noch 2-3mal
>durchackern... Irgendwann muss der Groschen ja fallen :D

Du musst "nur" das Prinzip verstehen. Ein Timer erzeugt in regelmäßigen 
Abständen ein Signal mittels einer Variablen (Flag). In diesem 
gleichmäßigen Zeitraster werden Funktionen aufgerufen, welche eine 
Statemachine abarbeiten und damit diverse Dinge tun. Der "Trick" 
lautet, niemals ein delay() zu nutzen und auch nie auf ein Ereignis zu 
warten, sondern nur bereits eingetroffene Ereignisse zu bearbeiten.

Steht alles im Artikel. Der Adafruit-Artikel macht fast das Gleiche, nur 
dass er es etwas "cooler" in einer Memberfunktion einer Klasse packt 
(C++), im Gegensatz zum einfachen Beispiel in old school C im Artikel 
hier.

Lass das erstmal mit der C++ Klasse, mach es erstmal einfach in C. Die 
Fehlerwahrscheinlichkeit ist geringer für einen Anfänger wie dich.

[EGS T. (egs_ti)]

Dann biste einfach noch nicht so weit. Ne Pause soll auch schonmal 
geholfen haben. Aber verstehen musste das schon selber. Und viel lesen.

[René J. (renej)]

Mein Problem ist ja, dass ich mehrmals kurz blinken will und dann 
erstmal nicht mehr.
Einen Interruptaufruf hingegen erhalte ich ja regelmäßig.

Und ich habe ja versucht, mit der Variablen i eine statemachine 
einzuführen:

   // Mein Interrupt-Code, der jede 100ms ausgeführt wird:
   
   // wenn 100ms, dann LED an
   if(i==1) digitalWrite(ledPin, ! digitalRead(ledPin));
   
   // wenn 200ms, dann LED aus
   if(i==2) digitalWrite(ledPin, ! digitalRead(ledPin));
   
   // wenn 300ms, dann LED an
   if(i==3) digitalWrite(ledPin, ! digitalRead(ledPin));
   
   // wenn 400ms, dann LED aus
   if(i==4) digitalWrite(ledPin, ! digitalRead(ledPin));
   
   // nach 30x 100ms wieder von vorne anfangen
   if(i>=30) i=0;
   
   i++;  // pro 100ms 1x hochzählen

Der Gedanke dabei war, dass NUR EINE if-Schleife pro Interruptvorgang 
durchgearbeitet und i inkrementiert wird. Also eine sehr kurze ISR.

Ich will ja irgendwann auch vllt. anders blinken, kurz und lang 
gemischt, daher die 3 Sekunden lange Zeit und 30 states.


Ich kann jetzt ja nicht einfach nur alle 3 Sekunden die ISR aufrufen und 
dann die blink-Codes ausführen, dann blockier ich ja den Rest des 
Programms für die Dauer die ich blinke...

[Falk B. (falk)]

@René J. (renej)

>Mein Problem ist ja, dass ich mehrmals kurz blinken will und dann
>erstmal nicht mehr.
>Einen Interruptaufruf hingegen erhalte ich ja regelmäßig.

Auch das ist kein Problem. Man muss nur einfach irgendwann mit dem 
Zählen aufhören.

etwa so

if (i<100) i++;  // zählt nur bis 100

>   // Mein Interrupt-Code, der jede 100ms ausgeführt wird:

Eben DORT gehört er NICHT hin! Das ist in beiden Beispielen klar 
sichtbar!

>Der Gedanke dabei war, dass NUR EINE if-Schleife pro Interruptvorgang

Es gibt keine If-Schleife, sondern nur eine If-Abfrage.

>Ich will ja irgendwann auch vllt. anders blinken, kurz und lang
>gemischt, daher die 3 Sekunden lange Zeit und 30 states.

Ja und?

>Ich kann jetzt ja nicht einfach nur alle 3 Sekunden die ISR aufrufen und
>dann die blink-Codes ausführen, dann blockier ich ja den Rest des
>Programms für die Dauer die ich blinke...

Du hast das Prinzip noch nicht verstanden. Nochmal lesen und nachdenken.

[René J. (renej)]

Falk B. schrieb:

>
> Eben DORT gehört er NICHT hin! Das ist in beiden Beispielen klar
> sichtbar!

Also dann eher so?

#define ledPin 17   // LED die blinken soll
int i = 1;          // counter, der pro interrupt incrementiert wird

void setup()
{
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  
  // initialize timer1 
  noInterrupts();           // disable all interrupts
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1  = 0;
  
  // 16MHz/256 = 62500 für eine Sekunde, 6250 fuer 100ms
  OCR1A = 6250;             // compare match register 16MHz/256/2Hz  
  TCCR1B |= (1 << WGM12);   // CTC mode
  TCCR1B |= (1 << CS12);    // 256 prescaler 
  TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
  interrupts();             // enable all interrupts
}

ISR(TIMER1_COMPA_vect) {         // timer compare interrupt service routine
   // Mein Interrupt-Code, der jede 100ms ausgeführt wird   
   i++;            // pro 100ms 1x hochzählen
   if(i>=30) i=0;  // nach 30x 100ms wieder von vorne anfangen
}

void blinken () {
  
  switch (i) {
    case 1:  // 100ms
       digitalWrite(ledPin, LOW);   // LED1 an
       TXLED1;                      // LED2 an
       break;
    case 2:
       digitalWrite(ledPin, HIGH);  // LED1 aus
       break;
    case 3:
       digitalWrite(ledPin, LOW);   // LED1 an
       break;
    case 4:
       digitalWrite(ledPin, HIGH);  // LED1 aus
       break;
    case 20:
       TXLED0;                      // LED2 aus
       break;
  }
}


void loop() {

blinken();
  
}

Aber woher weiß ich dann, ob blinken() immer rechtzeitig aufgerufen 
wird? Wenn mein Programm später mal größer wird und der interrupt 2x 
aufgerufen wird, bevor die mainfunktion einmal durch ist, zerhauts mir 
ja das blinken. Oder sind die 100ms SOOOOOOOO viel Zeit, dass das nicht 
passieren wird?

[OldMan (Gast)]

René J. schrieb:
> 100ms SOOOOOOOO viel Zeit

Ja, 100ms sind fast eine Ewigkeit.
Bei 1 MHz Takt benötigt der AVR 1us pro Befehl (auf Maschinencodeebene).
D.h. Du hast Zeit für 100.000 Befehle in den 100ms.
Das sollte ausreichend sein.

[BirgerT (Gast)]

René J. schrieb:

> Also dann eher so?
>
>

Jau.. schon besser, aber eigentlich noch immer nicht, was wir Dir gerne 
"beigebracht" hätten..

> Aber woher weiß ich dann, ob blinken() immer rechtzeitig aufgerufen
> wird? Wenn mein Programm später mal größer wird und der interrupt 2x
> aufgerufen wird, bevor die mainfunktion einmal durch ist, zerhauts mir
> ja das blinken. Oder sind die 100ms SOOOOOOOO viel Zeit, dass das nicht
> passieren wird?

Wenn auf delays verzichtet wird, ja

Und noch etwas, damit's funktioniert

volatile int i = 1;      // counter, der pro interrupt incrementiert wird
:
ISR(TIMER1_COMPA_vect) {         // timer compare interrupt service routine
   // Mein Interrupt-Code, der jede 100ms ausgeführt wird   
   i++;            // pro 100ms 1x hochzählen
//   if(i>=30) i=0;  // nach 30x 100ms wieder von vorne anfangen
}

void blinken () {
  
  switch (i) {
    case 1:  // 100ms
       digitalWrite(ledPin, LOW);   // LED1 an
       TXLED1;                      // LED2 an
       break;
    case 2:
       digitalWrite(ledPin, HIGH);  // LED1 aus
       break;
    case 3:
       digitalWrite(ledPin, LOW);   // LED1 an
       break;
    case 4:
       digitalWrite(ledPin, HIGH);  // LED1 aus
       break;
    case 20:
       TXLED0;                      // LED2 aus
       break;

    case 30:
       i=0;  // nach 30x 100ms wieder von vorne anfangen
       break;

  }
}

Mit dem Adafruit Beispiel könntest Du die LEDs auch im 10ms- oder 25ms- 
oder 88ms-Takt blinken lassen.

Ich verwende zwar auch einen anderen Ansatz, bei dem die Mainloop immer 
alle 100ms durchgeackert wird, und den Timer1 für einen 1ms Interrupt, 
in den ich 10 Funktionen "einklinken" kann, die dann alle 10ms 
aufgerufen werden.

Wenn's Dich interessiert:
http://www.roboter.cc/index.php?option=com_nicaiwci&view=project&Itemid=41&projectid=3743

Und ich tue mich auch schwer, auf das augenscheinlich bessere "System 
Adafruit" umzusteigen.
Auch einen gut kommentierten Code findest Du auf der rp6 Site von arexx; 
dort werden sogenannte "stopwatches" verwendet.

[Falk B. (falk)]

@ René J. (renej)

>Also dann eher so?

Besser, aber noch nicht gut. In die ISR kommt nur das Setzen des Flags, 
wie im Beispiel gezeigt. Der Zähler ghört in die einzelnen Funktionen!

volatile uint8_t timer_flag;

ISR(TIMER1_COMPA_vect) {         // timer compare interrupt service routine
   timer_flag=1;
}

void blinken () {

  static uint8_t i;
  
  switch (i) {
    case 1:  // 100ms
       digitalWrite(ledPin, LOW);   // LED1 an
       TXLED1;                      // LED2 an
       break;
    case 2:
       digitalWrite(ledPin, HIGH);  // LED1 aus
       break;
    case 3:
       digitalWrite(ledPin, LOW);   // LED1 an
       break;
    case 4:
       digitalWrite(ledPin, HIGH);  // LED1 aus
       break;
    case 20:
       TXLED0;                      // LED2 aus
       break;
  }

   i++;            // pro 100ms 1x hochzählen
   if(i>=30) i=0;  // nach 30x 100ms wieder von vorne anfangen
}

void loop() {
  if (timer_flag) {
    timer_flag = 0;
    blinken();
  }
}

>Aber woher weiß ich dann, ob blinken() immer rechtzeitig aufgerufen
>wird?

Kann man direkt während der Laufzeit prüfen.

https://www.mikrocontroller.net/articles/Multitasking#Verbesserter_Ansatz_mit_Timer

"Es kann leicht im realen System geprüft werden, ob die Laufzeit der 
Tasks klein genug ist, um den Anforderungen des Timers zu genügen.

Diese Überprüfung kann an zwei Stellen durchgeführt werden. "


Oder durch eine Simulation oder Messung.

https://www.mikrocontroller.net/articles/Interrupt#Wie_lange_dauert_meine_Interruptroutine.3F

Hier geht es zwar um die Messung der Zeit der Interruptroutine, die ist 
in diesem Beispiel extrem kurz. Aber das Gleiche kann man natürlich auch 
mit normalen Funktionen machen.

>ja das blinken. Oder sind die 100ms SOOOOOOOO viel Zeit, dass das nicht
>passieren wird?

Das auch.