1.5 ⏲ Timer

Dank der STM32-Arduino HardwareTimer library wird man von den nicht ganz einfachen Details der STM32 Timer zunächst verschont.
Info: In der MBED-Umgebung könnte das so aussehen: Ticker Dort wird mit Threads gearbeitet, die schlafen gelegt werden, erinnert mich an Java..
Hier nun der Weg mit STM32-Arduino. (Unterschied zu Atmel-AVR bei Register Compare, hier kein +1 zu Compareregister bei Zeitberechnung, Rücksetzen und ISR-Aufruf erfolgt offensichtlich sofort bei Erreichen des Vergleichswerts, nicht erst mit dem nächsten Systemtakt).

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) 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 Faktor (1..65536) (PSC-Registerwert 0..65535) 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:
$ 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.

TICK_FORMAT ausprobieren und berechnen

Beim TICK_FORMAT müssen Prescaler und Overflow-Wert des Zählers selber eingestellt werden. Ich habe die zu erwartende Frequenz an der LED berechnet und mit diesem Beispielcode einige Messungen durchgeführt.

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

$ 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.

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!

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
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.

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
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} 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};
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() {
}

🐤 Bei Dir piepts wohl? Tonausgabe mit PWM!

Ein Piezo-Lautsprecher soll einen Ton mit Frequenz f = 440 Hz ausgeben. Er ist zwischen GND und PA7/D11 angeschlossen. Am Pin wird dazu ein Rechtecksignal erzeugt. Wie lange ist die Periodendauer T des Signals? Wie lange ist der Pin 1 bzw. 0?
$ T = \frac{1}{f}= \frac{1}{440Hz} = 2.27 ms $
So könnte das realisiert werden:

• Mit delay()? Zu grob
• delayMicroseconds()!
  Erstellen Sie zur Übung ein Programm..
• Mit Timer-ISR
  Erstellen Sie zur Übung ein Programm..
• micros()
  Erstellen Sie zur Übung ein Programm..
• Mit Timer-PWM Hardware

PulsWeitenModulation (PWM) haben Sie schon bei Analog-Ausgabe kennengelernt. An bestimmten Pins des µC können von der Timer-Hardware Signale ausgegeben werden. Dadurch muss sich nicht die CPU darum kümmern. So funktioniert es prinzipiell:

Den Timer bis zu einem Wert Overflow zählen lassen und dann wieder auf 0 springen, wie beim Interrupt. Der Overflow-Wert gibt die Periodendauer vor. Beim Sprung auf 0 den Ausgabe-Pin auf 1 schalten. Ein Vergleichsregister das CaptionCompareRegister (CRR) gibt den Wert vor bei dem der Ausgabe-Pin wieder auf 0 geschaltet wird, es gibt die Einschaltdauer, Impulsdauer vor. Das Verhältnis der Impulsdauer zur Periodendauer ist der Tastgrad (engl. dutycycle). 50% dutycycle bedeutet 50% der Zeit ist der Ausgabepin 1 50% 0.

Der Lautsprecher sei an PA7/D11 angeschlossen. Welcher Timer und welcher Kanal kommt dafür in Frage? Gewählt: TIM3_CH2. In der HardwareTimer library nachschauen wie das geht und ordentliches Testprogramm schreiben:

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

# define USER_BTN PC13  // Entpreller lowaktiver UserButton auf dem Board
# define PIEZO_PIN PA7  // Lautsprecher an PA7/D11 -> TIM3_CH2
# define KANAL 2        // CH2
int einschaltdauer = 50;// 50% dutycycle halbe Zeit an halbe aus
int frequenz = 440;     // 440 Hz
void ausgebenTimerWerte(){
  Serial.printf("Prescaler %5d Overflow %5d Compare %5d\n",mytimer.getPrescaleFactor(),mytimer.getOverflow(),mytimer.getCaptureCompare(KANAL));
}
void isr_userB(){  // Werte verändern und testen
  frequenz+=10;
  mytimer.setPWM(KANAL, PIEZO_PIN, frequenz, einschaltdauer);
  ausgebenTimerWerte();
}
void setup() {
  Serial.begin (9600); //Serielle Kommunikation starten
  pinMode(USER_BTN, INPUT);
  attachInterrupt (digitalPinToInterrupt (USER_BTN), isr_userB, FALLING);
  mytimer.setPWM(KANAL, PIEZO_PIN, frequenz, einschaltdauer);
  ausgebenTimerWerte();
}
void loop() {
}

Nach Programmstart piepst es und am seriellen Monitor wird das ausgegeben:
Prescaler 2 Overflow 35555 Compare 17777
Prima, die API nimmt uns die Rechenarbeit ab.
Leider verstummt bei Druck auf den User-Button der Ton, ein zweiter Aufruf von setPWM() funktioniert nicht zum Verändern der Parameter. Hier der Quellcode der API-Methode:

void HardwareTimer::setPWM(uint32_t channel, PinName pin, uint32_t frequency, uint32_t dutycycle, callback_function_t PeriodCallback, callback_function_t CompareCallback)
{
  setMode(channel, TIMER_OUTPUT_COMPARE_PWM1, pin);
  setOverflow(frequency, HERTZ_FORMAT);
  setCaptureCompare(channel, dutycycle, PERCENT_COMPARE_FORMAT);
  if (PeriodCallback) {
    attachInterrupt(PeriodCallback);
  }
  if (CompareCallback) {
    attachInterrupt(channel, CompareCallback);
  }
  resume();
}

Verantwortlich ist ein zweiter Aufruf der setMode()-Methode, also mit setOverflow() bzw. setCaptureCompare() die Werte in isr_userB() einzeln verändern:

void isr_userB(){  // Werte verändern und testen
  frequenz+=10;
  mytimer.setOverflow(frequenz,HERTZ_FORMAT); // Frequenz einstellen
  mytimer.setCaptureCompare(KANAL,50,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen 0..100
  ausgebenTimerWerte();
}

PWM mit 0,1,99 und 100% ?

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

# define USER_BTN PC13  // Entpreller lowaktiver UserButton auf dem Board
# define PIEZO_PIN PA7  // Lautsprecher an PA7/D11 -> TIM3_CH2
# define KANAL 2        // CH2
int prozent = 50;// 50% dutycycle halbe Zeit an halbe aus
int frequenz = 440;     // 440 Hz
void ausgebenTimerWerte(){
  Serial.printf("Prescaler %5d Overflow %5d Compare %5d\n",mytimer.getPrescaleFactor(),mytimer.getOverflow(),mytimer.getCaptureCompare(KANAL));
}
void isr_userB(){  // Werte verändern und testen
  switch (prozent){
    case 0: prozent=1; break;
    case 1: prozent=99; break;
    case 99: prozent=100; break;
    default: prozent=0;
  }
  mytimer.setCaptureCompare(KANAL,prozent,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen
  ausgebenTimerWerte();
}
void setup() {
  Serial.begin (9600); //Serielle Kommunikation starten
  pinMode(USER_BTN, INPUT);
  attachInterrupt (digitalPinToInterrupt (USER_BTN), isr_userB, FALLING);
  mytimer.setPWM(KANAL, PIEZO_PIN, frequenz, prozent);
  ausgebenTimerWerte();
}
void loop() {
}

Bei Impulsbreite 0% ist der PWM-Ausgang dauerhaft low, bei Impulsbreite 100% ist der PWM-Ausgang dauerhaft high. Betrachten Sie auch die Ausgaben auf dem Seriellen Monitor.

🦆 Alle meine Entchen spielen

Die Noten in eine Tonhöhe also Frequenz umsetzen. Hier eine mögliche Umsetzung [Gleichstufige Stimmung]:

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

#define USER_BTN PC13  // Entpreller lowaktiver UserButton auf dem Board
#define PIEZO_PIN PA7  // Lautsprecher an PA7/D11 -> TIM3_CH2
#define KANAL 2        // CH2
#define HUELLKURVE 0   // besserer Sound mit Hüllkurve
//const unsigned int ton[] ={264,275,297,317,330,352,367,396,422,440,475,495}; // Frequenzen
const unsigned int ton[] ={262,277,293,311,330,349,370,392,415,440,466,494}; // Frequenzen
const unsigned char kurve[]  = {25,13,8,4,2,1,0}; // Huellkurve
const unsigned char melodie[]  ={0,2,4,5,7,7,9,9,9,9,7,9,9,9,9,7,5,5,5,5,4,4,7,7,7,7,0}; // alle meine Entchen
const unsigned char lange[]    ={2,2,2,2,4,4,2,2,2,2,4,2,2,2,2,4,2,2,2,2,4,4,2,2,2,2,4}; // Tonlaengen

void isr_userB(){  // Abschalten können!
  static bool spielt = true;
  if (spielt){
    mytimer.pause();
    spielt=false;
  } else{
    mytimer.resume();
    spielt=true;
  }
}
void setup() {
  pinMode(USER_BTN, INPUT);
  attachInterrupt (digitalPinToInterrupt (USER_BTN), isr_userB, FALLING);
  mytimer.setPWM(KANAL, PIEZO_PIN, 440, 50); // Initialisierung mit 440 Hz
}
void loop() {
  unsigned char d,i,j,l;
  unsigned int k;
  for (i=0;i<sizeof(melodie);i++){ // spiele die Melodie
    k = ton[melodie[i]]; // hole die Frequenz
    mytimer.setOverflow(k,HERTZ_FORMAT);  // Frequenz einstellen
    mytimer.setCaptureCompare(KANAL,50,PERCENT_COMPARE_FORMAT); // Signalbreite einstellen
    delay(20);
#if HUELLKURVE == 1    // mit Hüllkurve
    for(j=0;j<sizeof(kurve);j++){ // Huellkurve anwenden: Signalbreite schmäler
       mytimer.setCaptureCompare(KANAL,kurve[j],PERCENT_COMPARE_FORMAT);
      for (d=0;d<lange[i];d++){ // Tonlaenge
        delay(20);
      }
    }
 #else                 // ohne Hüllkurve
    for (d=0;d<lange[i];d++){ // Tonlaenge
      delay(100);
    }
    mytimer.setCaptureCompare(KANAL,0,PERCENT_COMPARE_FORMAT);
    delay(80);          // Pause bis naechster Ton
  #endif  
  }
  delay(300);  // Pause bis Melodie wieder startet
}

Mit Hüllkurve hört es sich besser an: #define HUELLKURVE 1 setzen.
Durch eine geringere Pulsbreite kann die Lautsprecherausgabe leiser werden..
Wie ich Sie kenne werden Sie nun begeistert mit neuen Melodien den Unterrichtsraum beglücken 😜.

🎸 Gitarrenstimmhilfe (HP15-2)

Zum Stimmen von Gitarren soll ein µC Referenzfrequenzen an PA7/D11 ausgeben. Das Signal entspricht den Tonfrequenzen der sechs Gitarrensaiten. In der Tabelle sind die Frequenzen und die Ausgaben auf der 7-Segment-LED-Anzeige aufgeführt.

Die Tonauswahl soll über den prellfreien Low-aktiven Taster an PC13 erfolgen. Der Reset-Taster setzt die Stimmhilfe wieder zurück. Nach Einschalten/Reset wird kein Ton ausgegeben und in der 7 Segment Anzeige leuchtet “-“. Mit jedem Tastendruck auf PC13 wird der jeweils nächste Ton ausgewählt, dies geschieht mit einer ISR. Nach e’ soll die Auswahl wieder mit E beginnen:
(Ruhe->E->A->d->g->h->e’->E->…).

Töne genau erzeugen, Prescaler und und Overflow ermitteln

Viele Töne (E,d,h,e’) lassen sich nicht mit dem Herz-Format genau einstellen, da als Eingabe ganze Zahlen vorgesehen sind. Daher wird im Tick-Format Prescaler und Overflow verwendet. Hier eine Beispielrechnung wie die Werte ermittelt werden können:

1. $ \textbf{Taktzahl} = TimerCLK / Tonfrequenz = 32MHz / 82,41Hz = 388302,39 $
2. $ \textbf{Prescaler: } Taktzahl / MaxOverflow = {388302,39 / 65536} = 5,92 \textbf{ Aufrunden: 6} $
3. $ \textbf{Overflow: } Taktzahl / Prescaler = 388302,39 / 6 = \textbf{64717} $
4. $ \textbf{Probe: } TimerCLK / Prescaler / Overflow = 32MHz / 6 / 64717 = \textbf{82,41Hz} $

✍️ Ermitteln Sie die zu erwartenden Werte für Prescaler und Overflow für die anderen Frequenzen.
Tipp: 🖥 Verwenden Sie eine Tabellenkalkulation.
Der Prescaler-Wert ändert sich, es müssten zwei Felder verwendet werden um die Einstellungen zu speichern. Wie genau wären die Frequenzen, wenn der Prescaler-Wert von 82,41 Hz beibehalten und nur die Overflow-Werte geändert werden würden?
✍️ 🖥 Ermitteln Sie die Overflow-Werte für die Frequenzen und bestimmen Sie die Ausgabefrequenz.

Lösung

Werte für 7 Segmentanzeige bestimmen

Bestimmen sie die Werte für die Ausgabe auf der 7 Segmentanzeige, füllen Sie die Tabelle aus:

Ausgabe	g PC6	f PC5	e PC4	d PC3	c PC2	b PC1	a PC0	Hex
–	1	0	0	0	0	0	0	0x40
E
A
d
g
h
e

Code Vorgabe vervollständigen

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

#define USER_BTN PC13  // Entpreller lowaktiver UserButton auf dem Board
#define PIEZO_PIN PA7  // Lautsprecher an PA7/D11 -> TIM3_CH2
#define KANAL 2        // CH2

const unsigned char anzeige[] ={...}; // 7Segmentausgaben für E..e
const unsigned int ton_overflow[] ={64717,...}; // Overflow-Werte für E..e
unsigned char ton=0;

void isr_userB(){  // nächsten Ton ausgeben
  GPIOC->ODR = anzeige[ton]; // ton auf 7Seg. ausgeben
  digitalWrite(PC11,HIGH);   // Einer einschalten
  mytimer.setOverflow(ton_overflow[ton], TICK_FORMAT); // Frequenz einstellen
  mytimer.setCaptureCompare(KANAL,50,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen 0..100
  mytimer.resume();  // Timer aktivieren
  if (ton>=5) ton=0;
  else ton++;
}
void setup() {
  pinMode(PC0, OUTPUT);  // ohne diese Zeile klappts nicht
  GPIOC->MODER = 0x5555; // PC0..PC7 als Ausgang
  pinMode(PC11,OUTPUT); // Einer Ausgang
  pinMode(USER_BTN, INPUT);
  attachInterrupt (digitalPinToInterrupt (USER_BTN), isr_userB, FALLING);
  GPIOC->ODR = 0x40; // - ausgeben
  digitalWrite(PC11,HIGH);  // Einer einschalten
  mytimer.setPrescaleFactor(?);  // Prescaler einstellen
  mytimer.setMode(KANAL, TIMER_OUTPUT_COMPARE_PWM1, PIEZO_PIN); // Den PWM-Ausgang einstellen
}
void loop() {
}

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

#define USER_BTN PC13  // Entpreller lowaktiver UserButton auf dem Board
#define PIEZO_PIN PA7  // Lautsprecher an PA7/D11 -> TIM3_CH2
#define KANAL 2        // CH2

const unsigned char anzeige[] ={0x79,0x77,0x5e,0x6f,0x74,0x7b}; // 7Segmentausgaben für E..e
const unsigned int ton_overflow[] ={64717,48485,36323,27211,21598,16180}; // Overflow-Werte für E..e
unsigned char ton=0;

void isr_userB(){  // nächsten Ton ausgeben
  GPIOC->ODR = anzeige[ton]; // ton auf 7Seg. ausgeben
  digitalWrite(PC11,HIGH);   // Einer einschalten
  mytimer.setOverflow(ton_overflow[ton], TICK_FORMAT); // Frequenz einstellen
  mytimer.setCaptureCompare(KANAL,50,PERCENT_COMPARE_FORMAT); // Impulsbreite einstellen 0..100
  mytimer.resume();  // Timer aktivieren
  if (ton>=5) ton=0;
  else ton++;
}
void setup() {
  pinMode(PC0, OUTPUT);  // ohne diese Zeile klappts nicht
  GPIOC->MODER = 0x5555; // PC0..PC7 als Ausgang
  pinMode(PC11,OUTPUT); // Einer Ausgang
  pinMode(USER_BTN, INPUT);
  attachInterrupt (digitalPinToInterrupt (USER_BTN), isr_userB, FALLING);
  GPIOC->ODR = 0x40; // - ausgeben
  digitalWrite(PC11,HIGH);  // Einer einschalten
  mytimer.setPrescaleFactor(6);  // Prescaler einstellen
  mytimer.setMode(KANAL, TIMER_OUTPUT_COMPARE_PWM1, PIEZO_PIN); // Den PWM-Ausgang einstellen
}
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 10 Sekunden Wecker gestellt werden, der statt Klingeln 0,3 Sekunden mit 2 kHz piepst.

Lösung mit Timer-ISR

static HardwareTimer myWecker = 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

void isr_userB(){    // UserButton
  myWecker.resume(); // Timer starten
}

void isr_Wecker(){   // Wecker ist abgelaufen
  myWecker.pause();  // Timer stoppen, sonst würde er weiter laufen
  myPieper.resume(); // Pieper starten
  delay(300);
  myPieper.pause();  // Pieper stoppen
}

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
  myWecker.setOverflow(10000000,MICROSEC_FORMAT);  // Wecker auf 10 Sekunden stellen
  myWecker.attachInterrupt(isr_Wecker);            // ISR einstellen
}
void loop() {
}

1. Ermitteln Sie die längste Weckzeit, die damit erreicht werden kann, Herleitung!
2. Wie können längere Weckzeiten erzielt werden?
3. Was geschieht, wenn während der Wecker läuft der UserButton erneut gedrückt wird?

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
unsigned long weckzeit; // wann der Wecker "klingeln" soll
enum zustandstyp {CHILLEN,WECKER,PIEPEN};
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(10000); // auf 10 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);
        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
unsigned long weckzeit; // wann der Wecker "klingeln" soll
unsigned long myTicks=0; // 0,1s Ticks
enum zustandstyp {CHILLEN,WECKER,PIEPEN};
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};
zustandstyp zustand=AUS;
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};
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};
zustandstyp zustand=AUS;
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};
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;
  }
}

🔊 Entfernung messen mit Ultraschallsensor HC-SR04 (HP17-2)

ToDo: Bilder von den Sensoren und der Rückseite machen!
Auf Funduino.de gibt es einen Sketch Nr.11 Entfernung messen, diesen wollte ich für unser Board mit dem STM32 anpassen. Auf Seite 10 der Boardbeschreibung wird gezeigt wie ein Ultraschallmodul HC-SR04 verwendet werden kann. An einem Trigger-Pin wird ein mindestens 10µs langes Startsignal angelegt und nach kurzer Zeit erhält man am Echo-Pin ein Signal dessen Dauer proportional zur Entfernung ist. Links auf mezdata.de zum Sensor.
Auch Lehrer machen Fehler: Der angepasste Funduino-Sketch wollte zunächst nicht funktionieren weil ich statt PC9 für das Echosignal PA9 eingetragen hatte. Hab ich aber erst gemerkt, als ich mit dem Oszilloskop Messungen durchführte:

Messung mit dem Funduinomodul:
C1 (Channel1) , Gelb ist das Triggersignal, C2, blau das Echosignal. Entfernung ca. 1m.
Gefahr für den STM durch zu hohe Ausgangsspannung des Echo-Signals? Der STM arbeitet mit 3,3V und das Signal hat 5V, es könnte der Eingang beschädigt werden? Entwarnung: Habe zwischen Modul und Eingang einen 10kΩ Widerstand geschaltet und das Signal zeigt die Spannung am Eingang: 5,14V also fließt kein gefährlicher Strom.
Messung mit dem Amazonmodul:
Echosignal kommt später und hat nur 3,4V
Ist wohl ein anderer µC verbaut..

Musste ein wenig suchen um den Schaltplan des Moduls zu finden und entdeckte zwei hochkarätige Seiten zum Thema: Circuit Diagram Ultrasonic Distance Sensor HC-SR04 und HC-SR04
Leider steht im Funduino-Sketch der übliche abgeschriebene Unsinn von anderen (Triggersignal ist 10ms lang statt 10µs wie in der Doku des Sensors verlangt). Doku zu pulseIn(), noch eine Anleitung. Hier mein modifizierter Sketch:

#define TRIGGER PA10
#define ECHO PC9
long dauer=0; // Das Wort dauer ist jetzt eine Variable, unter der die Zeit gespeichert wird, die eine Schallwelle bis zur Reflektion und zurück benötigt. Startwert ist hier 0.
long entfernung=0; // Das Wort „entfernung“ ist jetzt die variable, unter der die berechnete Entfernung gespeichert wird. Info: Anstelle von „int“ steht hier vor den beiden Variablen „long“. Das hat den Vorteil, dass eine größere Zahl gespeichert werden kann. Nachteil: Die Variable benötigt mehr Platz im Speicher.
void setup(){
  Serial.begin (9600); //Serielle kommunikation starten, damit man sich später die Werte am serial monitor ansehen kann.
  pinMode(TRIGGER, OUTPUT); // Trigger-Pin ist ein Ausgang
  pinMode(ECHO, INPUT); // Echo-Pin ist ein Eingang
}
void loop(){
  digitalWrite(TRIGGER, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER, LOW);// Jetzt fängt die Messung an
  dauer = pulseIn(ECHO, HIGH); //Mit dem Befehl „pulseIn“ zählt der Mikrokontroller die Zeit in Mikrosekunden, bis der Schall zum Ultraschallsensor zurückkehrt.
  entfernung = (dauer/2) * 0.03432; //Nun berechnet man die Entfernung in Zentimetern. Man teilt zunächst die Zeit durch zwei (Weil man ja nur eine Strecke berechnen möchte und nicht die Strecke hin- und zurück). Den Wert multipliziert man mit der Schallgeschwindigkeit in der Einheit Zentimeter/Mikrosekunde und erhält dann den Wert in Zentimetern.
  if (entfernung >= 500 || entfernung <= 0){ //Wenn die gemessene Entfernung über 500cm oder unter 0cm liegt,…
    Serial.println("Kein Messwert"); //dann soll der serial monitor ausgeben „Kein Messwert“, weil Messwerte in diesen Bereichen falsch oder ungenau sind.
  }
  else{ //  Ansonsten…
    Serial.print(entfernung); //…soll der Wert der Entfernung an den serial monitor hier ausgegeben werden.
    Serial.println(" cm"); // Hinter dem Wert der Entfernung soll auch am Serial Monitor die Einheit "cm" angegeben werden.
  }
  delay(1000); //Das delay von einer Sekunde sorgt in ca. jeder neuen Sekunde für einen neuen Messwert.
}

🅿️ Einparkhilfe mit Leuchtband und blinkender LED

Entwickeln Sie eine Einparkhilfe mit Leuchtband L0..L7. Was ist besser, je näher desto mehr LED oder desto weniger?

Erweitern Sie ihre Lösung mit der blinkenden Board-LED, je näher desto schneller blinkt sie, bei der geringsten Entfernung leuchtet sie dauernd.
Verwenden Sie zum Blinken einen Timer-Interrupt.

#define trigger PA10
#define echo PC9
#define LED_B PA5 // D13 Led auf dem Board
int dauer=0; // int bei STM sind 32 Bit
int entfernung=0;
static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timeruaswahl
void isr_blinken(){
  digitalWrite(LED_B,!digitalRead(LED_B));
}
void setup(){
  Serial.begin (9600); //Serielle kommunikation starten, damit man sich später die Werte am serial monitor ansehen kann.
  pinMode(trigger, OUTPUT); // Trigger-Pin ist ein Ausgang
  pinMode(echo, INPUT); // Echo-Pin ist ein Eingang
  GPIOC->MODER = 0x5555; // PC0..PC7 als Ausgang
  pinMode(LED_B,OUTPUT); // BoardLED
  mytimer.setOverflow(1, HERTZ_FORMAT); 
  mytimer.attachInterrupt(isr_blinken); //Timer IR aktivieren und Sprung zur ISR
}
#define MAX_ENTFERNUNG 200
void ausgeben(int d){
  int ausgabe=0;
  int blink=0;
  int vergleichswert=MAX_ENTFERNUNG;
  while (d < vergleichswert){
    ausgabe = ausgabe*2 +1;
    //vergleichswert /= 1.5; // type cast, Java würde meckern
    vergleichswert = (int) (vergleichswert / 1.5); 
    blink++;
  }
  if (blink==0){ // zu weit weg
    mytimer.pause();   //Timer stoppen
    digitalWrite(LED_B,LOW);
  }
  else if (blink<=7){
    mytimer.setOverflow(blink, HERTZ_FORMAT); //
    mytimer.resume();   //Timer starten
  }
  else{
    mytimer.pause();   //Timer stoppen
    digitalWrite(LED_B,HIGH);
  }
  GPIOC->ODR =ausgabe;
}
void loop(){
  static int dist=0;
  digitalWrite(trigger, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(trigger, LOW); // Messung starten
  dauer = pulseIn(echo, HIGH); 
  entfernung = (dauer/2) * 0.03432; 
  if (entfernung >= 300 || entfernung <= 0){
    Serial.println("Kein Messwert");
  }
  else{
    dist = (dist+entfernung)/2;
    Serial.printf(" %d cm Mittelwert: %d cm \n",entfernung,dist);
    ausgeben(dist);
  }
  delay(200);
}

ToDo: pulseIn() mit Timer nachbauen

Wie kann die Puls-Dauer mit einem Timer gemessen werden?
In der Doku findet sich Frequency_Dutycycle_measurement.ino wie funktioniert das?

Einparkhilfe mit Anzeigenumschaltung

Die Einparkhilfe verwendet für Entfernungen über 16 cm eine zweistellige 7-Segmentanzeige und schaltet bei geringerer Entfernung auf eine Leuchtbandanzeige um. Der entprellte Boardtaster schaltet die Einparkhilfe an und aus. Ausgewertet wird der Tastendruck über einen Interrupt auf die fallende Flanke. Ein Timerinterrupt ruft mit 100 Hz die isr_ausgeben() auf, neben der Ausgabe auf die zwei Anzeigen, bzw. dem Leuchtband wird eine Variable csZaehler (Centi-Sekunden = 100. Sekunden) hochgezählt, mit dieser Variable können Delays vermieden werden.

#define TRIGGER PA10
#define ECHO PC9
int entfernung=0; // entfernung in cm
int csZaehler=0; // Centi-Sekunden
int bcd_7seg[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; // Umrechnung
int leuchtband[]={0b10101010,0b1,0b11,0b111,0b1111,0b11111,0b111111,0b1111111,0b11111111};
static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timeruaswahl
enum{RUHE,MESSEN} zustand=RUHE;

void setup(){
  pinMode(TRIGGER, OUTPUT); // Trigger-Pin ist ein Ausgang
  pinMode(ECHO, INPUT); // Echo-Pin ist ein Eingang
  GPIOC->MODER = 0x5555; // PC0..PC7 als Ausgang
  pinMode(PC11,OUTPUT); // Einer
  pinMode(PC12,OUTPUT); // Zehner
  attachInterrupt (digitalPinToInterrupt (PC13), isr_taster, FALLING);
  mytimer.setOverflow(100, HERTZ_FORMAT); 
  mytimer.attachInterrupt(isr_ausgeben); //Timer IR aktivieren und Sprung zur ISR
  mytimer.resume();   //Timer starten
}
void isr_taster(){ // Taster wurde gedrückt
  switch(zustand){
    case RUHE:
      zustand=MESSEN;
      break;
    case MESSEN:
      zustand=RUHE;  
  }
}
void isr_ausgeben(){  // alle 10ms also 100 Hz
  int ausgabe; // Dezimeter
  switch(zustand){
    case RUHE:
      GPIOC->ODR = 0;
      break;
    case MESSEN:
      if(entfernung <= 16){
        GPIOC->ODR = leuchtband[entfernung/2];
      }
      else{
        ausgabe = entfernung/10; // Dezimeter
        if (csZaehler%2){ // ungerade
          GPIOC->ODR = bcd_7seg[ausgabe%10] | (1<<11); // Einer einschalten
        }
        else{ // gerade
          GPIOC->ODR = bcd_7seg[ausgabe/10] | (1<<7) |(1<<12); // Dezimalpunkt und Zehner einschalten
        }
      }
      if(csZaehler%30==0){ // alle 300 ms Messen
        messung(); // Messe die Entfernung.
      }
  }
  csZaehler++;
}
void messung(){
  int dauer=0; // int bei STM sind 32 Bit
  int mess;
  digitalWrite(TRIGGER, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(TRIGGER, LOW); // Messung starten
  dauer = pulseIn(ECHO, HIGH,20000); // auf 20ms begrenzen für 6m
  mess = (dauer/2) * 0.03432;
  if (mess>300){
    entfernung = 300;
  }
  else{
    entfernung = (entfernung+mess)/2; // Messungen glätten
  }
}
void loop(){
}

Zustandsdiagramm?

Gerne für isr_taster(), aber dabei isr_ausgeben() richtig ein zu bauen macht irre. Ausweg wäre durch geschickte Unterprogramme die Sache zu erleichtern, aber dabei wird der Code unnötig aufgepumpt?

Wozu überhaupt isr_ausgeben() darstellen, führt ja zu keiner Zustandsänderung.

Bonus: Lösung ohne pulseIn()

Bei größeren Distanzen flackert die Einerstelle, die Ursache liegt in der Messung der Pulslänge die von der ISR aufgerufen wird. Hier eine Lösung ohne pulseIn() und ohne Verzögerung.
Hinweis: Die Funktion micros() gibt die Zeit seit Systemstart in Mikrosekunden zurück, wird hier als Zeitmarkengeber verwendet. Dank PlatformIO ist die Definition von mircos() nur einen Mausklick entfernt:

extern uint32_t micros(void) ;

Wie lange dauert es, bis nach Systemstart micros() wieder auf 0 überläuft?

#include <Arduino.h>

#define TRIGGER PA10 // Auslösen einer Messung
#define ECHO PC9     // Signal des Sensors
#define LED_B PA5    // D13 Board-LED
#define TASTER_B PC13 // Board-Taster
const int bcd_7seg[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; // Umrechnung
const int leuchtband[]={0b10101010,0b1,0b11,0b111,0b1111,0b11111,0b111111,0b1111111,0b11111111};
static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timeruaswahl
enum zustandstyp{RUHE,MESSEN};
zustandstyp zustand=RUHE;
int entfernung=0;    // entfernung in cm
int csZaehler=0;     // Centi-Sekunden-Zähler
bool messungLaeuft = false; // Flag zum Synchronisieren

void isr_echo(){ // Messen der Entfernung, Aufruf bei Flankenwechsel
  static unsigned long anfang = micros(); // Anfangszeit merken können
  int dauer;
  int mess;
  if (digitalRead(ECHO) == HIGH) { // 0->1 Messung starten
    anfang = micros();
    messungLaeuft=true;
  }
  else { // 1->0 Messung stoppen und auswerten
    dauer = micros()-anfang;
    mess = (dauer/2) * 0.03432;
    if (mess>300 || mess<=0){
      entfernung = 300;
    }
    else{
      entfernung = (entfernung+mess)/2; // Messungen glätten
    }
    messungLaeuft=false;
  }
}
void isr_taster(){
  switch(zustand){
    case RUHE:
      zustand=MESSEN;
      break;
    case MESSEN:
      zustand=RUHE;  
  }
}
void ausgeben(){
  int ausgabe; // Dezimeter
  if(entfernung <= 16){
    GPIOC->ODR = leuchtband[entfernung/2];
  }
  else{
    ausgabe = entfernung/10; // Dezimeter
    if (csZaehler%2){ // ungerade
      GPIOC->ODR = bcd_7seg[ausgabe%10] | (1<<11); // Einer einschalten
    }
    else{ // gerade
      GPIOC->ODR = bcd_7seg[ausgabe/10] | (1<<7) |(1<<12); // Dezimalpunkt und Zehner einschalten
    }
  }
}
void starteMessung(){ // Messung starten
  digitalWrite(TRIGGER, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(TRIGGER, LOW); 
}
void isr_ausgeben(){ // alle 10 ms
  switch(zustand){
    case RUHE:
      GPIOC->ODR = 0;
      break;
    case MESSEN:
      ausgeben();
      if(!messungLaeuft && csZaehler%30==0){ // alle 300 ms Messung wieder starten
        starteMessung();
      }
  }
  csZaehler++;
}
void setup(){
  pinMode(TRIGGER, OUTPUT); // TRIGGER-Pin ist ein Ausgang  
  pinMode(ECHO, INPUT);     // ECHO-Pin ist ein Eingang
  GPIOC->MODER = 0x5555;    // PC0..PC7 als Ausgang
  pinMode(PC11,OUTPUT);     // Einer
  pinMode(PC12,OUTPUT);     // Zehner
  pinMode(LED_B,OUTPUT);    // Board-LED zum Testen
  pinMode(TASTER_B,INPUT);  // nicht unbedingt erforderlich
  attachInterrupt (digitalPinToInterrupt (TASTER_B), isr_taster, FALLING);
  mytimer.setOverflow(100, HERTZ_FORMAT); 
  mytimer.attachInterrupt(isr_ausgeben); //Timer IR aktivieren und Sprung zur ISR
  mytimer.resume();       //Timer starten
  attachInterrupt(digitalPinToInterrupt(ECHO),isr_echo,CHANGE); // Aufruf bei Flankenwechsel
}
void loop(){
}

Nun habe ich versucht bool messungLaeuft durch zwei Zustände zu ersetzten, dabei musste ich den Echo-Interrupt ein- und ausschalten.

#include <Arduino.h>

#define TRIGGER PA10 // Auslösen einer Messung
#define ECHO PC9     // Signal des Sensors
#define LED_B PA5    // D13 Board-LED
#define TASTER_B PC13 // Board-Taster
const int bcd_7seg[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; // Umrechnung
const int leuchtband[]={0b10101010,0b1,0b11,0b111,0b1111,0b11111,0b111111,0b1111111,0b11111111};
static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timeruaswahl
enum zustandstyp{RUHE,MESSEN,MESSENFERTIG};
zustandstyp zustand=RUHE;
int entfernung=0;    // entfernung in cm
int csZaehler=0;     // Centi-Sekunden-Zähler

void isr_echo(){ // Messen der Entfernung, Aufruf bei Flankenwechsel
  static unsigned long anfang = micros(); // Anfangszeit merken können
  int dauer;
  int mess;
  if (digitalRead(ECHO)) { // 0->1 Messung starten
    anfang = micros();
  }
  else { // 1->0 Messung stoppen und auswerten
    dauer = micros()-anfang;
    mess = (dauer/2) * 0.03432;
    if (mess>300 || mess<=0){
      entfernung = 300;
    }
    else{
      entfernung = (entfernung+mess)/2; // Messungen glätten
    }
    zustand=MESSENFERTIG;
  }
}
void starteMessung(){ // Messung starten
  digitalWrite(TRIGGER, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(TRIGGER, LOW);
}
void isr_taster(){
  switch(zustand){
    case RUHE:
      attachInterrupt(ECHO,ISR_echo,CHANGE); // Aufruf bei Flankenwechsel
      starteMessung();
      zustand=MESSEN;
      break;
    case MESSEN:
    case MESSENFERTIG:
      detachInterrupt(ECHO);
      zustand=RUHE;  
  }
}
void ausgeben(){
  int ausgabe; // Dezimeter
  if(entfernung <= 16){
    GPIOC->ODR = leuchtband[entfernung/2];
  }
  else{
    ausgabe = entfernung/10; // Dezimeter
    if (csZaehler%2){ // ungerade
      GPIOC->ODR = bcd_7seg[ausgabe%10] | (1<<11); // Einer einschalten
    }
    else{ // gerade
      GPIOC->ODR = bcd_7seg[ausgabe/10] | (1<<7) |(1<<12); // Dezimalpunkt und Zehner einschalten
    }
  }
}
void isr_ausgeben(){ // alle 10 ms
  switch(zustand){
    case RUHE:
      GPIOC->ODR = 0;
      break;
    case MESSEN:
      ausgeben();
      break;
    case MESSENFERTIG:
      ausgeben();
      if(csZaehler%30==0){ // alle 300 ms Messung wieder starten
        starteMessung();
        zustand=MESSEN;
      }
  }
  csZaehler++;
}
void setup(){
  pinMode(TRIGGER, OUTPUT); // TRIGGER-Pin ist ein Ausgang  
  pinMode(ECHO, INPUT);     // ECHO-Pin ist ein Eingang
  GPIOC->MODER = 0x5555;    // PC0..PC7 als Ausgang
  pinMode(PC11,OUTPUT);     // Einer
  pinMode(PC12,OUTPUT);     // Zehner
  pinMode(LED_B,OUTPUT);    // Board-LED zum Testen
  pinMode(TASTER_B,INPUT);  // nicht unbedingt erforderlich
  attachInterrupt (digitalPinToInterrupt (TASTER_B), isr_taster, FALLING);
  mytimer.setOverflow(100, HERTZ_FORMAT); 
  mytimer.attachInterrupt(isr_ausgeben); //Timer IR aktivieren und Sprung zur ISR
  mytimer.resume();       //Timer starten
}
void loop(){
}

Erstellen Sie ein Zustandsdiagramm.

Lösungsvorschlag Zustandsdiagramm

🤯 Bonus/Experiment: Ein Entwurf ohne “Events”

ISRs sind keine echten Events, daher können lustige Probleme auftreten, wenn z.B. im Hauptprogramm und in der ISR auf die selben Ressourcen verändert werden. Wollte das von den SuS fern halten, in dem ich alle Zustandsänderungen nur in Hauptprogramm vornehme und künstlich Zustände NAH und FERN verwende. Hier ein Experiment wie das funktionieren könnte (Würg! Nie wieder!):

#define trigger PA10
#define echo PC9
int entfernung=0; // entfernung in cm
int csZaehler=0; // Centi-Sekunden
bool taster_F=false;
int bcd_7seg[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; // Umrechnung
int leuchtband[]={0b10101010,0b1,0b11,0b111,0b1111,0b11111,0b111111,0b1111111,0b11111111};
static HardwareTimer mytimer = HardwareTimer(TIM2);  // Timerinstanz sowie Timerauswahl
enum{RUHE,FERN,NAH} zustand=RUHE;

void setup(){
  pinMode(trigger, OUTPUT); // Trigger-Pin ist ein Ausgang
  pinMode(echo, INPUT); // Echo-Pin ist ein Eingang
  GPIOC->MODER = 0x5555; // PC0..PC7 als Ausgang
  pinMode(PC11,OUTPUT); // Einer
  pinMode(PC12,OUTPUT); // Zehner
  attachInterrupt (digitalPinToInterrupt (PC13), isr_taster, FALLING);
  mytimer.setOverflow(100, HERTZ_FORMAT); 
  mytimer.attachInterrupt(isr_ausgeben); //Timer IR aktivieren und Sprung zur ISR
  mytimer.resume();   //Timer starten
}
void isr_taster(){
  taster_F=true;
}
bool taster() { // Abfrage Taster-Flag und bei true wieder auf false setzen
  if(taster_F){
    taster_F=false;
    return true;
  }
  return false;
}
void isr_ausgeben(){
  int ausgabe; // Dezimeter
  switch(zustand){
    case RUHE:
      GPIOC->ODR = 0;
      break;
    case FERN:
      ausgabe = entfernung/10; // Dezimeter
      if (csZaehler%2){ // ungerade
        GPIOC->ODR = bcd_7seg[ausgabe%10] | (1<<11); // Einer einschalten
      }
      else{ // gerade
        GPIOC->ODR = bcd_7seg[ausgabe/10] | (1<<7) |(1<<12); // Dezimalpunkt und 
      }                                                      // Zehner einschalten
      break;
    case NAH:    
      GPIOC->ODR = leuchtband[entfernung/2];
  }
  csZaehler++;
}
void messung(){
  int dauer=0; // int bei STM sind 32 Bit
  int mess;
  digitalWrite(trigger, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(trigger, LOW); // Messung starten
  dauer = pulseIn(echo, HIGH); 
  mess = (dauer/2) * 0.03432;
  if (mess>300){
    entfernung = 300;
  }
  else{
    entfernung = (entfernung+mess)/2; // Messungen glätten
  }
}
void loop(){
  switch(zustand){
    case RUHE:
      if(taster()){
        zustand = FERN;
      }
      break;
    case FERN:
      if(csZaehler%30==0){ // alle 300 ms Messen
        messung();
      }
      if(taster()){    // Tastendruck hat Priorität, 
        zustand = RUHE; // sonst könnte er übersehen werden
      }
      else if(entfernung <= 16){ // falls diese Bedingung
        zustand = NAH;           // auch zutrifft
      }
      break;
    case NAH:
      if(csZaehler%30==0){ // alle 300 ms Messen
        messung();
      }
      if(taster()){ // Tastenereignis hat Priorität
        zustand = RUHE;
      }
      else if(entfernung > 16){
        zustand=FERN;
      }
  }
}

Versuch den Code so präzise wie möglich in einem Zustandsdiagramm ab zu bilden: