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
Board auswählen
- 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.
Mit Steckbrett verwenden
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.
Die optimale Position auf dem Steckbrett.
Pinbelegung
I2C-Bus
➨Info
I2C-Pins
22 -> SCL
21 -> SDA
Beispiel: Anschluss eines LCD
So sieht es aus:
Das dazugehörige Programm:
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
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.
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
SPI-Bus
➨Info
SPI-Pins
23 -> COPI/SDO
19 -> CIPO/SDI
18 -> CLK
5 -> CS
Digitale Pins
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
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 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);
}
Analoge Pins
36
39
34
35
32
33
Beispiel:
Potentiometer an Pin 35
// 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);
}
Ausgabe im Seriellen Plotter bei der Drehung des Potentiometers
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.
DAC-Pins
25
26
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:
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.
Diese Adresse musst du in einem Browser deiner Wahl eingeben
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: