1.6 ⏱️ Frequenz, Perioden- und Impulsdauer messen

#define P_FREQUENZ PA1 // Frequenz zu messen
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl
volatile unsigned long zaehler=0;  // Flanken zählen
volatile unsigned long frequenz=0; // ermittelte Frequenz

void isr_Messen(){    // Jede Sekunde aufrufen
  frequenz = zaehler; // gemessene Frequenz sichern
  zaehler=0;
  Serial.printf("Frequenz %d Hz \n",frequenz);
}
void isr_Zaehlen(){   // zählt bei jeder steigenden Taktflake
  zaehler++;
}
void setup(){
  Serial.begin (9600); //Serielle kommunikation starten
  pinMode(P_FREQUENZ, INPUT);
  attachInterrupt (digitalPinToInterrupt (P_FREQUENZ), isr_Zaehlen, RISING); // steigende Taktflanken zählen
  mytimer.setOverflow(1000000, MICROSEC_FORMAT);// ISR jede Sekunde
  mytimer.attachInterrupt(isr_Messen); // Timer ISR einstellen
  mytimer.resume();  // Timer aktivieren
}
void loop(){}

1. Ja, solange die Messung stattfindet.
2. Beim Überschreiten von timeout wird 0 zurück gegeben.
   Der Default-Wert von timeout ist 1000000. Die längste Messzeit ist dabei 1 Sekunde.
3. pulseIn() verwendet micros() und ist dabei auf die Genauigkeit dieser Funktion angewiesen, hängt vom µC ab
   https://docs.arduino.cc/language-reference/en/functions/time/micros/🔗

#define P_FREQUENZ PA1 // Frequenz zu messen
volatile unsigned long impulsdauerPos=0; // Dauer positiver Impuls
volatile unsigned long impulsdauerNeg=0; // Dauer negativer Impuls

void isr_Flankenwechsel(){ // bei jeder Flanke aufgerufen
  static unsigned long zeitmarke = 0;   // lokale persistente Zeitmarke
  unsigned long zeitneu = micros();     // Zeit jetzt gleich festhalten
  if(digitalRead(P_FREQUENZ)){        // war steigende Flanke
    impulsdauerNeg = zeitneu-zeitmarke; // Dauer negativer Impuls
  }else{                                // war fallende Flanke
    impulsdauerPos=zeitneu-zeitmarke;   // Dauer positiver Impuls
  }
  zeitmarke=zeitneu;
}
void setup(){
  Serial.begin (9600); //Serielle kommunikation starten
  pinMode(P_FREQUENZ, INPUT);
  attachInterrupt (digitalPinToInterrupt (P_FREQUENZ), isr_Flankenwechsel, CHANGE); // wechselnde Flanken
}
void loop(){
  Serial.printf("Impulsdauer pos %d µs neg %d µs\n",impulsdauerPos,impulsdauerNeg);
  delay(1000);
}

1. Es wird jede Sekunde jeweils der letzte Wert der Messung ausgegeben.
2. Die Genauigkeit hängt der Zeit bis in die ISR gesprungen wird und von der Genauigkeit der micros() Funktion ab.

#define P_FREQUENZ PA1 // Frequenz zu messen
static HardwareTimer mytimer = HardwareTimer(TIM3);  // Timerinstanz sowie Timerauswahl
volatile unsigned long periode = 0;      // Periodendauer
volatile unsigned long impulsdauerPos=0; // Dauer positiver Impuls
volatile unsigned long impulsdauerNeg=0; // Dauer negativer Impuls

void isr_Flankenwechsel(){ // bei jeder Flanke aufgerufen
  static unsigned long zeitmarke = 0;      // lokale persistente Zeitmarke
  unsigned long zeit = mytimer.getCount(); // Zeit jetzt gleich festhalten
  if(digitalRead(P_FREQUENZ)){           // war steigende Flanke
    mytimer.setCount(0);                   // Timer auf 0 setzen
    impulsdauerNeg = zeit-zeitmarke;       // Dauer negativer Impuls
    periode = zeit;                        // Periodendauer
  }else{                                   // war fallende Flanke
    impulsdauerPos=zeit;                   // Dauer positiver Impuls
    zeitmarke=zeit;                        // Zeit merken
  }
}
void setup(){
  Serial.begin (9600); //Serielle Kommunikation starten
  pinMode(P_FREQUENZ, INPUT);
  attachInterrupt (digitalPinToInterrupt (P_FREQUENZ), isr_Flankenwechsel, CHANGE); // steigende Taktflanken zählen
  mytimer.setOverflow(0xFFFF,TICK_FORMAT);// auf Maximum setzen
  mytimer.setPrescaleFactor(32); // 32MHz Frequenz durch 32 Teilen -> 1µs
  mytimer.resume(); // Timer starten
}
void loop(){
  Serial.printf("Impulsdauer pos %d µs neg %d µs Summe %d Periodendauer %d\n",impulsdauerPos,impulsdauerNeg,(impulsdauerPos+impulsdauerNeg),periode);
  delay(1000);
}

1. Bei einem 16Bit-Timer 2¹⁶ µs.
2. Die Zeit zwischen Flankenwechsel und Einlesen des Timers, die Zeit bis zum Zurücksetzen des Timers bei steigender Flanke.

#define TRIGGER PA10 // Pin zum Auslösen der Messung
#define ECHO PC9     // Rückgabepin für Impulslänge
unsigned long dauer=0;        // long sind 32 Bit für Messung der Impulslänge in µs
unsigned long entfernung=0;   // in mm
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(20);       // 10 µs minimal, 20 zur Sicherheit
  digitalWrite(TRIGGER, LOW);  // Jetzt fängt die Messung an
  dauer = pulseIn(ECHO, HIGH,11648); // Mit dem Befehl „pulseIn“ zählt der Mikrokontroller die Zeit in Mikrosekunden, bis der Schall zum Ultraschallsensor zurückkehrt.
  if (dauer!=0){
    entfernung = (entfernung + dauer*0.3434/2)/2; // Berechnung in mm
  }
  Serial.printf("Entfernung:%d\n",entfernung); // Ausgabe serieller Plotter
  delay(500); // 0,5s
}

#define TRIGGER PA10 // Pin zum Auslösen der Messung
#define ECHO PC9     // Rückgabepin für Impulslänge
#define ECHO_RISE digitalRead(ECHO) // wenn nach CHANGE High ist
static HardwareTimer startMessungTimer = HardwareTimer(TIM3);  // Timerinstanz für Messungswiederholung
static HardwareTimer messTimer = HardwareTimer(TIM4);  // Timerinstanz für Pulsdauermessung
enum zustandstyp {MESSEN_ENTRY,MESSEN,MESSUNG};
zustandstyp zustand=MESSEN_ENTRY;

unsigned long entfernung=0;   // in mm
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
  startMessungTimer.setPrescaleFactor(32000);         // 1ms Takt
  startMessungTimer.setOverflow(300);                 // 300 ms
  startMessungTimer.attachInterrupt(isr_startMessung);
  startMessungTimer.resume();                         // Timer starten
  messTimer.setPrescaleFactor(32);                    // 1 µs Takt
  messTimer.setOverflow(12000);                       // bei mehr als ? m
  messTimer.attachInterrupt(isr_messTimer_overflow);  // wenn Messung zu lange dauert
  attachInterrupt (digitalPinToInterrupt (ECHO), isr_echo_change, CHANGE); // wenn sich am ECHO-Pin was tut
}
void isr_startMessung(){ // alle 300 ms eine neue Messung durch ISR ausgelöst
  if(zustand==MESSEN){
    starteMessung();
    zustand = MESSUNG;
  }  
}
void isr_messTimer_overflow(){ // Wenn Pulsmessung zu lange dauert
  zustand = MESSEN_ENTRY;
}
void isr_echo_change(){ // Wenn sich am ECHO-Pin was tut
  if (zustand!=MESSUNG)return; // keine Messung
  if(ECHO_RISE){
    messTimer.setCount(0); // Timer zurück setzen
  } else {  // Falling
    auswertenMessung();
    zustand = MESSEN_ENTRY;
  }
}
void starteMessung(){ // Impuls senden und messTimer klar machen
  digitalWrite(TRIGGER, HIGH);
  delayMicroseconds(20);       // 10 µs minimal, 20 zur Sicherheit
  digitalWrite(TRIGGER, LOW);  // Jetzt fängt die Messung an
  messTimer.setCount(0);
  messTimer.resume();
}
void auswertenMessung(){ // Messung erfolgreich auswerten
  entfernung = (entfernung + messTimer.getCount()*0.3434/2)/2; // Berechnung in mm
  Serial.printf("Entfernung:%d\n",entfernung); // Ausgabe serieller Plotter
}
void loop(){
  switch(zustand){
    case MESSEN_ENTRY:
      messTimer.pause();
      zustand = MESSEN;
      break;
  }
}

#define TRIGGER PA10 // Pin zum Auslösen der Messung
#define ECHO PC9     // Rückgabepin für Impulslänge
#define ECHO_RISE digitalRead(ECHO) // wenn nach CHANGE High ist
#define TASTER PC13 // Entprellter UserButton active low
static HardwareTimer startMessungTimer = HardwareTimer(TIM3);  // Timerinstanz für Messungswiederholung
static HardwareTimer messTimer = HardwareTimer(TIM4);  // Timerinstanz für Pulsdauermessung
static HardwareTimer ausgebenTimer = HardwareTimer(TIM5);  // Timerinstanz für Anzeige
enum zustandstyp {RUHE_ENTRY,RUHE,MESSEN_ENTRY,MESSEN,MESSUNG};
zustandstyp zustand=RUHE_ENTRY;
int bcd_7seg[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x40}; // Umrechnung
int leuchtband[]={0b10101010,0b1,0b11,0b111,0b1111,0b11111,0b111111,0b1111111,0b11111111};

unsigned long entfernung=0;   // in mm
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
  pinMode(TASTER, INPUT);   // UserButton
  GPIOC->MODER = 0x5555; // PC0..PC7 als Ausgang
  pinMode(PC11,OUTPUT);  // Einer
  pinMode(PC12,OUTPUT);  // Zehner
  startMessungTimer.setPrescaleFactor(32000);         // 1ms Takt
  startMessungTimer.setOverflow(300);                 // 300 ms
  startMessungTimer.attachInterrupt(isr_startMessung);
  startMessungTimer.resume();                         // Timer starten
  messTimer.setPrescaleFactor(32);                    // 1 µs Takt
  messTimer.setOverflow(12000);                       // bei mehr als ? m
  messTimer.attachInterrupt(isr_messTimer_overflow);  // wenn Messung zu lange dauert
  attachInterrupt (digitalPinToInterrupt (ECHO), isr_echo_change, CHANGE); // wenn sich am ECHO-Pin was tut
  ausgebenTimer.setPrescaleFactor(32000);             // 1 ms Takt
  ausgebenTimer.setOverflow(10);                      // alle 10 ms 100 Hz
  ausgebenTimer.attachInterrupt(isr_ausgeben);
  attachInterrupt (digitalPinToInterrupt (TASTER), isr_taster, FALLING); // wenn Taster gedrückt wird
}
void isr_startMessung(){ // alle 300 ms eine neue Messung durch ISR ausgelöst
  if(zustand==MESSEN){
    starteMessung();
    zustand = MESSUNG;
  }  
}
bool fehlmessung=false;
void isr_messTimer_overflow(){ // Wenn Pulsmessung zu lange dauert
  fehlmessung=true;
  zustand = MESSEN_ENTRY;
}
void isr_echo_change(){ // Wenn sich am ECHO-Pin was tut
  if (zustand!=MESSUNG)return; // keine Messung
  if(ECHO_RISE){
    messTimer.setCount(0); // Timer zurück setzen
  } else {  // Falling
    auswertenMessung();
    zustand = MESSEN_ENTRY;
  }
}
void starteMessung(){ // Impuls senden und messTimer klar machen
  digitalWrite(TRIGGER, HIGH);
  delayMicroseconds(20);       // 10 µs minimal, 20 zur Sicherheit
  digitalWrite(TRIGGER, LOW);  // Jetzt fängt die Messung an
  messTimer.setCount(0);
  messTimer.resume();
}
void auswertenMessung(){ // Messung erfolgreich auswerten
  entfernung = (entfernung + messTimer.getCount()*0.3434/2)/2; // Berechnung in mm
  Serial.printf("Entfernung:%d\n",entfernung); // Ausgabe serieller Plotter
  fehlmessung=false;
}
void isr_ausgeben(){ // 100Hz
  static bool einer = true; // Einerstelle ist dran
  int ausgabe;
  if(fehlmessung){
    GPIOC->ODR = bcd_7seg[10] | (einer?(1<<11):(1<<12));
  }
  else if(entfernung <= 160){
    GPIOC->ODR = leuchtband[entfernung/20];
  } else{
    ausgabe = (entfernung+50)/100; // in Dezimeter runden
    if (einer){
      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
    }
  }
  einer = !einer;
}
void isr_taster(){
  if(zustand==RUHE){
    zustand=MESSEN_ENTRY;
    ausgebenTimer.resume(); // Ausgabe starten
  } else{
    zustand=RUHE_ENTRY;
  }
}
void anzeigeAus(){
  GPIOC->ODR = 0;
}
void loop(){
  switch(zustand){
    case RUHE_ENTRY:
      ausgebenTimer.pause();
      anzeigeAus();
      zustand=RUHE;
      break;
    case MESSEN_ENTRY:
      messTimer.pause();
      zustand = MESSEN;
      break;
  }
}