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) (Registerwert 0..65535) und mit diesem langsameren Takt zählt ein Zähler bis zu einem vorgegebenen Wert Overflow (Auto-Reload Register ARR). Beim Erreichen des Overflow-Wertes wird der Zähler wieder auf 0 gesetzt und ein Timer-Interrupt kann auslöst werden.
Es gibt 3 Modi um einen Timerinterrupt aus zu lösen:
- 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 $
TimerCLK | Prescaler | Overflow | Frequenz berechnet | Frequenz gemessen |
---|---|---|---|---|
32 MHz | 32000 | 100 | 5 Hz | 5 Hz |
32 MHz | 32000 | 10 | 50 Hz | 50 Hz |
32 MHz | 32000 | 2 | 250 Hz | 250 Hz |
32 MHz | 32000 | 1 | 500 Hz | Kein Signal! |
32 MHz | 65535 | 2 | 122,07 Hz | 122,07 Hz |
32 MHz | 65536 | 2 | 122,07 Hz | 122,07 Hz |
32 MHz | 65535 | 3 | 81,38 Hz | 81,38 Hz |
32 MHz | 1 | 65535 | 244,14 Hz | 244,14 Hz |
32 MHz | 1 | 65536 | 244,14 Hz | 244,14 Hz |
32 MHz | 1 | 100 | 160 kHz | 48,8 kHz (ISR kam nicht hinterher) |
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, mir ist noch nicht klar ob das Absicht ist oder aus der Integerrechnung hervorgeht. 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

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()
Lösungsvorschlag Quellcode
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: Nach dem Einschalten soll nur noch 3 Mal jedes Gleis geschaltet werden und dann in den Interruptbetrieb gegangen werden. Zustandsdiagramm und Quellcode.
Lösungsvorschlag Zustandsdiagramm
Entfernung messen mit Ultraschallsensor HC-SR04
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.
}
Datentypen-Unterschied zwischen 8 Bit AVM und STM32 Controller
Der klassische Arduino-Controller war ein Atmel AVM 8 Bit Ding. Bei diesem Controller wird für int 16 Bit verwendet, Zahlenbereich -32 Ki .. + 32 Ki -1. Will man grössere Zahlen verarbeiten musste auf long 32 Bit ausgewichen werden. Beim STM32 wird immer mit 32 Bit gearbeitet, daher wird int in 32 Bit übersetzt, Zahlenbereich: -2 Gi .. + 2 Gi-1.
Viele “Verrenkungen” aus der 8 Bit Ära können wir uns sparen…
ToDo: STM32 Datentypen-Tabelle!
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.
Lösungsvorschlag
#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 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(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ähre 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.
#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 Timeruaswahl
enum{RUHE,MESSEN} zustand=RUHE;
volatile bool messungLaeuft = false;
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
pinMode(echo, INPUT);
attachInterrupt(digitalPinToInterrupt(echo),ISR_echo,CHANGE);
}
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 ISR_ausgeben(){ // alle 10 ms
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(!messungLaeuft && csZaehler%30==0){ // alle 300 ms Messung wieder starten
digitalWrite(trigger, HIGH);
delayMicroseconds(10);
digitalWrite(trigger, LOW); // Messung starten
}
}
csZaehler++;
}
void loop(){
}
Bonus/Experiment: 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: