1.5 ⏲️ Timer

Ein Timer ist ein feines Stück eingebauter Hardware in einem Mikrocontroller, nach einer einstellbaren Zeit kann er z.B. einen Interrupt auslösen. Als Zeitbasis braucht er einen Timer-Takt (CK_PSC), hier sind es 32 MHz (andere Taktquellen sind einstellbar). Um z.B. jede Sekunde einen Interrupt auslösen zu können bräuchte man einen Zähler der bis 32 Millionen zählt (wie viele Bit müsste der haben?). Statt dessen werden ein Vorteiler (Prescaler Register PSC) mit 16 Bit und ein 16 Bit Zähler (CTR DIV 65536) kombiniert, die einstellbaren Werte der Hardware-Register für beide können daher 65535 nicht überschreiten. Der Prescaler (Vorteiler) teilt den Timertakt mit einem einstellbaren VorteilerFaktor (1..65536) (PSC-Registerwert 0..65535; PSC=0 -> Takt/1) und mit diesem langsameren Takt zählt ein Zähler bis zu einem vorgegebenen Wert im Auto-Reload Register ARR. Beim Erreichen des ARR-Wertes wird der Zähler wieder auf 0 gesetzt und ein Timer-Interrupt kann auslöst werden. In der STM32-API wird dafür die Bezeichnung Overflow eingeführt:

$ PSC = PrescaleFactor-1 $
$ ARR = Overflow-1 $

Beispiel: Overflow hat den Wert 2, es wird ARR auf 1 gesetzt. Das bewirkt beim Erreichen des Zählerwertes 1 ein Zurückstellen auf 0 und das Setzen eines Interrupt-Flags. Zwei Zählertakte sind dabei vergangen. Overflow gibt also die Anzahl der Zählertakte bis zum Zurücksetzen an. Ein Overflowwert von 1 (ARR=0) scheint allerdings nicht zu funktionieren.
AVR-Bemerkung: Funktioniert wie CTC.
Es gibt 3 Varianten um den Timer mit setOverflow() ein zu stellen:

• Ticks: z.B. setOverflow(10000, TICK_FORMAT); nach 10000 Zählertakten wird ISR ausgelöst, dazu muss auch der Prescaler gesetzt werden..
• Hertz: z.B. setOverflow(10000, HERTZ_FORMAT); die ISR wird mit 10kHz also alle 100µs ausgelöst, der Prescaler wird automatisch eingestellt.
• µs: z.B. setOverflow(10000, MICROSEC_FORMAT); nach 10000µs=10ms wird ISR auslöst, der Prescaler wird automatisch eingestellt.

Timer Befehle

TICK_FORMAT ausprobieren und berechnen

Beim TICK_FORMAT müssen Prescaler und Overflow-Wert des Zählers selber eingestellt werden. Es ist das voreingestellte Format, wenn kein zweiter Parameter bei setOverflow(…) angegeben wird. Ich habe die zu erwartende Frequenz an der LED berechnet und mit diesem Beispielcode einige Messungen durchgeführt.

#define P_BLED PA5 // Led auf dem Board (BoardLED) an Pin D13/PA5
static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timeruaswahl
void isr_blinken(){
  digitalWrite(P_BLED,!digitalRead(P_BLED)); // LED invertieren
}
void setup() {
  pinMode(P_BLED,OUTPUT); // BoardLED
  mytimer.setOverflow(100, TICK_FORMAT); // 2..65536
  mytimer.setPrescaleFactor(32000);  // 1..65536
  mytimer.attachInterrupt(isr_blinken); //Timer IR aktivieren und Sprung zur ISR// put your setup code here, to run once:
  mytimer.resume();
}
void loop() {
}

Hinweis: Die Frequenz der ISR-Aufrufe ist doppelt so hoch wie die Frequenz der blinkenden LED, weil bei jedem Interrupt die LED umgeschaltet wird.

$ Frequenz_{ISR} = Frequenz_{TimerCLK} / PreFaktor / Overflow / = 32 * 10^6 Hz / 32000 / 100 / = 10 Hz $
$ Frequenz_{LED} = Frequenz_{TimerCLK} / PreFaktor / Overflow / 2 = 32 * 10^6 Hz / 32000 / 100 / 2 = 5 Hz $

🖥 Erstellen Sie eine Tabellenkalkulation für die Berechnung der Frequenzen.

✍️ Die LED soll nun mit 0,5 Hz blinken, 1 s an und 1 s aus. Ermitteln Sie passende Werte für Prescaler und Overflow.

Welchen Wert bekommt Overflow, wenn Zahl nicht in die Bitbreite passt?

Bsp. das ARR sei 16 Bit breit und mit setOverflow(70000) gesetzt. Mit getOverflow() erhält man dann den Wert 4464 zurück. Die Bits, die nicht in das Register passen werden links abgeschnitten. 70000 = 0x11170 auf 16 Bit zurechtschneiden: 0x1170=4464

Die Erfindung der Taktzahl

Die Timer-ISR soll alle 10 ms aufgerufen werden, ermittle passende Werte für Prescaler und Overflow.

$ Zeit_{ISR} = Prescaler * Overflow / TimerCLK $
$ \Leftrightarrow Zeit_{ISR} * TimerCLK = Prescaler * Overflow = \textbf{Taktzahl} $

Letztlich werden Takte gezählt und die Anzahl der Takte auf Prescaler und Overflow geschickt verteilt.

$ \textbf{Taktzahl} = Zeit_{ISR} * TimerCLK $
$ \textbf{Taktzahl} = Prescaler * Overflow $

Berechnen wir die Zahl der zu zählenden Takte:

$ \textbf{Taktzahl} = 10 ms * 32 MHz = 10 *10^{-3} s * 32 * 10^6 Hz = 320 * 10^3 = 320.000 $

Nun die Qual der Wahl: Welche Kombination von Prescaler und Overflow die 320.000 als Produkt ergibt sollen wir nun wählen? Zeit um sich die beiden anderen Timer-Formate an zu sehen.

🍬 Info: Einfach mit Hertz

Hier ein Testprogramm um das Hertz-Format zu erkunden, dabei wird Prescaler und Overflow passend eingestellt. isr_blinken() wird am Anfang jede Sekunde aufgerufen. Durch Druck auf den UserButton verdoppelt sich die Frequenz und die eingestellten Werte werden angezeigt.

#define LED_B PA5 // D13 Led auf dem Board
#define T_B PC13  // Entpreller UserButton auf dem Board
static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timerauswahl
volatile int isrFrequenz = 1;
void isr_blinken(){
  digitalWrite(LED_B,!digitalRead(LED_B));
}
void isr_gedruecktT_B(){ // Interrupt Service Routine
  isrFrequenz*=2;
  stelleTimer();
}
void stelleTimer(){ // Timer einstellen und Werte anzeigen
  mytimer.setOverflow(isrFrequenz, HERTZ_FORMAT);
  Serial.printf("ISR-Freq.: %3d Sytemtakt %d Prescaler %5d Overflow %5d \n", isrFrequenz,mytimer.getTimerClkFreq(),mytimer.getPrescaleFactor(),mytimer.getOverflow());
}
void setup() {
  Serial.begin (115200); //Serielle kommunikation starten
  pinMode(LED_B,OUTPUT); // BoardLED
  stelleTimer();
  mytimer.attachInterrupt(isr_blinken); // Timer ISR einstellen
  mytimer.resume();  // Timer aktivieren
  pinMode(T_B,INPUT);
  attachInterrupt (digitalPinToInterrupt (T_B), isr_gedruecktT_B, FALLING);
}
void loop() {
}

ISR-Freq.:   1 Hz TimerCLK: 32 MHz Prescaler:   489 Overflow: 65439
ISR-Freq.:   2 Hz TimerCLK: 32 MHz Prescaler:   245 Overflow: 65306
ISR-Freq.:   4 Hz TimerCLK: 32 MHz Prescaler:   123 Overflow: 65040
ISR-Freq.:   8 Hz TimerCLK: 32 MHz Prescaler:    62 Overflow: 64516

Es fällt auf, dass der Prescaler möglichst klein und der Overflow möglichst groß gewählt wurde. Diese Strategie ist geschickt, wenn damit Pulsweitenmodulation (PWM) oder Zeitmessung mit dem Zähler gemacht werden sollen. Je größer der Prescaler, desto größer sind die Zeithäppchen, die der Zähler bekommt und desto ungenauer lässt sich mit Overflow die Zeit damit einstellen. Also möglichst kleine Zeithäppchen -> Prescaler minimal.

$ \textbf{Prescaler} = Taktzahl / 65536 = 32 * 10^6 / 65536 = 488,28 $

Einfach Runden ist keine gute Idee, denn dann wären die Zeithäppchen hier zu klein, es müssten zu viele davon gezählt werden:

$ \textbf{Overflow} = Taktzahl / Prescaler = 32 * 10^6 / 488 = 65573 > 65535 ! $

Hier also Aufrunden auf 489.

$ \textbf{Overflow} = Taktzahl / Prescaler = 32 * 10^6 / 489 = 65439,67 < 65535 ! $

Auf welchen Wert Overflow einstellen? Ich würde runden, allerdings scheint die API an dieser Stelle bei Hertz- und Mikrosekunden-Format abzurunden, es wird mit Integer gerechnet. Probe machen:

$ \textbf{FreqISR} = TimerCLK / Prescaler / Overflow = \frac{32 MHz} {489 * 65439} = \frac{32 MHz} {31999671} = 1,00001 Hz $

$ \textbf{ZeitISR} = Prescaler * Overflow / TimerCLK = \frac{489 * 65439} {32 MHz} = 0,99998 s $

🖥 Erstellen Sie eine Tabellenkalkulation zur Berechnung der Werte.

🍬 Info: MICROSEC_FORMAT

#define LED_B PA5 // D13 Led auf dem Board
#define T_B PC13  // Entpreller UserButton auf dem Board
static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timerauswahl
volatile int isrMicrosec = 10000;
void isr_blinken(){
  digitalWrite(LED_B,!digitalRead(LED_B));
}
void isr_gedruecktT_B(){ // Interrupt Service Routine
  isrMicrosec*=2;
  stelleTimer();
}
void stelleTimer(){ // Timer einstellen und Werte anzeigen
  mytimer.setOverflow(isrMicrosec, MICROSEC_FORMAT);
  Serial.printf("Zeit-ISR: %8d us TimerCLK: %d MHz Prescaler: %5d Overflow: %5d\n",isrMicrosec,mytimer.getTimerClkFreq()/1000000,mytimer.getPrescaleFactor(),mytimer.getOverflow());
}
void setup() {
  Serial.begin (115200); //Serielle kommunikation starten
  pinMode(LED_B,OUTPUT); // BoardLED
  stelleTimer();
  mytimer.attachInterrupt(isr_blinken); // Timer ISR einstellen
  mytimer.resume();  // Timer aktivieren
  pinMode(T_B,INPUT);
  attachInterrupt (digitalPinToInterrupt (T_B), isr_gedruecktT_B, FALLING);
}
void loop() {
}

Zeit-ISR:    10000 us TimerCLK: 32 MHz Prescaler:     5 Overflow: 64000
Zeit-ISR:    20000 us TimerCLK: 32 MHz Prescaler:    10 Overflow: 64000
Zeit-ISR:    40000 us TimerCLK: 32 MHz Prescaler:    20 Overflow: 64000
Zeit-ISR:    80000 us TimerCLK: 32 MHz Prescaler:    40 Overflow: 64000
Zeit-ISR:   160000 us TimerCLK: 32 MHz Prescaler:    79 Overflow: 64810
Zeit-ISR:   320000 us TimerCLK: 32 MHz Prescaler:   157 Overflow: 65222
Zeit-ISR:   640000 us TimerCLK: 32 MHz Prescaler:   313 Overflow: 65431
Zeit-ISR:  1280000 us TimerCLK: 32 MHz Prescaler:   626 Overflow: 65431
Zeit-ISR:  2560000 us TimerCLK: 32 MHz Prescaler:  1251 Overflow: 65483
Zeit-ISR:  5120000 us TimerCLK: 32 MHz Prescaler:  2501 Overflow: 65509
Zeit-ISR: 10240000 us TimerCLK: 32 MHz Prescaler:  5001 Overflow: 65522

Wie wird jetzt Prescaler und Overflow berechnet? Erstellen Sie eine Tabellenkalkulation. Werden die Werte von setOverflow() optimal berechnet?

🛤️ Gleisanlage (HP16-1)

Für den Bahnhof einer Modellbahnanlage soll eine Steuerung entworfen werden. Der Bahnhof besitzt 6 Gleise. Diese Gleise werden über die Weichen W0 (PC0) bis W4 (PC4) angefahren. Eine Lichtschranke LS (PC13) erfasst vor der ersten Weiche die einfahrenden Züge. Die Züge werden zyklisch aufsteigend (nach Gleis 5 wieder auf Gleis 0) auf die 6 Gleise des Bahnhofs verteilt. (Auffahrunfälle werden durch die hier nicht betrachtete Signalanlage verhindert). Die gelben Zahlen geben die Stellung der Weichen an. Bei einer 0 fährt der Zug nach „oben“, bei einer 1 nach „unten“. Nach dem Start befindet sich das Programm im „Automatikmodus“ bei dem alle 5 Sekunden isr_5sekunden() ein Gleis durch wechsleGleis() zyklisch weitergeschaltet wird. In einem zweiten Modus „Interruptbetrieb“ werden die Gleise bei Unterbrechung der Lichtschranke durch isr_lichtschranke() weiter geschaltet. Der Wechsel zwischen den beiden Modi geschieht mit isr_moduswechsel() die bei Druck auf Taste PA1 ausgelöst wird. Folgender Quellcode ist gegeben:

enum {AUTOMATIKMODUS,INTERRUPTBETRIEB} zustand=AUTOMATIKMODUS; 
volatile int gleis = 0; // wird in ISR verändert daher volatile
const int fahrstrasse[] = {0b00000, 0b10000, 0b00001, 0b10001, 0b00011, 0b00111};

static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timeruaswahl

# define LICHTSCHRANKE PC13  // Entpreller lowaktiver UserButton auf dem Board
# define MODUSWECHSEL PA1    // Nicht entprellter highaktiver Taster

void wechsleGleis(){ // gleis eins weiter schalten: 0,1,2,3,4,5->0,1...
 
}
void isr_lichtschranke(){ // im INTERRUPTBETRIEB Gleis weiterschalten
  
}
void isr_moduswechsel(){ // zwischen AUTOMATIKMODUS und INTERRUPTBETRIEB wechseln
  
}
void isr_5sekunden(){ // im AUTOMATIKMODUS Gleis weiter schalten
  
}
void setup() {
  pinMode(PC0, OUTPUT);           // ohne diese Zeile klappts nicht mit MODER
  GPIOC->MODER = 0x5555;          // PC0..PC7 als Ausgang
  pinMode(LICHTSCHRANKE, INPUT);  // nicht notwendig?
  pinMode(MODUSWECHSEL, INPUT_PULLDOWN);   // notwendig wegen PullDown einschalten
  
}
void loop() {
}

Erstellen Sie ein Zustandsdiagramm.

Lösungsvorschlag Zustandsdiagramm

Vervollständigen Sie den Quellcode für:

• wechsleGleis() die Variable gleis wird zum nächsten Gleis weitergeschaltet und die Weichen gestellt.
• setup() Timer-ISR für 5 Sekunden einstellen, ISRs für Lichtschranke und Moduswechsel (Entprellen nicht notwendig).
• ISR_lichtschranke(), ISR_moduswechsel(), ISR_5sekunden()

enum {AUTOMATIKMODUS,INTERRUPTBETRIEB} zustandstyp;
volatile zustandstyp zustand=AUTOMATIKMODUS; 
volatile int gleis = 0; // wird in ISR verändert daher volatile
const int fahrstrasse[] = {0b00000, 0b10000, 0b00001, 0b10001, 0b00011, 0b00111};

static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timeruaswahl

# define LICHTSCHRANKE PC13  // Entpreller lowaktiver UserButton auf dem Board
# define MODUSWECHSEL PA1    // Nicht entprellter highaktiver Taster

void wechsleGleis(){ // gleis eins weiter schalten: 0,1,2,3,4,5->0,1...
  gleis = (gleis + 1) % 6;
  GPIOC->ODR = fahrstrasse[gleis];
}
void isr_lichtschranke(){ // im INTERRUPTBETRIEB Gleis weiterschalten
  switch(zustand){
    case INTERRUPTBETRIEB:
      wechsleGleis();
      break;
  }
}
void isr_moduswechsel(){ // zwischen AUTOMATIKMODUS und INTERRUPTBETRIEB wechseln
  switch(zustand){
    case AUTOMATIKMODUS:
      zustand = INTERRUPTBETRIEB;
      break;
    case INTERRUPTBETRIEB:
      zustand = AUTOMATIKMODUS;
      break;
  }
}
void isr_5sekunden(){ // im AUTOMATIKMODUS Gleis weiter schalten
  switch(zustand){
    case AUTOMATIKMODUS:
      wechsleGleis();
      break;
  }
}
void setup() {
  pinMode(PC0, OUTPUT);           // ohne diese Zeile klappts nicht
  GPIOC->MODER = 0x5555;          // PC0..PC7 als Ausgang
  pinMode(LICHTSCHRANKE, INPUT);  
  pinMode(MODUSWECHSEL, INPUT_PULLDOWN);   // Start
  attachInterrupt (digitalPinToInterrupt (LICHTSCHRANKE), isr_lichtschranke, FALLING);
  attachInterrupt (digitalPinToInterrupt (MODUSWECHSEL), isr_moduswechsel, RISING);
  mytimer.setOverflow(5000000, MICROSEC_FORMAT); // 5 sec = 5 000 000 µs
  mytimer.attachInterrupt(isr_5sekunden); //Timer IR aktivieren und Sprung zur ISR
  mytimer.resume();   //Timer starten
}
void loop() {
}

Zusatzaufgabe: Im Automatikbetrieb soll nur noch 3 Mal jedes Gleis geschaltet und dann in den Interruptbetrieb gewechselt werden. Beim Moduswechsel in den Automatikbetrieb wird der Gleiswechselzähler wieder auf 0 gesetzt. Entwerfen Sie Zustandsdiagramm und Quellcode.

Lösungsvorschlag Zustandsdiagramm

#include <Arduino.h>
enum zustandstyp {AUTOMATIKMODUS,INTERRUPTBETRIEB};
volatile zustandstyp zustand=AUTOMATIKMODUS; 
volatile int gleis = 0; // wird in ISR verändert daher volatile
int gleiswechsel=0; // scheint ohne volatile zu funktionieren 
const int fahrstrasse[] = {0b00000, 0b10000, 0b00001, 0b10001, 0b00011, 0b00111};

static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timeruaswahl

# define LICHTSCHRANKE PC13  // Entpreller lowaktiver UserButton auf dem Board
# define MODUSWECHSEL PA1    // Nicht entprellter highaktiver Taster

void wechsleGleis(){ // gleis eins weiter schalten: 0,1,2,3,4,5->0,1...
  gleis = (gleis + 1) % 6;
  GPIOC->ODR = fahrstrasse[gleis];
}
void isr_lichtschranke(){ // im INTERRUPTBETRIEB Gleis weiterschalten
  switch(zustand){
    case INTERRUPTBETRIEB:
      wechsleGleis();
      break;
  }
}
void isr_moduswechsel(){ // zwischen AUTOMATIKMODUS und INTERRUPTBETRIEB wechseln
  switch(zustand){
    case AUTOMATIKMODUS:
      zustand = INTERRUPTBETRIEB;
      break;
    case INTERRUPTBETRIEB:
      gleiswechsel=0;
      zustand = AUTOMATIKMODUS;
      break;
  }
}
void isr_5sekunden(){ // im AUTOMATIKMODUS Gleis weiter schalten
  switch(zustand){
    case AUTOMATIKMODUS:
      if(gleiswechsel>=18){
        zustand=INTERRUPTBETRIEB;
      }
      else{
        wechsleGleis();
        gleiswechsel++;
      }
      break;
  }
}
void setup() {
  pinMode(PC0, OUTPUT);           // ohne diese Zeile klappts nicht
  GPIOC->MODER = 0x5555;          // PC0..PC7 als Ausgang
  pinMode(LICHTSCHRANKE, INPUT);  
  pinMode(MODUSWECHSEL, INPUT_PULLDOWN);   // Start
  attachInterrupt (digitalPinToInterrupt (LICHTSCHRANKE), isr_lichtschranke, FALLING);
  attachInterrupt (digitalPinToInterrupt (MODUSWECHSEL), isr_moduswechsel, RISING);
  mytimer.setOverflow(5000000, MICROSEC_FORMAT); // 5 sec = 5 000 000 µs
  mytimer.attachInterrupt(isr_5sekunden); //Timer IR aktivieren und Sprung zur ISR
  mytimer.resume();   //Timer starten
}
void loop() {
}

⏰ Wecker stellen

Häufig werden für die Programmierung eines zeitlichen Ablaufs „Wecker“ benötigt. Eine Verzögerung mit delay(..) unterbricht den Programmablauf und ist oft nicht geschickt. Praktisch wäre ein Wecker, der nach Ablauf der Zeit die gewünschte Aktion auslöst ohne den Programmfluss zu behindern.
Hier zeige ich drei typische Lösungsansätze.
Aufgabe: Mit dem UserButton an PC13 soll ein 5 Sekunden Wecker gestellt werden, der statt Klingeln 0,3 Sekunden die BoardLED an D13/PA5 leuchten und einen 2kHz Ton auf einem Piezo-Lautsprecher an D11/PA7 mit tone()🔗 ausgibt.

Lösung mit Timer-ISR

Die Timer-ISR wird für die Weckzeit und für die Länge des Tones verwendet.

#include <Arduino.h>
static HardwareTimer myWecker = HardwareTimer(TIM2);  // Timerinstanz für Zeit

#define P_USERBTN PC13  // Entpreller lowaktiver UserButton auf dem Board
#define P_BLED 13       // Boardled D13/PA5
#define P_PIEZO PA7     // Lautsprecher an PA7/D11
enum zustandstyp {CHILLEN,WECKER,WECKEN};
volatile zustandstyp zustand=CHILLEN;

void starteWecken(){ // den Pieper kurz piepen lassen
  tone(P_PIEZO,2000);// Ton mit 2kHz ausgeben
  digitalWrite(P_BLED,HIGH);
}
void endeWecken(){  // piepen beenden
  noTone(P_PIEZO);  // Tonausgabe beenden
  digitalWrite(P_BLED,LOW);
}
void isr_start(){    // UserButton
  if(zustand==CHILLEN){
    stelleWecker(5000); // 5s
    zustand=WECKER;
  }
}
void stelleWecker(int n){
  myWecker.setOverflow(n); // Zeit in ms einstellen
  myWecker.setCount(0);    // Zählerstand auf 0 stellen, nicht unbedingt nötig
  myWecker.resume();       // Timer starten
}
void isr_wecken(){  // Wecker ist abgelaufen (timeout)
  myWecker.pause(); // Timer stoppen
  switch(zustand){
    case WECKER:
      starteWecken();
      stelleWecker(300); // 0,3s
      zustand=WECKEN;
      break;
    case WECKEN:
      endeWecken();
      zustand=CHILLEN;
      break;  
  }
}
void setup() {
  pinMode(P_BLED,OUTPUT);
  attachInterrupt (digitalPinToInterrupt (P_USERBTN), isr_start, FALLING);
  myWecker.setPrescaleFactor(32000); // 32MHz/32000 = 1kHz -> 1ms Periodendauer
  myWecker.attachInterrupt(isr_wecken);            // ISR einstellen
  Serial.begin(9600);
}
void loop() {
}

Ist myWecker.setCount(0); notwendig? Nicht unbedingt, da bei Overflow der Zähler wieder auf 0 gesetzt wird und in der ISR mit myWecker.pause(); gestoppt wird.

1. Ermitteln Sie die längste Weckzeit, die mit Timer-ISR erreicht werden kann: Prescaler, Overflow, Herleitung!
2. Wie können längere Weckzeiten erzielt werden?
3. Wird der Wecker neu gestartet, wenn während der Wecker läuft der UserButton erneut gedrückt wird?

💊 Timer-ISR und lange Zeiten

Nun soll der Wecker mit Timer ISR auch für längere Zeiten z.B. 10 min verwendbar sein. Dazu muss in der ISR gezählt werden, Vorüberlegung:
Wecker ist von 0,1 s bis 10 min einstellbar. Idee: Timer-ISR alle 0,1 s aufrufen, 10 min sind 6000 Aufrufe, Datentyp Integer ist ausreichend.

#include <Arduino.h>
static HardwareTimer myWecker = HardwareTimer(TIM2);  // Timerinstanz für Zeit

#define P_USERBTN PC13  // Entpreller lowaktiver UserButton auf dem Board
#define P_BLED 13       // Boardled D13/PA5
#define P_PIEZO PA7     // Lautsprecher an PA7/D11
enum zustandstyp {CHILLEN,WECKER,WECKEN};
volatile zustandstyp zustand=CHILLEN;
volatile int weckerticks = 0;
volatile int weckzeit = 0;

void starteWecken(){ // den Pieper kurz piepen lassen
  tone(P_PIEZO,2000);// Ton mit 2kHz ausgeben
  digitalWrite(P_BLED,HIGH);
}
void endeWecken(){  // piepen beenden
  noTone(P_PIEZO);  // Tonausgabe beenden
  digitalWrite(P_BLED,LOW);
}
void isr_start(){    // UserButton
  if(zustand==CHILLEN){
    stelleWecker(50); // 5s
    zustand=WECKER;
  }
}
void stelleWecker(int n){ // 0,1s Auflösung
  weckerticks = 0;
  weckzeit = n;
  myWecker.setCount(0);   // zur Sicherheit
  myWecker.resume();      // Timer starten
}
void isr_wecken(){  // Zeiten vergleichen
  if(++weckerticks>=weckzeit){ // wenn Zeit abgelaufen
    myWecker.pause();        // Timer stoppen
    switch(zustand){
      case WECKER:
        starteWecken();
        stelleWecker(3); // 0,3s
        zustand=WECKEN;
        break;
      case WECKEN:
        endeWecken();
        zustand=CHILLEN;
        break;  
    }
  }
}
void setup() {
  pinMode(P_BLED,OUTPUT);
  attachInterrupt (digitalPinToInterrupt (P_USERBTN), isr_start, FALLING);
  myWecker.setPrescaleFactor(32000); // 32MHz/32000 = 1kHz -> 1ms Periodendauer
  myWecker.setOverflow(100);         // alle 100ms
  myWecker.attachInterrupt(isr_wecken);            // ISR einstellen
  Serial.begin(9600);
}
void loop() {
}

Alternative Lösung

volatile int weckzeit = 0;

void stelleWecker(int n){ // 0,1s Auflösung
  weckzeit = n;
  myWecker.setCount(0);   // zur Sicherheit
  myWecker.resume();      // Timer starten
}
void isr_wecken(){  // Zeiten vergleichen
  if(--weckzeit==0){ // wenn Zeit abgelaufen
    myWecker.pause();        // Timer stoppen
    switch(zustand){
      case WECKER:
        starteWecken();
        stelleWecker(3); // 0,3s
        zustand=WECKEN;
        break;
      case WECKEN:
        endeWecken();
        zustand=CHILLEN;
        break;  
    }
  }
}

Lösung mit millis()

Bei Arduino ist eine Funktion millis(): uint32_t🔗 eingebaut (intern wird dafür ein Timer abgestellt der die Zeit zählt), sie gibt die Millisekunden seit Systemstart zurück.

static HardwareTimer myPieper = HardwareTimer(TIM3);  // Timerinstanz für Piepen

#define USER_BTN PC13  // Entpreller lowaktiver UserButton auf dem Board
#define PIEZO_PIN PA7  // Lautsprecher an PA7/D11 -> TIM3_CH2
#define KANAL 2        // CH2
volatile unsigned long weckzeit; // wann der Wecker "klingeln" soll
enum zustandstyp {CHILLEN,WECKER,PIEPEN};
volatile zustandstyp zustand=CHILLEN;

void stelleWecker(int n){ // n ist Zeit in ms
  weckzeit = millis()+n;
}
bool abgelaufenWecker(){
  return millis()>=weckzeit;
}

void isr_userB(){  // Wecker stellen
  switch(zustand){
    case CHILLEN:
      stelleWecker(5000); // auf 5 Sekunden stellen
      zustand=WECKER;
  }
}

void setup() {
  pinMode(USER_BTN, INPUT);
  attachInterrupt (digitalPinToInterrupt (USER_BTN), isr_userB, FALLING);
  myPieper.setOverflow(2000, HERTZ_FORMAT); // Frequenz einstellen
  myPieper.setCaptureCompare(KANAL,50,PERCENT_COMPARE_FORMAT); // Impulsbreite 50%
  myPieper.setMode(KANAL, TIMER_OUTPUT_COMPARE_PWM1, PIEZO_PIN); // Den PWM-Ausgang einstellen
}
void loop() {
  switch(zustand){
    case CHILLEN:
      break;
    case WECKER: // Wecker ist gestellt, warten auf Klingeln
      if(abgelaufenWecker()){
        myPieper.resume(); // Pieper an
        stelleWecker(300); // 0,3s
        zustand=PIEPEN;
      }
      break;
    case PIEPEN: // Piepen auch mit Wecker gelöst
      if(abgelaufenWecker()){
        myPieper.pause();
        zustand=CHILLEN;
      }
      break;  
  }
}

1. Erstellen Sie ein Zustandsdiagramm für den Code.
2. Was passiert, wenn während der Wecker läuft der UserButton erneut gedrückt wird?
3. Was passiert, wenn während des Piepens der UserButton gedrückt wird?
4. Nach welcher Zeit springt millis() wieder auf 0? Muss dies bei dem Wecker beachtet werden, Begründung?
5. Bonus: Entwickeln Sie eine Totmanneinrichtung🔗

Lösung 1

Lösung mit selbst gebautem Zeitticker

Wenn Software ohne Arduino-Umgebung erstellt wird und deshalb millis() nicht zu Verfügung steht wünsche ich mir für Weckzeiten einen eigenen Zeitticker, ich habe in diesen Fällen oft in einem periodischen Interrupt z.B. für eine Multiplexanzeige einen Zähler eingebaut, der mir eine Zeitbasis (Ticks) gibt. Für die Problemstellung würde als Zeitbasis 0,1 Sekunden reichen.
Erstellen Sie eine Lösung mit einem Timer myTicker, der alle 0,1 s eine Variable myTicks:GZ hochzählt und deren Weckzeiten darauf basiert.

static HardwareTimer myTicker = HardwareTimer(TIM2);  // Timerinstanz für Zeit
static HardwareTimer myPieper = HardwareTimer(TIM3);  // Timerinstanz für Piepen

#define USER_BTN PC13  // Entpreller lowaktiver UserButton auf dem Board
#define PIEZO_PIN PA7  // Lautsprecher an PA7/D11 -> TIM3_CH2
#define KANAL 2        // CH2
volatile unsigned long weckzeit; // wann der Wecker "klingeln" soll
volatile unsigned long myTicks=0; // 0,1s Ticks
enum zustandstyp {CHILLEN,WECKER,PIEPEN};
volatile zustandstyp zustand=CHILLEN;

void stelleWecker(int n){ // n ist Zeit in 0,1s
  weckzeit = myTicks+n;
}
bool abgelaufenWecker(){
  return myTicks>=weckzeit;
}

void isr_userB(){    // Wecker stellen
  stelleWecker(100); // auf 10 Sekunden stellen
  zustand=WECKER;
}

void isr_Tick(){ // Tickzeit erhöhen
  myTicks++;
}

void setup() {
  pinMode(USER_BTN, INPUT);
  attachInterrupt (digitalPinToInterrupt (USER_BTN), isr_userB, FALLING);
  myPieper.setOverflow(2000, HERTZ_FORMAT); // Frequenz einstellen
  myPieper.setCaptureCompare(KANAL,50,PERCENT_COMPARE_FORMAT); // Impulsbreite 50%
  myPieper.setMode(KANAL, TIMER_OUTPUT_COMPARE_PWM1, PIEZO_PIN); // Den PWM-Ausgang einstellen
  myTicker.setOverflow(100000,MICROSEC_FORMAT);  // Ticks auf 0,1 Sekunden stellen
  myTicker.attachInterrupt(isr_Tick);            // ISR einstellen
  myTicker.resume();                             // Ticker starten
}
void loop() {
  switch(zustand){
    case CHILLEN:
      break;
    case WECKER: // Wecker ist gestellt, warten auf Klingeln
      if(abgelaufenWecker()){
        myPieper.resume(); // Pieper an
        stelleWecker(3); // 0,3 Sekunden
        zustand=PIEPEN;
      }
      break;
    case PIEPEN: // Piepen auch mit Wecker gelöst
      if(abgelaufenWecker()){
        myPieper.pause();
        zustand=CHILLEN;
      }
      break;  
  }
}

☕️ Kaffeeautomat (HP12-2)

• Nach dem Einschalten wird das Wasser für 15 Sekunden (Wecker) aufgeheizt (HEIZUNG=1) dabei blinkt die LED mit 4 Hz.
• Nach dem Heizen ist das Wasser heiss, die LED leuchtet dauernd und die Heizung ist aus.
• Nun kann mit KL_TA eine kleine Tasse oder mit GR_TA eine große Tasse angefordert werden.
  • Bei einer kleinen Tasse läuft die Pumpe 5 Sekunden.
  • Bei einer großen Tasse 10 Sekunden.
• Während die Pumpe läuft blinkt die LED mit 1 Hz.
• Nach Ausgabe einer Tasse wird das Wasser wieder aufgeheizt.

// Codevorgabe
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl

# define EIN_AUS PC13  // Entpreller lowaktiver UserButton auf dem Board
# define KL_TA PA1 
# define GR_TA PA6
# define HEIZUNG PC0
# define PUMPE PC1
# define LED PC2
enum zustandstyp {AUS,HEIZEN_ENTRY,HEIZEN,HEISS,PUMPEN};
volatile zustandstyp zustand=AUS;
volatile uint32_t weckzeit; // Zeit zum Wecken

void ausschaltenAlles(){ // Alles ist aus
}
void stelleWecker(int n){ // Wecker stellen, n sind Sekunden
}
bool abgelaufenWecker(){  // True, wenn Wecker abgelaufen ist
}
void isr_einAus(){ // Externer Interrupt 
}
void isr_blinken(){ // Invertiert die LED
}
void blinkenLED(int n){  // Einstellen der Blinkzeit
}
void einschaltenLED(){  // LED leuchtet dauernd
}
void setup() {
  pinMode(EIN_AUS, INPUT);
  ..
}
void loop() {
  switch (zustand){
  }
}

☕️ 1. Vervollständigen Sie das Zustandsdiagramm 10P

Mögliche Lösung Kaffeeautomat Zustandsdiagramm

☕️ 2. Welche Taster müssen entprellt sein? 3P

Begründen Sie welche Taster entprellt sein müssen.

☕️ 3. Initialisierung der Pins 4P

Erstellen Sie die Codesequenz um die Pins zu initialisieren.

pinMode(EIN_AUS, INPUT);
pinMode(KL_TA, INPUT_PULLDOWN);
pinMode(GR_TA, INPUT_PULLDOWN);
pinMode(HEIZUNG, OUTPUT);
pinMode(PUMPE, OUTPUT);
pinMode(LED, OUTPUT);

☕️ 4. isr_einAus() 5P

Erstellen Sie die Codesequenz zur Initialisierung der ISR und den Code für isr_einAus().

attachInterrupt (digitalPinToInterrupt (EIN_AUS), isr_einAus, FALLING);

void isr_einAus(){  // Externer Interrupt 
  if(zustand==AUS){
    zustand=HEIZEN_ENTRY;
  }
  else{
    zustand=AUS;
    auschaltenAlles();
  }
}

☕️ 5. ausschaltenAlles() 3P

Erstellen Sie den Code für ausschaltenAlles(). Alle Ausgänge werden auf 0 geschaltet, es blinkt auch nichts mehr.

void ausschaltenAlles(){ // Alles ist aus
  mytimer.pause(); // keine ISRs mehr ausloesen
  digitalWrite(LED,LOW);
  digitalWrite(HEIZUNG,LOW);
  digitalWrite(PUMPE,LOW);
}

☕️ 6. Weckerfunktionen 4P

Erstellen Sie den Code für stelleWecker(int n) und abgelaufenWecker():bool.
Für die 15,10,5 Sekunden wird ein Wecker mit stelleWecker(int n) gestellt. Der Parameter n gibt die Weckzeit in Sekunden vor. Mit abgelaufenWecker():bool wird der Wecker abgefragt -> true wenn Wecker abgelaufen ist. Der Wecker verwendet die millis()-Funktion

void stelleWecker(int n){ // Wecker stellen n sind Sekunden
  weckzeit = millis()+n*1000;
}
bool abgelaufenWecker(){ // True, wenn Wecker abgelaufen ist
  return millis()>=weckzeit;
}

☕️ 7. LED blinken und dauernd leuchten lassen 10P

Die LED soll blinken, dauerleuchten und aus sein. Das LED-Blinken wird mit einer isr_blinken() und Timer3 erzeugt.
Für das Einstellen des LED-Blinkens wird ein Unterprogramm blinkenLED(int n) verwendet. Der Parameter n ist die Blinkfrequenz.
Erstellen Sie den Code für die Initialisierung von isr_blinken(), isr_blinken(), blinkenLED(int n) und einschaltenLED().

mytimer.attachInterrupt(isr_blinken); // Timer ISR einstellen

void isr_blinken(){  // Invertiert die LED
  digitalWrite(LED,!digitalRead(LED));
}
void blinkenLED(int n){  // Einstellen der Blinkzeit
  mytimer.setOverflow(n*2,HERTZ_FORMAT);
  mytimer.resume();
}
void einschaltenLED(){  // LED leuchtet dauernd
  mytimer.pause();
  digitalWrite(LED,HIGH);
}

☕️ 8. loop() 15P

Erstellen Sie den Code für die loop().

switch (zustand){
    case HEIZEN_ENTRY:
      digitalWrite(HEIZUNG,HIGH);
      stelleWecker(15);
      blinkenLED(4);
      zustand=HEIZEN;
      break;
    case HEIZEN:
      if(abgelaufenWecker()){
        zustand=HEISS;
        digitalWrite(HEIZUNG,LOW);
        einschaltenLED();
      }
      break;
    case HEISS:
      if(digitalRead(KL_TA)){
        zustand=PUMPEN;
        stelleWecker(5);
        blinkenLED(1);
        digitalWrite(PUMPE,HIGH);
      }
      else if (digitalRead(GR_TA)){
        zustand=PUMPEN;
        stelleWecker(10);
        blinkenLED(1);
        digitalWrite(PUMPE,HIGH);
      }
      break;
    case PUMPEN:
      if(abgelaufenWecker()){
        zustand=HEIZEN_ENTRY;
        digitalWrite(PUMPE,LOW);
      }
      break;  
  }

#include <Arduino.h>
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl

# define EIN_AUS PC13  // Entpreller lowaktiver UserButton auf dem Board
# define KL_TA PA1 
# define GR_TA PA6
# define HEIZUNG PC0
# define PUMPE PC1
# define LED PC1
enum zustandstyp {AUS,HEIZEN_ENTRY,HEIZEN,HEISS,PUMPEN};
zustandstyp zustand=AUS;
uint32_t weckzeit; // Zeit zum Wecken

void ausschaltenAlles(){ // Alles ist aus
  mytimer.pause(); // keine ISRs mehr ausloesen
  digitalWrite(LED,LOW);
  digitalWrite(HEIZUNG,LOW);
  digitalWrite(PUMPE,LOW);
}
void stelleWecker(int n){ // Wecker stellen n sind Sekunden
  weckzeit = millis()+n*1000;
}
bool abgelaufenWecker(){ // True, wenn Wecker abgelaufen ist
  return millis()>=weckzeit;
}
void isr_einAus(){  // Externer Interrupt 
  if(zustand==AUS){
    zustand=HEIZEN_ENTRY;
  }
  else{
    zustand=AUS;
    ausschaltenAlles();
  }
}
void isr_blinken(){  // Invertiert die LED
  digitalWrite(LED,!digitalRead(LED));
}

void blinkenLED(int n){  // Einstellen der Blinkzeit
  mytimer.setOverflow(n*2,HERTZ_FORMAT);
  mytimer.resume();
}
void einschaltenLED(){  // LED leuchtet dauernd
  mytimer.pause();
  digitalWrite(LED,HIGH);
}
void setup() {
  pinMode(EIN_AUS, INPUT);
  pinMode(KL_TA, INPUT_PULLDOWN);
  pinMode(GR_TA, INPUT_PULLDOWN);
  pinMode(HEIZUNG, OUTPUT);
  pinMode(PUMPE, OUTPUT);
  pinMode(LED, OUTPUT);
  attachInterrupt (digitalPinToInterrupt (EIN_AUS), isr_einAus, FALLING);
  mytimer.attachInterrupt(isr_blinken); // Timer ISR einstellen
}
void loop() {
  switch (zustand){
    case HEIZEN_ENTRY:
      digitalWrite(HEIZUNG,HIGH);
      stelleWecker(15);
      blinkenLED(4);
      zustand=HEIZEN;
      break;
    case HEIZEN:
      if(abgelaufenWecker()){
        zustand=HEISS;
        digitalWrite(HEIZUNG,LOW);
        einschaltenLED();
      }
      break;
    case HEISS:
      if(digitalRead(KL_TA)){
        zustand=PUMPEN;
        stelleWecker(5);
        blinkenLED(1);
        digitalWrite(PUMPE,HIGH);
      }
      else if (digitalRead(GR_TA)){
        zustand=PUMPEN;
        stelleWecker(10);
        blinkenLED(1);
        digitalWrite(PUMPE,HIGH);
      }
      break;
    case PUMPEN:
      if(abgelaufenWecker()){
        zustand=HEIZEN_ENTRY;
        digitalWrite(PUMPE,LOW);
      }
      break;  
  }
}

☕️ 9. Wasser wieder erwärmen 10P

Nach 20 Sekunden im Zustand HEISS wird das Wasser kalt und muss wieder erhitzt werden. Nach 2 mal Nachheizen ohne Benutzung schaltet sich der Automat aus. Erweitern Sie ihr Zustandsdiagramm und Programm.

Mögliche Lösung Kaffeeautomat Zustandsdiagramm

#include <Arduino.h>
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl

# define EIN_AUS PC13  // Entpreller lowaktiver UserButton auf dem Board
# define KL_TA PA1 
# define GR_TA PA6
# define HEIZUNG PC0
# define PUMPE PC1
# define LED PC2
enum zustandstyp {AUS,HEIZEN_ENTRY,HEIZEN,HEISS,PUMPEN};
volatile zustandstyp zustand=AUS;
uint32_t weckzeit; // Zeit zum Wecken
int autoAus=0;

void auschaltenAlles(){
  mytimer.pause(); // keine ISRs mehr ausloesen
  digitalWrite(LED,LOW);
  digitalWrite(HEIZUNG,LOW);
  digitalWrite(PUMPE,LOW);
}
void stelleWecker(int n){
  weckzeit = millis()+n*1000;
}
bool abgelaufenWecker(){
  return millis()>=weckzeit;
}
void isr_einAus(){
  if(zustand==AUS){
    zustand=HEIZEN_ENTRY;
  }
  else{
    zustand=AUS;
    auschaltenAlles();
    autoAus=0;
  }
}
void isr_blinken(){
  digitalWrite(LED,!digitalRead(LED));
}

void blinkenLED(int n){  // Werte verändern und testen
  mytimer.setOverflow(n*2,HERTZ_FORMAT);
  mytimer.resume();
}
void einschaltenLED(){
  mytimer.pause();
  digitalWrite(LED,HIGH);
}
void setup() {
  pinMode(EIN_AUS, INPUT);
  pinMode(KL_TA, INPUT_PULLDOWN);
  pinMode(GR_TA, INPUT_PULLDOWN);
  pinMode(HEIZUNG, OUTPUT);
  pinMode(PUMPE, OUTPUT);
  pinMode(LED, OUTPUT);
  attachInterrupt (digitalPinToInterrupt (EIN_AUS), isr_einAus, FALLING);
  mytimer.attachInterrupt(isr_blinken); // Timer ISR einstellen
}
void loop() {
  switch (zustand){
    case HEIZEN_ENTRY:
      digitalWrite(HEIZUNG,HIGH);
      stelleWecker(15);
      blinkenLED(4);
      zustand=HEIZEN;
      break;
    case HEIZEN:
      if(autoAus>2){
        zustand=AUS;
        auschaltenAlles();
        autoAus=0;
      }
      if(abgelaufenWecker()){
        zustand=HEISS;
        digitalWrite(HEIZUNG,LOW);
        einschaltenLED();
        stelleWecker(20);
      }
      break;
    case HEISS:
      if(digitalRead(KL_TA)){
        zustand=PUMPEN;
        stelleWecker(5);
        blinkenLED(1);
        digitalWrite(PUMPE,HIGH);
      }
      else if(digitalRead(GR_TA)){
        zustand=PUMPEN;
        stelleWecker(10);
        blinkenLED(1);
        digitalWrite(PUMPE,HIGH);
      }
      else if(abgelaufenWecker()){
        zustand=HEIZEN_ENTRY;
        autoAus++;
      }
      break;
    case PUMPEN:
      if(abgelaufenWecker()){
        zustand=HEIZEN_ENTRY;
        digitalWrite(PUMPE,LOW);
        autoAus=0;
      }
      break;  
  }
}

🪥 🚧 Elektrische Zahnbürste (HP19-2)

// Vorgabe Code
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl

# define EIN_AUS PC13  // Entpreller lowaktiver UserButton auf dem Board
# define MODUS PA1     // Taster highaktiv prellend
# define MOTOR PC6     // PWM mit Timer 3 Kanal 1 möglich

enum zustandstyp {AUS,AN_ENTRY,AN,STOPP,ZEIT_UM,AUFHELLEN,SENSITIV};
volatile zustandstyp zustand=AUS;
volatile uint32_t weckzeit; // Zeit zum Wecken
int quadrant = 0;  // Mundquadrant, der gerade geputzt werden soll

void anschaltenMotor(){
}
void ausschaltenMotor(){
}
void ausschaltenLED(){ // schaltet nur die LED aus
}
void stelleWecker(int n){ // n in Zehntelsekunden
}
bool abgelaufenWecker(){  // true, wenn Weckzeit vorbei
}
void isr_einAus(){ // wird mit EIN_AUS aufgerufen
}
void ausgebenLED(int n){  // gibt Leuchtband aus
}
void setup() {
}
void loop() {
}

🪥 1. Vervollständigen Sie das Zustandsdiagramm

Mögliche Lösung Zustandsdiagramm

🪥 2. Initialisierung der Pins

Erstellen Sie die Codesequenz um die Pins zu initialisieren.

pinMode(PC0, OUTPUT);   // LEDA Ausgang
pinMode(PC1, OUTPUT);   // LEDB Ausgang
pinMode(PC2, OUTPUT);   // LEDC Ausgang
pinMode(PC3, OUTPUT);   // LEDD Ausgang
pinMode(MOTOR, OUTPUT); // Motor Ausgang
pinMode(EIN_AUS, INPUT);
pinMode(MODUS, INPUT_PULLDOWN);

🪥 3. isr_einAus()

Erstellen Sie die Codesequenz zur Initialisierung der ISR und den Code für isr_einAus().

attachInterrupt (digitalPinToInterrupt (EIN_AUS), isr_einAus, FALLING);

void isr_einAus(){ // wird mit EIN_AUS aufgerufen
  if(zustand==AUS){
    zustand=AN_ENTRY;
  }
  else{
    zustand=AUS;
    ausschaltenLED();
    ausschaltenMotor();
    quadrant=0;
  }
}

🪥 4. Motor und LEDs schalten

Erstellen Sie den Programmcode für anschaltenMotor(), ausschaltenMotor() und ausschaltenLED().

void anschaltenMotor(){
  digitalWrite(MOTOR,HIGH);
}
void ausschaltenMotor(){
  digitalWrite(MOTOR,LOW);
}
void ausschaltenLED(){// schaltet nur die LED aus
  GPIOC->ODR &= ~0b1111;
}

🪥 5. Weckerfunktion

Erstellen Sie den Code für stelleWecker(int n) und abgelaufenWecker():bool.
Mit stelleWecker(int n) wird die Weckzeit in Zehntelsekunden gestellt. Mit abgelaufenWecker():bool wird der Wecker abgefragt -> true wenn Wecker abgelaufen ist. Der Wecker verwendet die millis()-Funktion

void stelleWecker(int n){ // n in Zehntelsekunden
  weckzeit = millis()+n*100;
}
bool abgelaufenWecker(){  // true, wenn Weckzeit vorbei
  return millis()>=weckzeit;
}

🪥 6. ausgebenLED(int n)

Erstellen Sie den Code für ausgebenLED(int n), das ein Leuchtband mit LEDA..LEDD ausgibt. Für n=0 leuchtet LEDA, für n>2 leuchten alle 4 LED.

void ausgebenLED(int n){  // gibt Leuchtband aus
  switch (n){
  case 0:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b1; 
    break;
  case 1:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b11;
    break;
  case 2:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b111;  
    break;
  default: // für quadrant > 2
    GPIOC->ODR = GPIOC->ODR | 0b1111;  
    break;
  }
}

🪥 7. loop()

Erstellen Sie den Code für die loop().

void loop() {
  switch (zustand){
    case AN_ENTRY:
      stelleWecker(55); // 295, mit 55 testen
      anschaltenMotor();
      ausgebenLED(quadrant);
      zustand=AN;
      break;
    case AN:
      if(abgelaufenWecker()){
        zustand=STOPP;
        quadrant++;
        stelleWecker(5);
        ausschaltenMotor();
      }
      break;
    case STOPP:
      if(abgelaufenWecker()){
        if(quadrant%4==0) zustand=ZEIT_UM;
        else zustand=AN_ENTRY;
      }
      break;
    case ZEIT_UM:
      anschaltenMotor();
      delay(200);
      ausschaltenMotor();
      delay(200);
      anschaltenMotor();
      delay(200);
      ausschaltenMotor();
      delay(200);
      zustand=AN_ENTRY;
      break;
  }
}

#include <Arduino.h>
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl

# define EIN_AUS PC13  // Entpreller lowaktiver UserButton auf dem Board
# define MODUS PA1     // Taster highaktiv prellend
# define MOTOR PC6     // PWM mit Timer 3 Kanal 1 möglich

enum zustandstyp {AUS,AN_ENTRY,AN,STOPP,ZEIT_UM,AUFHELLEN,SENSITIV};
volatile zustandstyp zustand=AUS;
uint32_t weckzeit; // Zeit zum Wecken
int quadrant = 0;  // Mundquadrant, der gerade geputzt werden soll

void anschaltenMotor(){
  digitalWrite(MOTOR,HIGH);
}
void ausschaltenMotor(){
  digitalWrite(MOTOR,LOW);
}
void ausschaltenLED(){// schaltet nur die LED aus
  GPIOC->ODR &= ~0b1111;
}
void stelleWecker(int n){ // n in Zehntelsekunden
  weckzeit = millis()+n*100;
}
bool abgelaufenWecker(){  // true, wenn Weckzeit vorbei
  return millis()>=weckzeit;
}
void isr_einAus(){ // wird mit EIN_AUS aufgerufen
  if(zustand==AUS){
    zustand=AN_ENTRY;
  }
  else{
    zustand=AUS;
    ausschaltenLED();
    ausschaltenMotor();
    quadrant=0;
  }
}
void ausgebenLED(int n){  // gibt Leuchtband aus
  switch (n){
  case 0:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b1; 
    break;
  case 1:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b11;
    break;
  case 2:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b111;  
    break;
  default: // für quadrant > 2
    GPIOC->ODR = GPIOC->ODR | 0b1111;  
    break;
  }
}
void setup() {
  pinMode(PC0, OUTPUT);   // LEDA Ausgang
  pinMode(PC1, OUTPUT);   // LEDB Ausgang
  pinMode(PC2, OUTPUT);   // LEDC Ausgang
  pinMode(PC3, OUTPUT);   // LEDD Ausgang
  pinMode(MOTOR, OUTPUT); // Motor Ausgang
  pinMode(EIN_AUS, INPUT);
  pinMode(MODUS, INPUT_PULLDOWN);
  attachInterrupt (digitalPinToInterrupt (EIN_AUS), isr_einAus, FALLING);
}
void loop() {
  switch (zustand){
    case AN_ENTRY:
      stelleWecker(55); // 295, mit 55 testen
      anschaltenMotor();
      ausgebenLED(quadrant);
      zustand=AN;
      break;
    case AN:
      if(abgelaufenWecker()){
        zustand=STOPP;
        quadrant++;
        stelleWecker(5);
        ausschaltenMotor();
      }
      break;
    case STOPP:
      if(abgelaufenWecker()){
        if(quadrant%4==0) zustand=ZEIT_UM;
        else zustand=AN_ENTRY;
      }
      break;
    case ZEIT_UM:
      anschaltenMotor();
      delay(200);
      ausschaltenMotor();
      delay(200);
      anschaltenMotor();
      delay(200);
      ausschaltenMotor();
      delay(200);
      zustand=AN_ENTRY;
      break;
  }
}

🪥 8. Weitere Betriebsmodi: Aufhellen und Sensitiv

Mit dem Taster MODUS (PA1, HighAktiv, prellt) kann aus dem Zustand AN in zwei weitere Modi (AUFHELLEN und SENSITIV) geschaltet werden.
AN -[MODUS]-> AUFHELLEN -[MODUS]-> SENSITIV. Diese Modi kennen keine Quadranten und können nur durch Ausschalten beendet werden.

1. AUFHELLEN: Aufruf der Funktionen aufhellen() (Der Bürstenmotor wird nun mit 1 Hz Rechtecksignal angesteuert) und ausschaltenLED()
2. SENSITIV: Aufruf der Funktion sensitiv() (Der Bürstenmotor wird nun mit 50 Hz Rechtecksignal angesteuert).

🪥 8.1 MODUS Taste entprellen

Um die MODUS-Taste zu entprellen erstellen Sie eine Funktion boolean checkModus() die beim Drücken des high-aktiven prellenden (10 ms) Tasters an PA1 ein true zurückgibt (Flankendedektion, Entprellen). Diese Funktion wird im Zustandsdiagramm und Programm verwendet, Codevorgabe:

boolean checkModus(){ // prellfreies Ueberpruefen Tastendruck
  static boolean oldT=false; // static bewirkt persistente lokale Variable
  ...
  return false;
}

boolean checkModus(){ // prellfreies Ueberpruefen Tastendruck
  static boolean oldT=false; // static bewirkt persistente lokale Variable
  if (oldT!=digitalRead(MODUS)){
    delay(20); // Prellen abwarten
    if (oldT!=digitalRead(MODUS)){ // immer noch?
      oldT=!oldT;  // neuer Wert ist anders
      return oldT; // steigende Flanke wenn neuer Wert = true
    }
  }
  return false;
}

🪥 8.2 Zustandsdiagramm erweitern

Erweitern Sie das Zustandsdiagramm.

Mögliche Lösung Zustandsdiagramm

🪥 8.3 Motoransteuerung mit Timer-PWM (meine bevorzugte Lösung)

Die Motoransteuerung geschieht über [PWM-Prozent] mit Timer3-PWM Kanal 1. Ergänzen Sie den Code für aufhellen(), sensitiv() und loop(). Codeschnipsel:

static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl

void anschaltenMotor(){
  mytimer.setOverflow(100,HERTZ_FORMAT);  // Frequenz einstellen
  mytimer.setCaptureCompare(1,100,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen
}
void ausschaltenMotor(){
   mytimer.setOverflow(100,HERTZ_FORMAT);  // Frequenz einstellen
   mytimer.setCaptureCompare(1,0,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen
}
void aufhellen(){ // Motor läuft mit 1 Hz
  ...
}
void sensitiv(){ // Motor läuft mit 50 Hz
 ...
}
void setup() {
  ...
 mytimer.setPWM(1, PC6, 100, 0); // Initialisierung mit 100 Hz
}
void loop() {
  switch (zustand){
  }  
}

#include <Arduino.h>
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl

# define EIN_AUS PC13  // Entpreller lowaktiver UserButton auf dem Board
# define MODUS PA1 
# define MOTOR PC6  // Timer 3 Kanal 1

enum zustandstyp {AUS,AN_ENTRY,AN,STOPP,ZEIT_UM,AUFHELLEN,SENSITIV};
zustandstyp zustand=AUS;
uint32_t weckzeit; // Zeit zum Wecken
int quadrant = 0;

void anschaltenMotor(){
   mytimer.setOverflow(100,HERTZ_FORMAT);  // Frequenz einstellen
   mytimer.setCaptureCompare(1,100,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen
}
void ausschaltenMotor(){
   mytimer.setOverflow(100,HERTZ_FORMAT);  // Frequenz einstellen
   mytimer.setCaptureCompare(1,0,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen
}
void ausschaltenLED(){
  GPIOC->ODR = 0;
}
void stelleWecker(int n){ // Zehntelsekunden
  weckzeit = millis()+n*100;
}
bool abgelaufenWecker(){
  return millis()>=weckzeit;
}
void isr_einAus(){
  if(zustand==AUS){
    zustand=AN_ENTRY;
  }
  else{
    zustand=AUS;
    ausschaltenLED();
    ausschaltenMotor();
    quadrant=0;
  }
}
void ausgebenLED(int n){
  switch (n){
  case 0:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b1; 
    break;
  case 1:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b11;
    break;
  case 2:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b111;  
    break;
  default:
    GPIOC->ODR = GPIOC->ODR | 0b1111;  
    break;
  }
}

void aufhellen(){
  mytimer.setOverflow(1,HERTZ_FORMAT);  // Frequenz einstellen
  mytimer.setCaptureCompare(1,50,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen
}
void sensitiv(){
  mytimer.setOverflow(10,HERTZ_FORMAT);  // Frequenz einstellen
  mytimer.setCaptureCompare(1,50,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen
}
boolean checkModus(){ // prellfreies Ueberpruefen Tastendruck
  static boolean oldT=false;
  if (oldT!=digitalRead(MODUS)){
    delay(20); // Prellen abwarten
    if (oldT!=digitalRead(MODUS)){ // immer noch?
      oldT=!oldT;  // neuer Wert ist anders
      return oldT; // steigende Flanke wenn neuer Wert = true
    }
  }
  return false;
}
void setup() {
  pinMode(PC0, OUTPUT);           // ohne diese Zeile klappts nicht mit MODER
  GPIOC->MODER = 0x5555;          // PC0..PC7 als Ausgang
  pinMode(EIN_AUS, INPUT);
  pinMode(MODUS, INPUT_PULLDOWN);
  pinMode(MOTOR, OUTPUT);
  attachInterrupt (digitalPinToInterrupt (EIN_AUS), isr_einAus, FALLING);
  mytimer.setPWM(1, PC6, 100, 0); // Initialisierung mit 100 Hz
}
void loop() {
  switch (zustand){
    case AN_ENTRY:
      stelleWecker(55); // 295, mit 55 testen
      anschaltenMotor();
      ausgebenLED(quadrant);
      zustand=AN;
      break;
    case AN:
      if(abgelaufenWecker()){
        zustand=STOPP;
        quadrant++;
        stelleWecker(5);
        ausschaltenMotor();
      }
      if(checkModus()){
        ausschaltenLED();
        aufhellen();
        zustand=AUFHELLEN;
      }
      break;
    case STOPP:
      if(abgelaufenWecker()){
        if(quadrant%4==0) zustand=ZEIT_UM;
        else zustand=AN_ENTRY;
      }
      break;
    case ZEIT_UM:
      anschaltenMotor();
      delay(200);
      ausschaltenMotor();
      delay(200);
      anschaltenMotor();
      delay(200);
      ausschaltenMotor();
      delay(200);
      zustand=AN_ENTRY;
      break;
    case AUFHELLEN:
      if (checkModus()){
        sensitiv();
        zustand=SENSITIV;
      }
      break;
    case SENSITIV:

      break;
  }
}

🪥 8.4 Motoransteuerung mit Timer und ABI-Bezug (kein PWM mit Timer-Kanälen)

Leider ist die Verwendung von echtem PWM mit Timerkanälen (setCaptureCompare usw.) derzeit nicht bei ABI-Aufgaben vorgesehen. Daher sollte diese Aufgabe im ABI mit Timer-ISRs gelöst werden. Somit müsste aufhellen() und sensitiv() mit Timer-ISR so erzeugt werden:

• Eine Timer ISR isr_Motor() invertiert den Motorausgang. Verwenden Sie z.B. Timer3.
• In den Operationen sensitiv() und aufhellen() wird u.a. die Interruptzeit passend eingestellt..

Erstellen Sie den modifizierten Code für die Initialisierung der Timer ISR, der Operationen isr_Motor(), ausschaltenMotor(), aufhellen() und sensitiv().

#include <Arduino.h>
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl

# define EIN_AUS PC13  // Entpreller lowaktiver UserButton auf dem Board
# define MODUS PA1     // Taster highaktiv prellend
# define MOTOR PC6     // PWM mit Timer 3 Kanal 1 möglich

enum zustandstyp {AUS,AN_ENTRY,AN,STOPP,ZEIT_UM,AUFHELLEN,SENSITIV};
zustandstyp zustand=AUS;
uint32_t weckzeit; // Zeit zum Wecken
int quadrant = 0;  // Mundquadrant, der gerade geputzt werden soll

void anschaltenMotor(){
  digitalWrite(MOTOR,HIGH);
}
void ausschaltenMotor(){
  mytimer.pause();
  digitalWrite(MOTOR,LOW);
}
void ausschaltenLED(){// schaltet nur die LED aus
  GPIOC->ODR &= ~0b1111;
}
void stelleWecker(int n){ // n in Zehntelsekunden
  weckzeit = millis()+n*100;
}
bool abgelaufenWecker(){  // true, wenn Weckzeit vorbei
  return millis()>=weckzeit;
}
void isr_einAus(){ // wird mit EIN_AUS aufgerufen
  if(zustand==AUS){
    zustand=AN_ENTRY;
  }
  else{
    zustand=AUS;
    ausschaltenLED();
    ausschaltenMotor();
    quadrant=0;
  }
}
void ausgebenLED(int n){  // gibt Leuchtband aus
  switch (n){
  case 0:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b1; 
    break;
  case 1:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b11;
    break;
  case 2:
    GPIOC->ODR = (GPIOC->ODR & ~0b1111) | 0b111;  
    break;
  default: // für quadrant > 2
    GPIOC->ODR = GPIOC->ODR | 0b1111;  
    break;
  }
}
void isr_Motor(){ // MotorAusgang invertieren
  digitalWrite(MOTOR,!digitalRead(MOTOR));
}
void aufhellen(){ // Motor läuft mit 1 Hz
  mytimer.setOverflow(2,HERTZ_FORMAT);
  mytimer.resume();
}
void sensitiv(){ // Motor läuft mit 50 Hz
  mytimer.setOverflow(100,HERTZ_FORMAT);
  mytimer.resume();
}
boolean checkModus(){ // prellfreies Ueberpruefen Tastendruck
  static boolean oldT=false;
  if (oldT!=digitalRead(MODUS)){
    delay(20); // Prellen abwarten
    if (oldT!=digitalRead(MODUS)){ // immer noch?
      oldT=!oldT;  // neuer Wert ist anders
      return oldT; // steigende Flanke wenn neuer Wert = true
    }
  }
  return false;
}
void setup() {
  pinMode(PC0, OUTPUT);   // LEDA Ausgang
  pinMode(PC1, OUTPUT);   // LEDB Ausgang
  pinMode(PC2, OUTPUT);   // LEDC Ausgang
  pinMode(PC3, OUTPUT);   // LEDD Ausgang
  pinMode(MOTOR, OUTPUT); // Motor Ausgang
  pinMode(EIN_AUS, INPUT);
  pinMode(MODUS, INPUT_PULLDOWN);
  attachInterrupt (digitalPinToInterrupt (EIN_AUS), isr_einAus, FALLING);
  mytimer.attachInterrupt(isr_Motor); // Timer ISR einstellen
}
void loop() {
  switch (zustand){
    case AN_ENTRY:
      stelleWecker(55); // 295, mit 55 testen
      anschaltenMotor();
      ausgebenLED(quadrant);
      zustand=AN;
      break;
    case AN:
      if(abgelaufenWecker()){
        zustand=STOPP;
        quadrant++;
        stelleWecker(5);
        ausschaltenMotor();
      }
      if(checkModus()){
        ausschaltenLED();
        aufhellen();
        zustand=AUFHELLEN;
      }
      break;
    case STOPP:
      if(abgelaufenWecker()){
        if(quadrant%4==0) zustand=ZEIT_UM;
        else zustand=AN_ENTRY;
      }
      break;
    case ZEIT_UM:
      anschaltenMotor();
      delay(200);
      ausschaltenMotor();
      delay(200);
      anschaltenMotor();
      delay(200);
      ausschaltenMotor();
      delay(200);
      zustand=AN_ENTRY;
      break;
    case AUFHELLEN:
      if (checkModus()){
        sensitiv();
        zustand=SENSITIV;
      }
      break;
    case SENSITIV:
      break;
  }
}

📦 Paketerfassung mit Sortierstraße (HP09)

Aufgabe wurde im Fachnetz-BS von Kollege Carsten N. gepostet, ich habe versucht sie für meinen Unterricht mit Arduino an zu passen.
Auf einem Förderband werden zwei unterschiedlich lange Paketsorten (P_lang, P_kurz) mit zwei Lichtschranken erfasst und anschließend in Transportbehälter geschoben (Unterprogramme pKurz(), pLang()). Eine zweistellige gemultiplexte 7-Segment-LED-Anzeige zeigt die Anzahl der verarbeiteten Pakete an.

Es gelten folgende Randbedingungen:

• Mit 2 Lichtschranken-Sensoren S1 und S2 werden die Pakete erfasst. Das Signal Sx ist ‚0‘,
  wenn ein Paket die Lichtschranke unterbricht, sonst ‚1‘.
• Die Paketsorte P_lang kann gleichzeitig von beiden Sensoren erfasst werden.
• Die Paketsorte P_kurz ist zu kurz, um gleichzeitig von beiden Sensoren erfasst zu werden.
• Die Pakete liegen mit einem Mindestabstand auseinander, so dass das nächste Paket den Sensor
  S1 erst erreichen kann, wenn das vorherige Paket bereits verpackt wurde.
• Die Zeit zwischen dem Verlassen von S2 und dem Verpackungsauslösen pKurz() für ein P_kurz-
  Paket muss 3 Sekunden betragen, zwischen S2 und pLang() 8 Sekunden.
• Zum Testen werden Tasten PA1 und PA6 verwendet und mit buttonCheck() entprellt. Das Unterbrechen einer Lichtschranke z.B. S1 wird durch Tastendruck PA1 getestet und als Bedingung S1_FALL ab prüfbar:
  • Taste PA1 drücken -> buttonCheck() -> S1_FALL liefert true.
  • Taste PA1 loslassen -> buttonCheck() -> S1_RISE liefert true.
• Für Sekunden Zeitintervalle wird ein HardwareTimer myWecker verwendet:
  • stelleWecker(int n) stellt den Timer auf n Sekunden ein und startet ihn.
  • isr_Wecker() wird nach Ablauf des Timers aufgerufen und stoppt ihn.

Vorgegebener Quelltext:

static HardwareTimer myWecker = HardwareTimer(TIM2);  // Timerinstanz für Zeitintervall
static HardwareTimer anzeigeTimer = HardwareTimer(TIM4);  // Timerinstanz für gemultiplexte Anzeige

#define S1 PA1 // PA1 Prellend High aktiv
#define S2 PA6 // PA6 Prellend High aktiv
#define S1_FALL buttonEnter&(1<<1) // Taste drücken für Lichtschranke unterbrochen
#define S1_RISE buttonExit&(1<<1)  // Taste loslassen für Lichtschranke nicht unterbrochen
#define S2_FALL buttonEnter&(1<<6) // Taste drücken für Lichtschranke unterbrochen
#define S2_RISE buttonExit&(1<<6)  // Taste loslassen für Lichtschranke nicht unterbrochen

enum zustandstyp {RUHE,S1_UNTERBROCHEN,P_LANG_ERKANNT,P_KURZ_ERKANNT,P_LANG_AUSWERFEN,P_KURZ_AUSWERFEN};
volatile zustandstyp zustand=RUHE;

int paketAnzahl=0; // Zähler für die ausgelieferten Pakete
int bcd_7seg[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; // Umrechnung

#define BUTTONREADER GPIOA->IDR & 0b10001000010 // nur die relevanten Tastenbits
int buttonOld = 0;              // alter Tasten-Zustand 
int buttonEnter,buttonExit;     // gedrueckte und losgelassene Tasten 

void buttonCheck(){             // Tastaturabfrage mit Flankendedektion  
  int buttonTest,tmp; 
  buttonEnter = 0, buttonExit = 0; 
  buttonTest = BUTTONREADER;       // Einlesen
  if (buttonOld != buttonTest){    // hat sich was getan 
    delay(5);                      // 5ms Prellen abwarten 
    tmp = BUTTONREADER;            // noch mal Einlesen
    if (tmp == buttonTest){        // ist es stabil? 
      buttonEnter = (~buttonOld) & buttonTest; // steigende Flanke !alt und neu 
      buttonExit = buttonOld & (~buttonTest);  // fallende Flanke alt und !neu 
      buttonOld = buttonTest; 
    } 
  } 
}
void stelleWecker(int n){ // Sekundenwecker stellen
 2️⃣ ... 😎
}
void isr_Wecker(){   // Wecker ist abgelaufen
  myWecker.pause();  // Timer stoppen
  switch(zustand){
   3️⃣ ...
  }
}
void isr_Anzeige(){ // gemultipexte 7 Segmentanzeige
  static bool einer = true;
  4️⃣ ...
  einer = !einer;
}
void pLang(){Serial.println("pLang()");}
void pKurz(){Serial.println("pKurz()");}

void setup() {
  pinMode(S1, INPUT_PULLDOWN);
  pinMode(S2, INPUT_PULLDOWN);
  pinMode(PC11,OUTPUT);   // Einer
  pinMode(PC12,OUTPUT);   // Zehner
  GPIOC->MODER |= 0x5555; // PC0..PC7 als Ausgang
  anzeigeTimer.setPrescaleFactor(32000);     // 32MHz/32000 = 1kHz -> 1ms Periodendauer
  4️⃣ ...
  anzeigeTimer.attachInterrupt(isr_Anzeige); // ISR einstellen
  anzeigeTimer.resume();                     // Timer starten
  Serial.begin(9600);
}
void loop() {
  buttonCheck();   // Tasten abfragen
  switch(zustand){ // für do und Transitionen
   5️⃣ ...
  }  
}

📦 1. Erstellen Sie ein Zustandsdiagramm für die Paketerfassung

❗️buttonCheck() muss nicht als do/buttonCheck() eingetragen werden.

Mögliche Lösung

📦 2. stelleWecker(int n)

Nach n Sekunden soll eine TimerISR isr_Wecker() aufgerufen werden. Erstellen Sie den Quellcode für stelleWecker(int n), die den Timer einstellt und startet.

📦 3. isr_Wecker()

Erstellen Sie den Quellcode für isr_Wecker().

📦 4. isr_Anzeige()

Die zwei 7 Segementanzeigen werden mit 100Hz zeitmultiplext. Welche Codezeile muss im setup() eingefügt werden, welche Zeilen in isr_Anzeige()?

📦 5. loop()

Erstellen Sie den Code für loop().

static HardwareTimer myWecker = HardwareTimer(TIM2);  // Timerinstanz für Zeitintervall
static HardwareTimer anzeigeTimer = HardwareTimer(TIM4);  // Timerinstanz für gemultiplexte Anzeige

#define S1 PA1 // PA1 Prellend High aktiv
#define S2 PA6 // PA6 Prellend High aktiv
#define S1_FALL buttonEnter&(1<<1) // Taste drücken für Lichtschranke unterbrochen
#define S1_RISE buttonExit&(1<<1)  // Taste loslassen für Lichtschranke nicht unterbrochen
#define S2_FALL buttonEnter&(1<<6) // Taste drücken für Lichtschranke unterbrochen
#define S2_RISE buttonExit&(1<<6)  // Taste loslassen für Lichtschranke nicht unterbrochen

enum zustandstyp {RUHE,S1_UNTERBROCHEN,P_LANG_ERKANNT,P_KURZ_ERKANNT,P_LANG_AUSWERFEN,P_KURZ_AUSWERFEN};
volatile zustandstyp zustand=RUHE;

int paketAnzahl=0; // Zähler für die ausgelieferten Pakete
int bcd_7seg[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; // Umrechnung

#define BUTTONREADER GPIOA->IDR & 0b10001000010 // nur die relevanten Tastenbits
int buttonOld = 0;              // alter Tasten-Zustand 
int buttonEnter,buttonExit;     // gedrueckte und losgelassene Tasten 

void buttonCheck(){             // Tastaturabfrage mit Flankendedektion  
  int buttonTest,tmp; 
  buttonEnter = 0, buttonExit = 0; 
  buttonTest = BUTTONREADER;       // Einlesen
  if (buttonOld != buttonTest){    // hat sich was getan 
    delay(5);                      // 5ms Prellen abwarten 
    tmp = BUTTONREADER;            // noch mal Einlesen
    if (tmp == buttonTest){        // ist es stabil? 
      buttonEnter = (~buttonOld) & buttonTest; // steigende Flanke !alt und neu 
      buttonExit = buttonOld & (~buttonTest);  // fallende Flanke alt und !neu 
      buttonOld = buttonTest; 
    } 
  } 
}
void stelleWecker(int n){ // Sekundenwecker stellen
  myWecker.setPrescaleFactor(32000); // 32MHz/32000 = 1kHz -> 1ms Periodendauer
  myWecker.setOverflow(n*1000);      // Zeit in ms einstellen
  myWecker.attachInterrupt(isr_Wecker);            // ISR einstellen
  myWecker.setCount(0);  // Zählerstand wieder auf 0 stellen
  myWecker.resume();     // Timer starten
}
void isr_Wecker(){   // Wecker ist abgelaufen
  myWecker.pause();  // Timer stoppen
  switch(zustand){
    case P_LANG_AUSWERFEN:
      zustand=RUHE;
      pLang();
      paketAnzahl++;
      break;
    case P_KURZ_AUSWERFEN:
      zustand=RUHE;
      pKurz();
      paketAnzahl++;
      break;   
  }
}
void isr_Anzeige(){ // gemultipexte 7 Segmentanzeige
  static bool einer = true;
  if (einer){
    GPIOC->ODR = bcd_7seg[paketAnzahl%10] | (1<<11); // Einer einschalten
  }
  else{
    GPIOC->ODR = bcd_7seg[paketAnzahl/10] | (1<<12); // Zehner einschalten
  }
  einer = !einer;
}
void pLang(){Serial.println("pLang()");}
void pKurz(){Serial.println("pKurz()");}

void setup() {
  pinMode(S1, INPUT_PULLDOWN);
  pinMode(S2, INPUT_PULLDOWN);
  pinMode(PC11,OUTPUT);   // Einer
  pinMode(PC12,OUTPUT);   // Zehner
  GPIOC->MODER |= 0x5555; // PC0..PC7 als Ausgang
  anzeigeTimer.setPrescaleFactor(32000);     // 32MHz/32000 = 1kHz -> 1ms Periodendauer
  anzeigeTimer.setOverflow(10);              // alle 10 ms ISR -> 100Hz
  anzeigeTimer.attachInterrupt(isr_Anzeige); // ISR einstellen
  anzeigeTimer.resume();                     // Timer starten
  Serial.begin(9600);
}
void loop() {
  buttonCheck();   // Tasten abfragen
  switch(zustand){ // für do und Transitionen
    case RUHE:
      if(S1_FALL){
        zustand=S1_UNTERBROCHEN;
        Serial.println("S1_UNTERBROCHEN");
      }
      break;
    case S1_UNTERBROCHEN:
      if(S2_FALL){
        zustand=P_LANG_ERKANNT;
        Serial.println("P_LANG_ERKANNT");
      }
      if(S1_RISE){
        zustand=P_KURZ_ERKANNT;
        Serial.println("P_KURZ_ERKANNT");
      }
      break;
    case P_LANG_ERKANNT:
      if(S2_RISE){
        zustand=P_LANG_AUSWERFEN;
        stelleWecker(8);
        Serial.println("P_LANG_AUSWERFEN");
      }
      break;
    case P_KURZ_ERKANNT:
      if(S2_RISE){
        zustand=P_KURZ_AUSWERFEN;
        stelleWecker(3);
        Serial.println("P_KURZ_AUSWERFEN");
      }
      break;
  }  
}

📦 Paketerfassung mit Sortierstraße (HP09) Lösung mit Events und Schlange

Synopsis: https://github.com/EinarArnason/ArduinoQueue🔗

Probleme bei der Umsetzung mit STM32-Arduino mit zwei ISRs

Auf einen Pin z.B. S1 zwei verschiedene ISRs (rise, fall) zu setzen ist mit Arduino nicht einfach möglich, es kann nur eine ISR pro Pin eingestellt werden, somit muss statt dessen eine change-ISR verwendet werden und in dieser wird bestimmt ob rise bzw. fall vorliegt.

Auch das Testen mit prellenden Tasten die als ISR-verarbeitet werden ist kein Spaß.

Lösung ist ein Eventansatz…

Zustandsdiagramm

Tasten entprellen mit Klasse Taster aus der TgiLib

Taster t_name(pin,highactiv)	Konstruktor für Taster-Instanz t_name Taster an pin. Parameter highactiv gibt an, ob Taster gedrückt HIGH,true oder LOW,false ist. Dabei wird pinMode(pin,INPUT) ausgeführt, bei internem PullDown o.ä im Setup pinMode(..) entsprechend nochmal durchführen.
t_name.enter():Bool	true, wenn Taster gedrückt wurde
t_name.exit():Bool	true, wenn Taster losgelassen wurde
t_name.change():int8_t	-1, wenn Taster losgelassen wurde, 0 bei keine Aktion, 1 bei Taster gedrückt

Lösungscode

Statt der Lichtschranken habe ich die Taster an PA1 und PA6 verwendet und entprellt. Die Logik ist umgekehrt.
Ausserdem habe ich versucht, die ISRs in Events um zu wandeln mit einer EventQueue.

#include <ArduinoQueue.h>
#include "TgiLib.h"
static HardwareTimer myWecker = HardwareTimer(TIM2);  // Timerinstanz für Zeitintervall
static HardwareTimer anzeigeTimer = HardwareTimer(TIM4);  // Timerinstanz für gemultiplexte Anzeige

typedef std::function<void(void)> my_event_t; // für die Queue
ArduinoQueue <my_event_t> eventQueue(10);

#define P_S1 PA1        // Pin für Taster prellend High aktiv
#define P_S2 PA6        // Pin für Taster prellend High aktiv

Taster t_s1(P_S1,HIGH); // entprellende Tasterinstanz(Pin,highactiv) zum Testen
Taster t_s2(P_S2,HIGH);

enum zustandstyp {RUHE,S1_UNTERBROCHEN,P_LANG_ERKANNT,P_KURZ_ERKANNT,P_LANG_AUSWERFEN,P_KURZ_AUSWERFEN};
volatile zustandstyp zustand=RUHE;

void isr_S1_change(){    // Lichtschranke Veränderung
  Serial.println("isr_S1_change");
  if(digitalRead(P_S1)){ // wenn high, dann steigende Flanke
    eventQueue.enqueue(event_S1_rise);
  }
  else{
    eventQueue.enqueue(event_S1_fall);
  }
}
void event_S1_fall(){
  Serial.println("event_S1_fall");
  switch(zustand){
    case RUHE:
      zustand=S1_UNTERBROCHEN;
      break;
  }
}
void event_S1_rise(){
  Serial.println("event_S1_rise");
  switch(zustand){
    case S1_UNTERBROCHEN:
      zustand=P_KURZ_ERKANNT;
      break;
  }
}
void isr_S2_change(){    // Lichtschranke fall = Taster rise
  if(digitalRead(P_S2)){   // wenn high, dann steigende Flanke
    eventQueue.enqueue(event_S2_rise);
  }
  else{
    eventQueue.enqueue(event_S2_fall);
  }
}
void event_S2_fall(){
  Serial.println("event_S2_fall");
  switch(zustand){
    case S1_UNTERBROCHEN:
      zustand=P_LANG_ERKANNT;
      break;
  }
}
void event_S2_rise(){
  Serial.println("event_S2_rise");
  switch(zustand){
    case P_LANG_ERKANNT:
      zustand=P_LANG_AUSWERFEN;
      stelleWecker(8);
      break;
    case P_KURZ_ERKANNT:
      zustand=P_KURZ_AUSWERFEN;
      stelleWecker(3);
      break;   
  }
}
void stelleWecker(int n){ // Sekundenwecker stellen
  myWecker.setPrescaleFactor(32000);    // 32MHz/32000 = 1kHz -> 1ms Periodendauer
  myWecker.setOverflow(n*1000);         // Zeit in ms einstellen
  myWecker.attachInterrupt(isr_Wecker); // ISR einstellen
  myWecker.setCount(0);  // Zählerstand wieder auf 0 stellen
  myWecker.resume();     // Timer starten
}
void isr_Wecker(){   // Wecker ist abgelaufen
  eventQueue.enqueue(event_Wecker);
  myWecker.pause();  // Timer stoppen
}
void event_Wecker(){
  Serial.println("event_Wecker");
  switch(zustand){
    case P_LANG_AUSWERFEN:
      zustand=RUHE;
      pLang();
      break;
    case P_KURZ_AUSWERFEN:
      zustand=RUHE;
      pKurz();
      break;   
  }
}
void pLang(){
  Serial.println("pLang()");
}
void pKurz(){
  Serial.println("pKurz()");
}
void setup() {
  pinMode(P_S1,INPUT_PULLDOWN);
  pinMode(P_S2,INPUT_PULLDOWN);
  //attachInterrupt (digitalPinToInterrupt (P_S1), isr_S1_change, CHANGE); // Taster umgekehrte Logik
  //attachInterrupt (digitalPinToInterrupt (P_S2), isr_S2_change, CHANGE); 
  Serial.begin(9600);
  COMPILE_INFO // Compile-Info ausgeben (Spielerei)
}
void abfragenTaster(){  // zum Testen
  int8_t tmp;
  tmp= t_s1.change();
  if(tmp>0)eventQueue.enqueue(event_S1_fall);       // Taste gedrückt = Lichtschranke unterbrochen
  else if(tmp<0) eventQueue.enqueue(event_S1_rise); // Taste losgelassen = Lichtschranke nicht unterbrochen
  tmp= t_s2.change();
  if(tmp>0)eventQueue.enqueue(event_S2_fall);       // Taste gedrückt = Lichtschranke unterbrochen
  else if(tmp<0) eventQueue.enqueue(event_S2_rise); // Taste losgelassen = Lichtschranke nicht unterbrochen
}
void loop() {
  while (!eventQueue.isEmpty()) {  // alle Events aufarbeiten
      my_event_t e = eventQueue.dequeue();
      e();
  }
  abfragenTaster();
  switch(zustand){ // für do und Transitionen
    case RUHE:
      break;
  }  
}

// TgiLib.h V0.6 © 27.02.2025 Oliver Mezger MezMedia.de CC BY-SA 4.0

#include "Arduino.h"

#define COMPILE_INFO \
  Serial.print("Compiledatum: "); \
  Serial.print(__DATE__); \
  Serial.print(" Compilezeit: "); \
  Serial.println(__TIME__); \
  Serial.println(__FILE__);

#define ENTPRELLZEIT 30  // Zeit in ms zum Entprellen von Tasten

class Taster{ // Klasse zum Entprellen von Tastern
  public:
    Taster(byte p, bool ha); // Pin, highactive
    bool enter();            // Taste gedrückt
    bool exit();             // Taste losgelassen
    bool active();           // Taste aktiv
    int8_t change();         // -1 falling, 1 rising
  private:
    byte pin;
    bool highactive;
    bool old;
};
class Wecker{  // Klasse für Wecker mit millis()
  public:
    Wecker();
    void stellen(unsigned int n);
    bool fertig();
  private:
    unsigned long weckzeit;
};

// TgiLib.cpp V0.6 © 27.02.2025 Oliver Mezger MezMedia.de CC BY-SA 4.0
#include "Arduino.h"
#include "TgiLib.h"

Taster::Taster(byte p, bool ha){ // Pin, highactive
  old=false; // Taste nicht gedrückt
  pin=p;
  highactive=ha;
  pinMode(p,INPUT);
}
bool Taster::enter(){          // Taste gedrückt
  bool ausgabe = false;
  bool test = digitalRead(pin);
  if (old != test){ // hat sich was getan?
    delay(ENTPRELLZEIT); // ms warten
    test=digitalRead(pin); // noch mal einlesen
    if (old != test){  // immer noch anders?
      ausgabe = highactive?(!old && test):(old && !test); // steigende:fallende Flanke
      old = test;
    }
  }
  return ausgabe;
} 
bool Taster::exit(){             // Taste losgelassen
  bool ausgabe = false;
  bool test = digitalRead(pin);
  if (old != test){ // hat sich was getan?
    delay(ENTPRELLZEIT); // ms warten
    test=digitalRead(pin); // noch mal einlesen
    if (old != test){  // immer noch anders?
      ausgabe = highactive?(old && !test):(!old && test); // fallende:steigende Flanke
      old = test;
    }
  }
  return ausgabe;
}
int8_t Taster::change(){            // abfragen -1 fall, 1 rise
  int8_t ausgabe = 0;
  bool test = digitalRead(pin);
  if (old != test){ // hat sich was getan?
    delay(ENTPRELLZEIT); // ms warten
    test=digitalRead(pin); // noch mal einlesen
    if (old != test){  // immer noch anders?
      if(!old && test) ausgabe = highactive?1:-1;
      else if (old && !test) ausgabe = highactive?-1:1;
      old = test;
    }
  }
  return ausgabe;
}
bool Taster::active(){
  return digitalRead(pin)==highactive;
}

Wecker::Wecker(){
  weckzeit = millis();
}
void Wecker::stellen(unsigned int n){
  weckzeit = millis()+n;
}
bool Wecker::fertig(){
  return millis()>=weckzeit;
}