Inhalt
Was kann das ESP32-Woom
Der ESP32-Wroom verfügt über:
- digitale Ein- und Ausgänge
- analoge Eingänge
- berührungsempfindliche Touch-Pins
- Bussysteme: I2C und SPI
- WiFi und Bluetooth BLE
Pinbelegung
I2C-Pins
Der I²C-Bus (Inter Integrated Circuit) wurde ursprünglich von Philips entwickelt. Ein Controller (hier das ESP32-Wroom) sollte mit verschiedenen Peripheriegeräten
rolex datejust mens 116200bkrj rolex calibre 2836 2813 automatic 12mm shop cb do one a day boost 900mg cbd tablets 30 caps 001452
kommunizieren können. Die Anschlüsse tragen die Bezeichnungen SDA und SCL.
Einige Bauteile werden mit I2C gesteuert:
I2C -Pins
22 -> SCL
21 -> SDA
Beispiel: Zufallszahlen auf einem 20×4 LCD
So sieht es aus:
Suche unter
Sketch -> Bibliothek einbinden -> Bibliotheken verwalten
nach der Bibliothek LCDIC2
oder klicke auf das Icon 
Das dazugehörige Programm:
# 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(0));
// LCD starten
lcd.begin();
// Cursor verbergen
lcd.setCursor(false);
// Ausgabe auf dem LCD
// Cursor auf Position 0 in Zeile 0 setzen
lcd.setCursor(0, 0);
lcd.print("Zufallszahlen:");
// Cursor auf Position 0 in Zeile 0 setzen
lcd.setCursor(0, 1);
// // 6 Zufallszahlen anzeigen
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
}
SPI-Pins
Auch der SPI-Bus (Serial Peripheral Interface) dient der Kommunikation zwischen dem Controller und Peripheriegeräten. Der SPI-Bus benötigt zwei Datenleitungen und zwei Steuerleitungen:
- COPI (Controller Out Peripherie In) vom Controller ausgehende Kommunikation mit einem Peripeheriegerät
- CIPO (Controller In Peropherie Out) vom Peripherie-Gerät aisgehende Kommunikation mit dem Controller
- CS (Chip Select) der Controller aktiviert und startet die Kommunikation mit dem Peripheriegerät
- SCK (Serial Clock) vom Controller erzeugte Taktfrequenz für den SPI-Bus
Anmerkung:
Es gibt mehrere Initiativen die alten, aber immer noch weit verbreiteten Bezeichnungen MOSI (Master Out Slave In -> COPI) und MISO (Master In Slave Out -> CIPO) zu ersetzen:
https://www.sparkfun.com/spi_signal_names
https://www.oshwa.org/a-resolution-to-redefine-spi-signal-names/
https://docs.arduino.cc/learn/communication/spi
SPI-Pins
23 -> COPI/SDO
19 -> CIPO/SDI
18 -> CLK
5 -> CS
Touch-Pins
Der menschliche Körper und elektrisch leitfähige Gegenstände können elektrische Ladung speichern. Wird einer der Touch-Pins berührt, verändert sich der Messwert.
Touch-Pins
32
33
27
14
12
13
4
2
15
Beispiel: Schließe ein Kabel an Touch-Pin 32 an
Das dazugehörige Programm:
void setup()
{
// Serielle Kommunikation starten
Serial.begin(9600);
delay(1000);
}
void loop()
{
Serial.print("Wert: ");
// gemessenen Wert am Touch-Pin 32 anzeigen
Serial.print(touchRead(32));
// wenn der Wert < 20 -> Pin wurde berührt
if (touchRead(32) < 20) Serial.println(" -> Pin berührt");
// bei größeren Werten wurde der Pin nicht berührt
else Serial.println(" -> Pin nicht berührt");
delay(1000);
}
Digitale Pins
Digitale Pins (INPUT und OUTPUT)
links rechts
33 23
25 22
26 21
27 19
14 18
12 5
13 17
16
4
2
15
Das LED-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 hat den Wertebereich von 0 bis 4095.
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
DAC-Pins
Für das ESP32-Wroom existiert kein analogWrite(). Stattdessen können die Pins 25 und 26 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()
{
// 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);
}
}
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 dazugehörige 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(0));
}
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();
}
}
}
}
}
Bluetooth BLE
Installiere zunächst die Bibliothek ArduinoBLE
Sketch -> Bibliothek einbinden -> Bibliotheken verwalten
Suche nach ArduinoBLE
oder über das entsprechende Icon
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 18
int LED = 18;
void setup()
{
Serial.begin(9600);
// auf serielle Verbindung warten
while (!Serial);
delay(1000);
// 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(char(Auswahl.value()));
Serial.println(" -> LED ein");
digitalWrite(LED, HIGH);
}
// LED ausschalten
if (Auswahl.value() == '0')
{
Serial.print(char(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).
Board installieren
Trage unter Datei -> Einstellungen eine zusätzliche Boardverwalter-URL ein:
https://dl.espressif.com/dl/package_esp32_index.json
- Icon für den Boardverwalter anklicken oder Werkzeuge-> Board -> Boardverwalter
- nach ESP32 suchen
- Board installieren
Board auswählen
Wenn das 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.
Funduino – Dein Onlineshop für Mikroelektronik
- Dauerhaft bis zu 10% Rabatt für Schüler, Studenten und Lehrkräfte
- Mehr als 3.500 Artikel sofort verfügbar!
- Über 8 Jahre Erfahrung mit Arduino, 3D-Druck und co.
