Dauerkalender

Wasserbehälter mit Balkenanzeige

(ESP32, Ultraschall, PulseIn)

In einem Wasserbehälter wird der Inhalt stets überwacht und das aktuelle Wasserniveau angezeigt. Für die Niveauanzeige wird eine Balkenanzeige verwendet. Die Überwachung des Niveaus wird mithilfe eines Ultraschallsensors realisiert. Zum Einsatz kommt der Ultraschallsensor HC-SR04. Die Messungen des Ultraschallsensors werden von dem Mikrocontroller ESP32 ausgewertet. Dabei wird die Methode Trigger-Echo angewandt.
Einen Versuch mit dem Ultraschallsensor HC-SR04 haben wir bereits durchgeführt. Es handelte sich dabei um einen einfachen Regelkreis. Bei der Ermittlung des Abstandes kam, anders als bei diesem Experiment, die Bibliothek „HCSR04.h“ zum Einsatz.

Ultraschallsensor

Mit dem Ultraschallsensor HC-SR04 wird permanent das Wasserniveau überwacht. Der Sensor besteht aus zwei Komponenten: einem Sender und einem Empfänger. Der Sender versendet Schallwellen, die von dem untersuchten Objekt zurückreflektiert werden. Der Empfänger misst die Zeit, die die Schallwellen benötigen, um zurückzukehren. Aus der Zeit und der Schallgeschwindigkeit kann anschließend die Entfernung zum Objekt ermittelt werden.

Balkenanzeige

Das aktuelle Wasserniveau wird mithilfe der Balkenanzeige OA_R102510BCUHRUG_11 angezeigt. Die Anzeige besteht aus 10 Balken, die als Anzeigeelemente der Balkenanzeige fungieren. Hinter jedem Anzeigebalken verbergen sich zwei LEDs, rot und grün, die separat angesteuert werden können.

Mikrocontroller

Der Mikrocontroller ESP32 initiiert die Messungen des aktuellen Niveaus und koordiniert die Ergebnisse mit der Anzeige.

Pegelwandler

Der Pegelwandler passt die 3,3V-Signale an die 5V-Signale an (und umgekehrt).

Der Schaltplan

Der Schaltplan

Die Testschaltung

Die Testschaltung

Das Programm

In dem Beispiel setzen wir voraus, dass das Wasserniveau in dem Wasserbehälter eine Höhe von max. 20 cm erreichen kann. Der aktuelle Wasserstand wird im Takt von 100ms neu erfasst. Befindet sich das Wasserniveau unter der 10 cm Marke, wird der Wasserstand mit grünen Balken der Balkenanzeige angezeigt. Wird die Grenze von 10 cm überschritten, wechselt die Farbe der Balken von Grün auf Rot. Damit stehen 20 Balken für Anzeigezwecke bereit, jeweils ein Balken für 1 cm.
Bei jeder Messung wird der Trigger-Pin des Ultraschallsensors für 10µs auf HIGH geschaltet. Daraufhin sendet sein Sender Schallwellen, die vom Wasserspiegel reflektiert werden. Der Empfänger, der Schallwellen erfassen kann, stellt anschließend fest, wie viel Zeit die Schallwellen unterwegs waren. Diese Information kann anschließend an dem Echo-Pin des Ultraschalls abgefragt werden. In dem Programm übernimmt die Aufgabe die Funktion PulseIn (), die die Zeit in µs liefert.
Die Ermittlung der Entfernung ist dann nur noch reine Rechenaufgabe. Die Schallgeschwindigkeit beträgt 343,2 m/s (trockener Luft, 20°C).
Passend umgerechnet beträgt die Schallgeschwindigkeit 0,034 cm/µs.
Die Entfernung (zurückgelegte Strecke) ist das Produkt der Geschwindigkeit und der Zeit:
s = v*t
Da die Schallwellen die gleiche Strecke hin und zurück zweimal zurückgelegt haben, muss die gesamte Strecke durch zwei dividiert werden. Damit ergibt sich für uns folgende Endformel:
Entfernung (Ultraschall - Wasserspiegel) = 0,034 (cm/µs) * Zeit (µs) / 2 = 0,017 (cm/µs) * Zeit (µs)
Das Ergebnis steht dann in cm zur Verfügung.
Um das Ergebnis auf der Balkenanzeige richtig anzeigen zu können, muss das Ergebnis, da der Ultraschallsensor oberhalb des Wasserspiegels angebracht ist, invertiert werden.
Die Schallgeschwindigkeit ist unter anderem von der Temperatur abhängig. Deswegen wird empfohlen, für genaue Messungen die aktuelle Temperatur zu berücksichtigen.

  int GPIOs [9] = { 13, 12, 14, 27, 26, 25, 33, 32, 23};   // GPIOs für Balkenanzeige
  int Balken [20][2] = {                                   // GPIOs - Paare für
      { 13, 23 }, { 13, 33 }, { 12, 23 }, { 12, 33 },      // für einzelne Balken
      { 14, 23 }, { 14, 33 }, { 27, 23 }, { 27, 33 },
      { 26, 23 }, { 26, 33 },
      { 13, 32 }, { 13, 25 }, { 12, 32 }, { 12, 25 },
      { 14, 32 }, { 14, 25 }, { 27, 32 }, { 27, 25 },
      { 26, 32 }, { 26, 25 }  };
  int Trigger_GPIO = 18;                                   // Trigger Ausgang
  int Echo_GPIO = 19;                                      // Echo Eingang
  int Wartezeit;
  int Entfernung;

// ****************************************************************************** SetUp
  void setup() {
      for ( int i=0; i<9; i++ ) {                          // GPIOs als Ausgänge
          pinMode (GPIOs [i], OUTPUT); }
      pinMode (Trigger_GPIO, OUTPUT);                      // Trigger GPIO als Ausgang
      pinMode (Echo_GPIO, INPUT);                          // Echo GPIO als Eingang
      Anzeige_AUS ();                                      // Anzeige löschen
      Anzeige_testen ();                                   // Test der Anzeige
      digitalWrite (Trigger_GPIO, LOW);
  }


// ********************************************************************** Hauptprogramm
  void loop() {
      digitalWrite (Trigger_GPIO, HIGH);                   // Trigger auf HIGH schalten
      delayMicroseconds(10);                               // 10 mikrosek. warten
      digitalWrite (Trigger_GPIO, LOW);                    // Trigger abschalten
      Wartezeit = pulseIn (Echo_GPIO, HIGH);               // Wartezeit ermitteln
      Entfernung = 20 - (Wartezeit * 0.017);               // Entfernung in cm (20 max)
      if (Entfernung < 0) { Entfernung = 0; };             // Anzeige max. 20 Balken
      Balkenanzeige ();                                    // Ergebnis anzeigen
      delay (100);                                         // Nach 100 ms Wiederholung
  }

// ************************************************************************************
  void Anzeige_testen () {                                 // Alle Balken kurz
      for ( int i=0; i<20; i++ ) {                         // einschalten
          digitalWrite (Balken [i][0], HIGH);
          digitalWrite (Balken [i][1], LOW);
          delay (300);
          Anzeige_AUS ();
      }
  }

// ************************************************************************************
  void Balkenanzeige () {                                  // Aktuelle Anzeige
      Anzeige_AUS ();
      digitalWrite (Balken [Entfernung][0], HIGH);
      digitalWrite (Balken [Entfernung][1], LOW);
  }
  
// ************************************************************************************
  void Anzeige_AUS () {                                    // Alle Balken ausschalten
      for ( int i=0; i<5; i++ ) {
          digitalWrite (GPIOs [i], LOW); }
      for ( int i=5; i<9; i++ ) {
          digitalWrite (GPIOs [i], HIGH); }
  }
  

Kurzvideo

Kurzvideo

Weitere Themen: