ESP32 Wroom

Was kann das ESP32-Woom

Der ESP32-Wroom verfügt über:

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 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 20x4 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 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).

Board installieren

Trage unter Datei -> Einstellungen eine zusätzliche Boardverwalter-URL ein:

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

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.