Bereich-Spannungsmessung

Uebersicht

Online Rechner

Chronik

Dauerkalender





Hohe Frequenzen mit ESP32 messen und anzeigen (PCNT)


Startbild (Schaltung)

Anders als Arduino kann der ESP32 Mikrocontroller mit sehr hohen Frequenzen arbeiten. Sie reichen tief in den Megahertzbereich. Es können z.B. Impulse, je nach Modell, problemlos bis zu 40 MHz erfasst werden. In der Praxis hängt das Maximum jedoch stark von der verwendeten Erfassungsmethode ab. Wenn man die Impulse mithilfe der Interrupt-Methode zählen möchte, können die Impulse bis maximal 500 kHz erfasst werden. Das hängt damit zusammen, dass diese Methode, da bei jedem Impuls Software-Code aufgerufen wird, die CPU sehr stark belastet.
In diesem Versuch wollen wir Impulse bis zu 1MHz messen und anzeigen. Damit das möglich ist und die CPU bei Bedarf auch für andere Zwecke nutzbar bleibt, wird der interne Pulszähler PCNT verwendet. Es handelt sich hier um ein Hardware-Peripheriemodul, das dazu entwickelt wurde, die elektrischen Signale an einem GPIO-Pin zu zählen, ohne dafür die CPU zu belasten. Der interne Hardware-Register des PCNT-Moduls ist ein 16-Bit-Zähler, der Werte im Bereich von -32767 bis +32767 speichern kann. Hier sehen wir, dass bei einer Frequenz von 1MHz, da hier 1.000.000 Impulse innerhalb einer Sekunde ankommen würden, der Zähler mehrfach überlaufen würde. Um fehlerhafte Ergebnisse zu vermeiden, wird im Programmcode der Zähler einmal pro 20 ms abgefragt und anschließend zurückgesetzt. Bei einer Frequenz von 1 MHz sind innerhalb von 20 ms 20.000 Impulse zu erwarten. Diese Zahl kann das PCNT-Modul problemlos erfassen, ohne dass eine Überlaufgefahr besteht. Bei noch höheren Frequenzen könnte man dem Zähleingang am ESP32 einen Signalteiler vorschalten, um die Anzahl der ankommenden Impulse zu reduzieren.

Schaltplan

Schaltplan


Testschaltung

Testschaltung

Der Pulszähler PCNT stellt eine sehr gute Methode zur Erfassung von Signalen mit hohen Frequenzen.
Es kann so die steigende als auch die fallende Flanke erfasst werden. Es erfolgt keine Belastung des Hauptprozessors. Es können Eingangsfrequenzen bis zu 40 MHz zuverlässig verarbeitet werden. Der klassische ESP32 besitzt 8 unabhängige Zählereinheiten (0 bis 7). Jede Einheit hat zwei Kanäle. Mit einem Filter kann z.B. das Kontaktprellen herausgefiltert werden. Es ist möglich, bestimmte Grenzen festzulegen, bei deren Erreichen eine Interrupt-Funktion ausgelöst werden kann.

ESP32 Kurzinfo


Programm

// **************************************************************************************
// Frequenzen bis 1 MHz mit ESP32 messen und anzeigen
// Eine Schaltung mit ESP32, LCD-Display 16x2 und I2C-Interface FC-113
// Arduino IDE 2.3.10
// **************************************************************************************

#include "driver/pcnt.h"                         // Bibliotheken
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

#define Signal_Pin  4                            // Signal Eingangspin

LiquidCrystal_I2C lcd(0x27, 16, 2);              // LCD: Adresse 0x27, 16 Spalten, 2 Zeilen

volatile int16_t Zaehlerstand_aktuell = 0;       // Veränderbare Variablen
volatile bool Daten_bereit = false; 

hw_timer_t * timer = NULL;

uint16_t Anzahl_der_Messungen = 0;               // Anzeige 1 pro 500 ms 
                                                 // (= 25 Messungen je 20 ms)

// ************************************************************************************************
void onTimer() {                             // Zählerstand auslesen 
    pcnt_get_counter_value(PCNT_UNIT_0, (int16_t*)&Zaehlerstand_aktuell); 
    pcnt_counter_clear(PCNT_UNIT_0);
    Daten_bereit = true; 
}

// ************************************************************************************************
void setup() {

    lcd.init();                                    // LCD Initialisierung             
    lcd.backlight();
    lcd.setCursor(0, 0);
    lcd.print("Frequenzmesser");
    delay(1500);
    lcd.clear();
  
    lcd.setCursor(0, 0);
    lcd.print("Freq:");

    pcnt_config_t pcnt_config = {};                // PCNT Konfiguration
    pcnt_config.pulse_gpio_num = Signal_Pin;       // PCNT Pin = 4
    pcnt_config.ctrl_gpio_num = PCNT_PIN_NOT_USED; // Ohne Steuerpin
    pcnt_config.channel = PCNT_CHANNEL_0;          // Kanal 0
    pcnt_config.unit = PCNT_UNIT_0;                // Zähler 0
    pcnt_config.pos_mode = PCNT_COUNT_INC;         // Zählen bei steigender Flanke
    pcnt_config.neg_mode = PCNT_COUNT_DIS;         // Fallende Flanke ignorieren
    pcnt_config.counter_h_lim = 30000;             // Oberes Zähllimit (mit Reserve)
    pcnt_config.counter_l_lim = -100;              // Unteres Limit (mit Reserve)

    pcnt_unit_config(&pcnt_config);
  
    pcnt_counter_pause(PCNT_UNIT_0);               // Zähler Stop
    pcnt_counter_clear(PCNT_UNIT_0);               // Zähler zurücksetzen
    pcnt_counter_resume(PCNT_UNIT_0);              // Zähler Start

    timer = timerBegin(1000000);                   // Timer auf 1 MHz (1 Tick = 1 µs) einstellen
    timerAttachInterrupt(timer, &onTimer);         // Interrupt-Funktion verknüpfen
    timerAlarm(timer, 20000, true, 0);             // Alle 20.000 µs (20 ms) auslösen, 
                                                   // unbegrenzt wiederholen
}

// ************************************************************************************************
void loop() {
    if (Daten_bereit) {                                    // Zähler auslesen
        Daten_bereit = false; 
        Anzahl_der_Messungen++;                            // Zählt im 20ms-Takt
    
                                                           // Anzeige 1 pro 500 ms -> 25 Messungen 
                                                           // (25 * 20 ms = 500 ms)
        if (Anzahl_der_Messungen >= 25) {   
            Anzahl_der_Messungen = 0;                      // Zähler sofort zurücksetzen
            
            noInterrupts();                                // Kurz pausieren für sicheres Auslesen
            int16_t Aktuelle_Messung = Zaehlerstand_aktuell; 
            interrupts();

                                                           // 20 ms * 50 = 1 Sekunde -> 
                                                           // Multiplikation mit 50 für Hz
            uint32_t frequenzHz = (uint32_t)Aktuelle_Messung * 50;             
      
            lcd.setCursor(6, 0);                           // --- LCD Ausgabe ---
            lcd.print("          ");                       // Zeilenrest leeren
            lcd.setCursor(6, 0);
      
                                                           // Anzeige Formatierung: 
                                                           // Ab 10 kHz in kHz anzeigen, 
                                                           // darunter in Hz
            if (frequenzHz >= 10000) {
                lcd.print(frequenzHz / 1000.0, 1);         // 1 Nachkommastelle
                lcd.print(" kHz");
            } else {
                lcd.print(frequenzHz);
                lcd.print(" Hz");
            }
        }
    }
}

// ************************************************************************************************       



Kurzvideo

Kurzvideo


Weitere Themen:


Google-Suche auf MEINE-SCHALTUNG.de :


Home Impressum Datenschutz