Bis jetzt haben wir beim ESP32 vor allem mit digitalen Signalen gearbeitet.
Also mit:
HIGH oder LOW
1 oder 0
AN oder AUS
Das reicht für viele Dinge.
Ein Taster ist gedrückt oder nicht gedrückt.
Eine LED ist an oder aus.
Aber was passiert, wenn wir nicht nur zwei Zustände brauchen?
Zum Beispiel:
- ein Drehregler steht auf 30 %
- ein Lichtsensor erkennt mittlere Helligkeit
- ein Temperatursensor liefert einen Messwert
- ein Joystick bewegt sich nur ein kleines Stück
- ein Sensor liefert eine Spannung zwischen 0 und 3,3 Volt
Dann brauchen wir analoge Werte.
Genau darum geht es in diesem Beitrag.
Wir schauen uns an:
- was analog bedeutet
- was ein ADC ist
- wie
analogRead()funktioniert - wie ein Potentiometer angeschlossen wird
- wie Messwerte im Serial Monitor angezeigt werden
- wie Werte umgerechnet werden
- wie Grenzwerte verwendet werden
- wie ein Potentiometer eine LED steuern kann
Ganz einfach erklärt.
Digital und analog: Was ist der Unterschied?
Beginnen wir mit einem einfachen Vergleich.
Digital
Ein digitales Signal kennt zwei Zustände.
Zum Beispiel:
Taster nicht gedrückt
oder
Taster gedrückt
Oder:
LED aus
oder
LED an
Man könnte sagen:
0 oder 1
Analog
Ein analoges Signal kann dagegen viele Zwischenwerte besitzen.
Zum Beispiel bei einem Lautstärkeregler:
ganz leise
↓
etwas lauter
↓
mittellaut
↓
laut
↓
ganz laut
Es gibt also nicht nur:
AUS
oder:
AN
sondern viele Werte dazwischen.
Ein Beispiel aus dem Alltag
Ein Lichtschalter ist digital.
Er kennt normalerweise:
AUS
oder
AN
Ein Dimmer ist eher analog gedacht.
Er kann beispielsweise stehen auf:
0 %
20 %
40 %
60 %
80 %
100 %
Genau solche Zwischenwerte wollen wir mit dem ESP32 erfassen.
Das Potentiometer
Ein perfektes Bauteil zum Lernen analoger Eingänge ist ein:
Potentiometer
Ein Potentiometer ist ein verstellbarer Widerstand.
In vielen Geräten kennen wir ihn als Drehregler.
Zum Beispiel für:
- Lautstärke
- Helligkeit
- Geschwindigkeit
- Solltemperatur
Newbiely verwendet das Potentiometer ebenfalls als grundlegendes Beispiel dafür, wie analoge Werte mit dem ESP32 eingelesen und anschließend in nutzbare Werte umgerechnet werden können.
Wie sieht ein Potentiometer aus?
Ein typisches Potentiometer besitzt drei Anschlüsse.
Vereinfacht:
Anschluss 1
Anschluss 2
Anschluss 3
Bei unserem Beispiel verbinden wir:
3,3 V
GND
Signal
Newbiely beschreibt diese drei Anschlüsse ebenfalls als Versorgung, Masse und Ausgang zum ESP32.
Wie funktioniert ein Potentiometer?
Das Potentiometer funktioniert vereinfacht wie ein einstellbarer Spannungsteiler.
Keine Sorge, wir müssen die genaue Mathematik für den Einstieg noch nicht kennen.
Wichtig ist nur:
Wenn wir am Drehknopf drehen, verändert sich die Spannung am mittleren Anschluss.
Zum Beispiel:
0 V
↓
0,8 V
↓
1,6 V
↓
2,4 V
↓
3,3 V
Diese Spannung kann der ESP32 messen.
Wie schließen wir das Potentiometer an?
Wir benötigen:
- ESP32
- Breadboard
- Potentiometer
- Jumper-Kabel
Die Anschlüsse werden vereinfacht so verbunden:
ESP32 3,3 V
│
│
Potentiometer
│
├──── Signal → ADC-GPIO
│
│
GND
Ein äußerer Anschluss kommt an:
3,3 V
Der andere äußere Anschluss an:
GND
Der mittlere Anschluss wird mit einem geeigneten analogen Eingang des ESP32 verbunden.
Warum 3,3 Volt?
Der ESP32 arbeitet an seinen GPIOs mit 3,3-V-Logik.
Deshalb ist es für diese Übung sinnvoll, das Potentiometer zwischen:
3,3 V
und:
GND
anzuschließen.
So liegt auch das Ausgangssignal des Potentiometers innerhalb dieses Bereichs.
Was ist ein ADC?
Jetzt kommt ein neuer Begriff:
ADC
ADC bedeutet:
Analog-to-Digital Converter
Auf Deutsch:
Analog-Digital-Wandler
Das klingt kompliziert.
Die Aufgabe ist aber einfach.
Der ADC macht aus einer analogen Spannung eine Zahl.
Warum brauchen wir überhaupt einen ADC?
Der ESP32 ist ein digitaler Mikrocontroller.
Er arbeitet intern mit Zahlen.
Unser Potentiometer liefert aber eine Spannung.
Zum Beispiel:
1,25 Volt
Der ESP32 möchte daraus einen Zahlenwert machen.
Also ungefähr:
Spannung
↓
ADC
↓
Zahlenwert
Damit kann unser Programm mit dem Messwert weiterarbeiten.
analogRead()
Zum Einlesen eines analogen Wertes verwenden wir:
analogRead();
Zum Beispiel:
int value = analogRead(34);
Damit sagen wir:
Lies den analogen Wert an GPIO 34 und speichere ihn in der Variable
value.
Wichtig:
Nicht jeder GPIO eignet sich gleichermaßen als ADC-Eingang.
Vor dem Aufbau sollte deshalb immer die Pinbelegung des verwendeten ESP32-Boards geprüft werden.
Unser erstes Potentiometer-Programm
Ein einfaches Programm kann so aussehen:
#define POT_PIN 34
void setup() {
Serial.begin(115200);
}
void loop() {
int value = analogRead(POT_PIN);
Serial.println(value);
delay(100);
}
Jetzt öffnen wir den Serial Monitor.
Wenn wir am Potentiometer drehen, verändern sich die Werte.
Zum Beispiel:
80
210
450
870
1300
2200
3100
3900
Was bedeuten diese Zahlen?
Der ESP32 wandelt die gemessene Spannung in einen digitalen Zahlenwert um.
Bei vielen klassischen ESP32-Konfigurationen wird häufig ein Bereich bis ungefähr:
0 bis 4095
verwendet.
Dabei bedeutet vereinfacht:
0
→ sehr niedrige Eingangsspannung
und:
4095
→ sehr hohe Eingangsspannung im Messbereich
Der tatsächlich nutzbare Bereich kann je nach ESP32-Variante, Konfiguration und Eingang etwas abweichen.
Für den Einstieg reicht aber:
Je höher die gemessene Spannung, desto größer normalerweise der gelesene ADC-Wert.
Warum springen die Werte manchmal etwas?
Beim Drehen kann man beispielsweise sehen:
2030
2027
2034
2029
2032
obwohl das Potentiometer scheinbar nicht bewegt wird.
Das ist normal.
Analoge Messungen sind nie vollkommen ruhig.
Es können kleine Schwankungen entstehen.
Zum Beispiel durch:
- elektrische Störungen
- Bauteiltoleranzen
- Versorgungsspannung
- Kontaktwiderstände
- ADC-Eigenschaften
Deshalb muss nicht jeder einzelne Zahlenwert exakt gleich sein.
Messwerte verständlicher anzeigen
Nur Zahlen wie:
2437
sind nicht besonders übersichtlich.
Wir können deshalb schreiben:
Serial.print("Potentiometer: ");
Serial.println(value);
Dann zeigt der Serial Monitor:
Potentiometer: 2437
Potentiometer: 2440
Potentiometer: 2435
Damit wissen wir sofort, welcher Wert ausgegeben wird.
Werte in Prozent umrechnen
Häufig möchten wir keine Werte von ungefähr:
0 bis 4095
sondern:
0 bis 100 %
Das ist wesentlich leichter zu verstehen.
Zum Beispiel:
0 %
25 %
50 %
75 %
100 %
map() einfach erklärt
Dafür gibt es in der Arduino-Welt häufig:
map();
Beispiel:
int percent = map(value, 0, 4095, 0, 100);
Das bedeutet:
Wandle den Bereich 0 bis 4095 in den Bereich 0 bis 100 um.
Beispielsweise:
0 → 0 %
ca. 1024 → 25 %
ca. 2048 → 50 %
ca. 3072 → 75 %
4095 → 100 %
Komplettes Beispiel mit Prozentanzeige
#define POT_PIN 34
void setup() {
Serial.begin(115200);
}
void loop() {
int value = analogRead(POT_PIN);
int percent = map(value, 0, 4095, 0, 100);
Serial.print("Potentiometer: ");
Serial.print(percent);
Serial.println(" %");
delay(100);
}
Jetzt erscheint beispielsweise:
Potentiometer: 12 %
Potentiometer: 27 %
Potentiometer: 54 %
Potentiometer: 81 %
Potentiometer: 100 %
Das ist deutlich verständlicher.
Was macht map() genau?
map() nimmt einen Zahlenbereich und überträgt ihn auf einen anderen.
Zum Beispiel:
Eingang:
0 bis 4095
wird:
Ausgang:
0 bis 100
Oder:
0 bis 4095
kann auch zu:
0 bis 255
werden.
Oder:
0 bis 4095
zu:
0 bis 180
Das ist später beispielsweise bei Servomotoren interessant.
Potentiometer als virtueller Regler
Jetzt kann das Potentiometer für verschiedene Aufgaben verwendet werden.
Zum Beispiel:
Potentiometer
↓
Messwert
↓
ESP32
↓
LED-Helligkeit
oder:
Potentiometer
↓
ESP32
↓
Servo-Position
oder:
Potentiometer
↓
ESP32
↓
Motorgeschwindigkeit
Newbiely baut genau auf diesem Prinzip weiter auf und kombiniert das Potentiometer unter anderem mit LED, Relais, Summer und Servomotor.
Einen Grenzwert verwenden
Wir können den analogen Wert auch mit einer Grenze vergleichen.
Zum Beispiel:
Wenn das Potentiometer über 50 % gedreht wird, soll eine LED leuchten.
Dafür verwenden wir:
if();
Beispiel
#define POT_PIN 34
#define LED_PIN 18
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
int value = analogRead(POT_PIN);
if (value > 2048) {
digitalWrite(LED_PIN, HIGH);
}
else {
digitalWrite(LED_PIN, LOW);
}
}
Jetzt gilt vereinfacht:
unter ungefähr 50 %
→ LED aus
und:
über ungefähr 50 %
→ LED an
Damit wird aus einem analogen Messwert eine Entscheidung.
Das ist ein wichtiges Grundprinzip
Viele Sensorprojekte funktionieren genau so.
Zum Beispiel:
Temperatur messen
↓
über 30 °C?
↓
JA
↓
Lüfter einschalten
Oder:
Helligkeit messen
↓
zu dunkel?
↓
JA
↓
Licht einschalten
Oder:
Bodenfeuchtigkeit messen
↓
zu trocken?
↓
JA
↓
Pumpe einschalten
Das Potentiometer simuliert für uns einen Sensor, dessen Wert wir einfach mit der Hand verändern können.
Deshalb eignet es sich hervorragend zum Lernen.
Potentiometer und LED-Helligkeit
Noch interessanter wird es, wenn das Potentiometer die Helligkeit einer LED steuert.
Das Prinzip lautet:
Potentiometer
↓
analogRead()
↓
Messwert
↓
PWM
↓
LED-Helligkeit
Drehen wir nach links:
LED dunkler
Drehen wir nach rechts:
LED heller
Newbiely führt genau diese Kombination als eigenes Beispiel „Potentiometer-Dimm-LED“ auf.
Was ist PWM noch einmal?
Im letzten Beitrag haben wir PWM bereits kennengelernt.
PWM steht für:
Pulse Width Modulation
Der ESP32 schaltet die LED sehr schnell ein und aus.
Je länger die LED innerhalb eines Zyklus eingeschaltet bleibt, desto heller wirkt sie.
Das Potentiometer kann dabei bestimmen:
wie hell
die LED sein soll.
Analoger Eingang bedeutet nicht automatisch analoger Ausgang
Das ist ein wichtiger Unterschied.
Mit:
analogRead();
lesen wir einen analogen Wert ein.
Aber ein normaler GPIO erzeugt nicht einfach eine beliebige echte analoge Spannung.
Zum Dimmen einer LED verwenden wir beispielsweise PWM.
Also:
ANALOGER EINGANG
→ ADC
→ Zahl
und:
PWM-AUSGANG
→ schnelles Ein/Aus
→ scheinbare Zwischenstufe
Diese beiden Dinge sollte man nicht verwechseln.
Analoge Sensoren
Ein Potentiometer ist nur der Anfang.
Viele Sensoren liefern ebenfalls einen analogen Wert.
Zum Beispiel:
- Lichtsensor
- Bodenfeuchtesensor
- Kraftsensor
- bestimmte Gassensoren
- Joystick
- manche Temperatursensoren
- Spannungssensoren
Newbiely führt nach dem Potentiometer zahlreiche weitere Sensoren auf, darunter Bodenfeuchtigkeit, Lichtsensor, Kraftsensor, Gas- und Spannungssensoren.
Das Grundprinzip bleibt ähnlich:
Sensor
↓
analoge Spannung
↓
ADC
↓
Zahlenwert
↓
Programm
Was bedeutet Messbereich?
Ein Sensor kann nur innerhalb eines bestimmten Bereichs sinnvoll messen.
Beispielsweise könnte ein Sensor einen Ausgang von:
0 bis 3,3 Volt
liefern.
Der ESP32 wandelt diesen Bereich dann in digitale Werte um.
Dabei ist wichtig:
Die Eingangsspannung darf den zulässigen Bereich des verwendeten ESP32-Pins nicht überschreiten.
Ein 5-V-Signal sollte deshalb nicht einfach ungeprüft an einen ADC-Eingang des klassischen ESP32 gelegt werden.
Ein analoger Wert ist nicht automatisch ein echter Messwert
Das ist ebenfalls wichtig.
Angenommen, der ESP32 liest:
2400
Was bedeutet das?
Noch gar nicht unbedingt:
24 °C
oder:
24 %
Der Wert ist zunächst nur ein Messwert des ADC.
Damit daraus beispielsweise:
Temperatur
Feuchtigkeit
oder:
Entfernung
wird, muss der Wert entsprechend umgerechnet werden.
Kalibrierung einfach erklärt
Stellen wir uns einen Bodenfeuchtesensor vor.
Er liefert:
800
bei sehr feuchter Erde.
Und:
3200
bei sehr trockener Erde.
Dann könnten wir diese beiden Werte als Bezugspunkte verwenden.
Zum Beispiel:
800
→ 100 % feucht
und:
3200
→ 0 % feucht
Danach können wir die Messwerte dazwischen umrechnen.
Das nennt man vereinfacht:
Kalibrieren
Warum Kalibrierung wichtig ist
Nicht jeder Sensor liefert exakt dieselben Werte.
Auch äußere Einflüsse können eine Rolle spielen.
Deshalb ist es oft sinnvoll, selbst zu messen:
Was liefert der Sensor beim Minimum?
Was liefert er beim Maximum?
Diese Werte können anschließend für die Umrechnung verwendet werden.
Der Serial Monitor ist wieder unser Freund
Bevor wir komplizierte Programme schreiben, sollten wir uns die Rohdaten eines Sensors ansehen.
Zum Beispiel:
int value = analogRead(SENSOR_PIN);
Serial.println(value);
Dann können wir beobachten:
Was passiert beim Drehen?
Was passiert bei Licht?
Was passiert im Dunkeln?
Was passiert bei trockener Erde?
Was passiert bei feuchter Erde?
So lernen wir zunächst den Sensor kennen.
Erst danach schreiben wir die eigentliche Steuerung.
Der Serial Plotter
Für analoge Werte gibt es noch ein sehr praktisches Werkzeug:
den Serial Plotter
Statt nur Zahlen anzuzeigen, zeichnet er Werte als Diagramm.
Zum Beispiel:
Messwert
│
│ /\
│ / \
│ / \
│____/ \____
│
└────────────── Zeit
Das ist besonders hilfreich bei:
- Potentiometern
- Sensoren
- Temperatur
- Helligkeit
- analogen Joysticks
Newbiely führt den Serial Plotter ebenfalls direkt bei den grundlegenden ESP32-Werkzeugen auf.
Ein einfaches Programm für den Serial Plotter
#define POT_PIN 34
void setup() {
Serial.begin(115200);
}
void loop() {
int value = analogRead(POT_PIN);
Serial.println(value);
delay(50);
}
Im Serial Plotter können wir nun sehen, wie sich die Kurve verändert, während wir am Potentiometer drehen.
Typische Anfängerfehler bei analogen Eingängen
Falscher GPIO
Nicht jeder GPIO eignet sich für jeden ADC-Zweck.
Die Pinbelegung des konkreten Boards prüfen.
5 Volt am Eingang
Der klassische ESP32 arbeitet mit 3,3-V-Logik.
Ein zu hohes Eingangssignal kann problematisch sein.
Potentiometer falsch angeschlossen
Bei einem typischen Potentiometer:
äußerer Anschluss → 3,3 V
anderer äußerer Anschluss → GND
mittlerer Anschluss → Signal
Werte springen
Kleine Schwankungen sind bei analogen Messungen normal.
Falsche Erwartungen an analogRead()
analogRead() liefert zunächst einen Rohwert.
Nicht automatisch:
Grad Celsius
Prozent
Lux
Meter
Die Umrechnung muss je nach Sensor erfolgen.
Minimum und Maximum stimmen nicht
Bei echten Sensoren wird oft nicht der gesamte theoretische Wertebereich erreicht.
Dann ist eine eigene Kalibrierung sinnvoll.
Die wichtigsten Befehle
Analogen Wert lesen:
analogRead(PIN);
In einer Variable speichern:
int value = analogRead(PIN);
Im Serial Monitor anzeigen:
Serial.println(value);
Wertebereich umrechnen:
map();
Grenzwert prüfen:
if (value > grenzwert)
Damit lassen sich bereits viele analoge Sensorprojekte umsetzen.
Das Wichtigste in 60 Sekunden
Digitale Signale kennen vereinfacht:
0 oder 1
Analoge Signale besitzen viele Zwischenwerte.
Ein Potentiometer ist ein einfacher analoger Geber.
Es besitzt normalerweise drei Anschlüsse:
3,3 V
GND
Signal
Der ESP32 wandelt die Eingangsspannung mit seinem:
ADC
in einen Zahlenwert um.
Dafür verwenden wir:
analogRead();
Zum Beispiel:
int value = analogRead(POT_PIN);
Mit:
map();
können wir einen Rohwert in einen verständlicheren Bereich umrechnen.
Zum Beispiel:
0 bis 4095
↓
0 bis 100 %
Mit if() können wir anschließend Grenzwerte verwenden.
Und damit sind wir bereits bei einem der wichtigsten Prinzipien für Sensorprojekte:
MESSEN
↓
WERT AUSWERTEN
↓
ENTSCHEIDUNG
↓
AKTION
Wie geht es weiter?
Nach Taster, LED und Potentiometer ist der nächste logische Schritt:
ESP32 und Sensoren
Dabei geht es nicht nur um einen einzelnen Sensor, sondern zunächst um die Frage:
- Was ist ein Sensor?
- digitale und analoge Sensoren
- Sensorwerte verstehen
- Rohwerte und echte Messwerte
- Grenzwerte
- Kalibrierung
- Sensoren mit 3,3 V und 5 V
- Sensoren mit einem einzelnen Signalpin
- Sensoren über I²C
- Sensoren über OneWire
- Sensoren über Bibliotheken
- typische Beispiele wie LDR, DHT22, DS18B20 und Ultraschallsensor
Danach können die wichtigsten Sensortypen jeweils als eigene Blogbeiträge folgen.
Alle Beiträge dieser Serie
- Teil 1: ESP32 kennenlernen
- Teil 2: ESP32 programmieren
- Teil 3: GPIO verstehen
- Teil 4: Taster anschließen und entprellen
- Teil 5: LEDs steuern
- Teil 6: Analoge Werte und ADC (Aktuell)
Add your first comment to this post