Ardui­no Nano ESP32

Inhalts­ver­zeich­nis

Das Board Nano ESP32 stellt neben dem Mikro­con­trol­ler auch ein ESP32-Modul bereit. Damit kön­nen Ver­bin­dun­gen zu WLAN-Net­z­­wer­ken und ande­ren Blue­­tooth-Gerä­­ten auf­ge­baut werden.

Pin­be­le­gung

Bild­quel­le: 🔗https://​docs​.ardui​no​.cc/​t​u​t​o​r​i​a​l​s​/​n​a​n​o​-​e​s​p​3​2​/​c​h​e​a​t​-​s​h​eet (abge­ru­fen am 3.9.23, eige­ne Bearbeitung)

Alle mit D bezeich­ne­ten Pins kön­nen als Ein- und Aus­ga­be­pins (➨digitalRead/digitalwrite) ver­wen­det wer­den, alle mit A beschrif­te­ten Pins kön­nen mit ➨analogRead/analogWrite ein­ge­setzt werden.

Alle ana­lo­gen und alle digi­ta­len Pins kön­nen mit der ➨Puls­wei­ten­mo­du­la­ti­on ange­spro­chen werden.

Board instal­lie­ren:

  • Icon für den Board­ver­wal­ter ankli­cken oder Werk­zeu­ge-> Board -> Boardverwalter
  • nach dem Board Ardui­no ESP32 suchen
  • Board instal­lie­ren

Board aus­wäh­len

Blue­tooth BLE

Zunächst musst du die Biblio­thek Ardui­no­BLE installieren:

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 6
int LED = 6;

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);
        }    
      }
    }
  }
}

App Light­Blue

WiFi

Bei­spiel: Das Pro­gramm zeigt im Brow­ser 6 Zufalls­zah­len an.
Im Seri­el­len Moni­tor wird die IP des ESP32-Wroom angezeigt.

Die­se Adres­se musst du in einem Brow­ser dei­ner Wahl eingeben

#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();
        }
      }
    }
  }
}

Boot­loa­der zurücksetzen

Bild­quel­le: 🔗https://​sup​port​.ardui​no​.cc/​h​c​/​e​n​-​u​s​/​a​r​t​i​c​l​e​s​/​9​8​1​0​4​1​4​0​6​0​1​8​8​-​R​e​s​e​t​-​t​h​e​-​A​r​d​u​i​n​o​-​b​o​o​t​l​o​a​d​e​r​-​o​n​-​t​h​e​-​N​a​n​o​-​E​SP32 (abge­ru­fen am 3.9.23)

GND und B1 mit Kabel überbrücken

Kon­trol­lie­ren, ob das rich­ti­ge Board aus­ge­wählt wur­de und als Pro­gramm­er Esp­tool gesetzt ist:

Sketch -> mit Pro­gramm­er hochladen

Reset-Knopf drü­cken

Feh­ler­mel­dun­gen (Linux)

No DFU capa­ble USB device available

Die Berech­ti­gun­gen für das udev-Sub­sys­tem müs­sen ange­passt wer­den. Ich habe dazu die­ses 🔗Script (abge­ru­fen am 02.10.23) ver­wen­det. Außer­dem muss das Pro­gramm dfu-util instal­liert werden.

Fai­led to con­nect to ESP32: No seri­al data recei­ved
No modu­le named 'seri­al'

Die Python-Erwei­te­rung python-pyse­ri­al muss instal­liert werden

Letzte Aktualisierung: 3. Okt 2023 @ 17:20