![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_WROOM.png)
Den ESP32-WROOM gibt es in verschiedenen Bauformen, das abgebildete Modell hat 38 Pins
Er verfügt über WLAN und WiFi.
Board installieren
Trage unter Datei -> Einstellungen eine zusätzliche Boardverwalter-URL ein:
https://dl.espressif.com/dl/package_esp32_index.json
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/09/ESP32_WROOM_installieren.png)
Board auswählen
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/09/ESP32_WROOM_Board_waehlen.png)
- Icon für den Boardverwalter anklicken oder Werkzeuge-> Board -> Boardverwalter
- nach ESP32 suchen
- Board installieren
Wenn der ESP32-WROOM nicht automatisch erkannt wurde, klicke auf "Wähle ein anderes Board und einen anderen Port" und suche nach esp32-wroom. Je nach Betriebssystem wird der USB-Port eine andere Bezeichnung haben.
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP_aendern.png)
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_WROOM_waehlen.png)
Mit Steckbrett verwenden
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/12/Steckbrett_ESP32-Wroom.png)
Leider ist der ESP32-Wroom nicht "steckbretttauglich". Ich habe daher zwei Steckbretter zu einem zusammengefügt. Es ist wichtig, dass auf einer Seite die Plus- und Minusleiste erhalten bleibt.
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/12/Steckbrett-Position_ESP32-Wroom.png)
Die optimale Position auf dem Steckbrett.
Pinbelegung
I2C-Bus
➨Info
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/12/ESP32_Board_I2C.png)
I2C-Pins
22 -> SCL
21 -> SDA
Beispiel: Anschluss eines LCD
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/11/ESP-WROOM_LCD.jpg)
So sieht es aus:
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/07/LCD_Zufallszahlen.png)
Das dazugehörige Programm:
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/07/Bibliothek_LCDIC2.png)
Benötigte Bibliothek installieren
# include "LCDIC2.h"
// 4-zeiliges LCD
LCDIC2 lcd(0x27, 20, 4);
// 2-zeiliges LCD
// LCDIC2 lcd(0x3f, 16, 2);
void setup()
{
// Zufallsgenerator starten
randomSeed(analogRead(A0));
// LCD starten
lcd.begin();
// Cursor "verstecken"
lcd.setCursor(false);
// Ausgabe auf dem LCD
// Cursor auf Position 0 in Zeile 0 setzen
lcd.setCursor(0, 0);
lcd.print("Zufallszahlen:");
lcd.setCursor(0, 1);
for (int i = 1; i <= 6; i++)
{
int Zahl = random(1, 7);
lcd.print(String(Zahl));
lcd.print(" ");
}
}
void loop()
{
// bleibt leer, Programm läuft nur einmal
}
Touch-Pins
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_Board_Touch.png)
Touch-Pins
32
33
27
14
12
13
4
2
15
Die Touch-Pins reagieren auf Veränderungen der Fähigkeit von Körpern oder Gegenständen elektrische Ladung zu speichern. Die menschliche Haut ist dazu in der Lage. Wird einer der Touch-Pins berührt, verändert sich der Messwert.
Beispiel:
Schließe ein Kabel am Touch-Pin 32 an.
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_Touch.png)
void setup()
{
Serial.begin(9600);
delay(1000);
}
void loop()
{
Serial.print("Wert: ");
Serial.print(touchRead(32));
if (touchRead(32) < 20) Serial.println(" -> Pin berührt");
else Serial.println(" -> Pin nicht berührt");
delay(1000);
}
Beispiel
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/09/ESP32_Touch-Pin.png)
SPI-Bus
➨Info
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_Board_SPI.png)
SPI-Pins
23 -> COPI/SDO
19 -> CIPO/SDI
18 -> CLK
5 -> CS
Digitale Pins
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_Board_digital_Skalierung.png)
Digitale Pins
links
33
25
26
27
14
12
13
rechts
23
22 (I2C)
21 (I2C)
19
18
5
17
16
4
2
15
Das Blinkprogramm an Pin 33
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_WROOM_LED.jpg)
int LED = 33;
void setup()
{
pinMode(LED, OUTPUT);
}
void loop()
{
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite(LED, LOW);
delay(1000);
}
Analoge Pins
Es stehen zwei ADC-Wandler (Analog Digital Converter) mit einer Auflösung von 9 Bit bis 12 Bit zur Verfügung. Wenn WiFi verwendet wird, können nur die Pins 32 bis 39 als analoge Eingänge angesprochen werden. Das Signal wird in Werte zwischen 0 und 4095 umgewandelt.
Die Auflösung des ADC-Wandlers kann zwischen 9-Bit (0 - 511), 10 Bit (0 - 1023), 11 Bit (0 - 2047) und 12 Bit (0 - 4095) Die Standardeinstellung ist 12 Bit. Die Anweisung analogReadResolution() beeinflusst den ADC-Wandler.
Beispiel:
void setup()
{
Serial.begin(9600);
analogReadResolution(10);
}
void loop()
{
Serial.println("ADC-Wert: " + String(analogRead(35)));
delay(200);
}
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_Board_ADC_Skalierung.png)
Analoge Pins
36
39
34
35
32
33
Beispiel:
Potentiometer an Pin 35
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_WROOM_Analog.jpg)
// Potentiometer an Pin 35
int Potentiometer = 35;
// Variable für den gelesenen Wert
int GelesenerWert = 0;
void setup()
{
Serial.begin(9600);
delay(1000);
}
void loop()
{
// analogen Wert lesen
GelesenerWert = analogRead(Potentiometer);
Serial.println(GelesenerWert);
delay(500);
}
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/ESP32_WROOM_Analog_Plotter.png)
Ausgabe im Seriellen Plotter bei der Drehung des Potentiometers
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/10/Serieller_Plotter_ESP_MilliVolt_ADC.png)
Mit analogReadMilliVolts kann der Wert in Millivolt gelesen werden.
// Potentiometer an Pin 35
int Potentiometer = 35;
// Variable für den gelesenen Wert
int GelesenerWert;
int milliVolt;
void setup()
{
Serial.begin(9600);
// auf serielle Verbindung warten
while (!Serial);
}
void loop()
{
// Werte lesen
GelesenerWert = analogRead(Potentiometer);
milliVolt = analogReadMilliVolts(Potentiometer);
// oder mit map Wertebereich übertragen
// milliVolt = map(analogReadMilliVolts(Potentiometer), 0, 3300, 0, 4095);
// Werte schreiben
// Titel im Plotter
Serial.print("Digital:");
Serial.print(GelesenerWert);
// mit , abschließen
Serial.print(",");
Serial.print("Millivolt:");
Serial.print(milliVolt);
// letzter Wert: mit Serial.println und , abschließen
Serial.println(",");
delay(500);
}
DAC-Pins
Die Pins 25 und 26 können mit dacWrite angesprochen werden. Das Programm erhöht die Helligkeit der LED in 5er-Schritten, anschließend wird die LED gedimmt.
void setup()
{
// kein setup notwendig
}
void loop()
{
// LED an Pin 25
// Helligkeit in 5er -Schritten erhöhen
for (int i = 50; i < 255; i+=5)
{
dacWrite(25, i);
delay(20);
}
// Helligkeit in 5er-Schritten verringern
for (int i = 255; i > 50; i-=5)
{
dacWrite(25, i);
delay(20);
}
}
Bluetooth BLE
Zunächst musst du die Bibliothek ArduinoBLE installieren:
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2021/11/Bibliothek_ArduinoBLE.png)
Das Programm schaltet eine LED an Pin 23:
1 -> einschalten, 0 -> ausschalten:
# include "ArduinoBLE.h"
/*
eindeutige UUID bestimmen:
https://www.guidgenerator.com/online-guid-generator.aspx
https://www.uuidgenerator.net/
BLERead | BLEWrite | BLENotify
-> schreiben, lesen, Info
*/
// Name BLE-Service
BLEService LEDSchalten("19b10000-e8f2-537e-4f6c-d104768a1214");
BLEUnsignedCharCharacteristic Auswahl("19b10000-e8f2-537e-4f6c-d104768a1214", BLERead | BLEWrite | BLENotify);
// LED an Pin 23
int LED = 23;
void setup()
{
Serial.begin(9600);
// pinMode festlegen
pinMode(LED, OUTPUT);
// BLE starten
if (!BLE.begin()) Serial.println("Bluetooth-Modul konnte nicht gestartet werden!");
else Serial.println("Bluetooth-Modul erfolgreich gestartet!");
// Name festlegen (wird in der App angezeigt) und den Service (LEDSchalten) zuweisen
BLE.setLocalName("LED schalten");
BLE.setAdvertisedService(LEDSchalten);
// Auswahl als Platzhalter für den in der App gewählten Wert
LEDSchalten.addCharacteristic(Auswahl);
// Service LEDSchalten hinzufügen
BLE.addService(LEDSchalten);
// Startwert für die Kommunikation schreiben
Auswahl.writeValue(0);
// Zuweisung starten
BLE.advertise();
}
void loop()
{
// auf die Verbindung zu Geräten warten
BLEDevice Verbindung = BLE.central();
// wenn der ESP32 mit einem Gerät verbunden ist ...
if (Verbindung)
{
Serial.println("Verbunden ... ");
// solange der Controller mit einem Gerät verbunden ist ...
while (Verbindung.connected())
{
if (Auswahl.written())
{
// LED einschalten
if (Auswahl.value() == 1)
{
Serial.print(Auswahl.value());
Serial.println(" -> LED ein");
digitalWrite(LED, HIGH);
}
// LED ausschalten
if (Auswahl.value() == 0)
{
Serial.print(Auswahl.value());
Serial.println(F(" -> LED aus"));
digitalWrite(LED, LOW);
}
}
}
}
}
Die für iOS und Android verfügbare App LightBlue sorgt für die Schaltung der LED (Bildschirmschnappschüsse mit iOS).
App LightBlue
![]() | ![]() | ![]() | ![]() | ![]() |
WiFi
Beispiel
Das Programm zeigt im Browser 6 Zufallszahlen an.
Im Seriellen Monitor wird die mit DHCP ermittelte IP des ESP32-Wroom angezeigt.
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/09/IP_WiFi_171.png)
Diese Adresse musst du in einem Browser deiner Wahl eingeben
![](https://hartmut-waller.info/arduinoblog/wp-content/uploads/2023/09/Zufallszahlen_Browser_ESP32.png)
Das Programm
#include "WiFi.h"
// SSID und Passwort des Routers
char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";
WiFiServer Server(80);
WiFiClient Client;
// Minimum und Maximum der Zufallszahlen
int Minimum = 1;
int Maximum = 49;
void setup()
{
Serial.begin(9600);
// auf serielle Verbindung warten
while (!Serial);
// WiFi starten
WiFi.begin(Router, Passwort);
// Verbindung herstellen
while (WiFi.status() != WL_CONNECTED)
{
delay(200);
Serial.print(".");
}
Server.begin();
// SSID des Routers anzeigen
Serial.println();
Serial.print("Verbunden mit ");
Serial.println(WiFi.SSID());
// IP anzeigen
Serial.println(WiFi.localIP());
// Zufallsgenerator mit dem Signal an A0 starten
randomSeed(analogRead(A0));
}
void loop()
{
Client = Server.available();
if (Client)
{
// Seite aufbauen wenn SeiteAufbauen true ist
boolean SeiteAufbauen = true;
// solange der Client verbunden ist ...
while (Client.connected())
{
if (Client.available())
{
// Anforderung vom Clienten lesen ...
char Zeichen = Client.read();
// return (\n) gesendet
if (Zeichen == '\n')
{
// wenn SeiteAufbauen den Wert true hat
if (SeiteAufbauen)
{
/*
HTML-Seite aufbauen
die folgenden Anweisungen müssen
mit print oder println gesendet werden
println "verschönert" den Quelltext
(erzeugt einen Zeilenumbruch im Quelltext)
*/
// HTML-Seite aufbauen
Client.println("HTTP/1.1 200 OK");
Client.println("Content-type:text/html");
// Leerzeile zwingend erforderlich
Client.println();
Client.println("<!doctype html>");
Client.println("<html>");
Client.println("<body>");
// alle 60 Sekunden aktualisieren mit meta-Tag
Client.println("<meta http-equiv=\"refresh\" content=\"60\">");
// <h2> Überschrift H2
Client.println("<h2>Zufallszahlen</h2>");
// <hr> horizontale Linie
Client.println("<hr>");
// Zufallszahlen anzeigen
for (int i = 0; i < 7; i++ )
{
int Zahl = random(Minimum, Maximum);
Client.println(Zahl);
Client.println(" ");
}
Client.print("<hr>");
// IPs anzeigen
Client.print("Eigene IP (Server): ");
Client.print(Client.remoteIP());
// <br> break = neue Zeile
Client.print("<br>IP Adresse Klient DHCP ");
Client.print(WiFi.localIP());
// Seite schließen
Client.println("</body>");
Client.println("</html>");
// HTTP-Antwort endet mit neuer Zeile
Client.println();
// Seite vollständig geladen -> loop verlassen
break;
}
// wenn new line (\n) gesendet wurde -> Seite aufbauen
if (Zeichen == '\n') SeiteAufbauen = true;
else if (Zeichen != '\r') SeiteAufbauen = false;
delay(1);
Client.stop();
}
}
}
}
}
Letzte Aktualisierung: