ESP32 Wroom

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 Inte­gra­ted Cir­cuit) wur­de ursprüng­lich von Phil­ips ent­wi­ckelt. 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 (Seri­al Peri­phe­ral Inter­face) dient der Kommunikation zwischen dem Controller und Peripheriegeräten. Der SPI-Bus benö­tigt zwei Daten­lei­tun­gen 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­än­dert 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 ste­hen zwei ADC-Wand­ler (Ana­log Digi­tal Con­ver­ter) mit einer Auf­lö­sung von 12 Bit zur Ver­fü­gung. Wenn WiFi ver­wen­det wird, kön­nen nur die Pins 32 bis 39 als ana­lo­ge Ein­gän­ge ange­spro­chen werden. Das Signal hat den Wertebereich von 0 bis 4095.

Analoge Pins

36
39
34
35
32
33

 

Beispiel:
Potentiometer an Pin 35

ESP32 WROOM Analog
				
					// 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 exis­tiert kein ana­log­Wri­te(). Statt­des­sen kön­nen die Pins 25 und 26 mit dac­Wri­te ange­spro­chen wer­den. Das Pro­gramm erhöht die Hel­lig­keit der LED in 5er-Schrit­ten, 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 Pro­gramm schal­tet eine LED an Pin 23:
1 -> ein­schal­ten, 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

Tra­ge unter Datei -> Ein­stel­lun­gen eine zusätz­li­che Board­ver­wal­ter-URL ein:

https://dl.espressif.com/dl/package_esp32_index.json

 

  • Icon für den Board­ver­wal­ter ankli­cken oder Werk­zeu­ge-> 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.
Zu unserem Onlineshop SALE