Wemos D1 R32 Board im Arduino-Format

Inhalts­ver­zeich­nis

Eigen­schaf­ten

Das Wemos D1 R32 Board ist mit dem ESP32-WROOM-32 von Espres­sif bestückt, es ver­fügt über:

  • digi­ta­le Ein- und Ausgänge
  • ana­lo­ge Eingänge
  • Bus­sys­te­me: I2C und SPI
  • WiFi
  • Blue­tooth LE (BLE)

Board instal­lie­ren

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

https://​dl​.espres​sif​.com/​d​l​/​p​a​c​k​a​g​e​_​e​s​p​3​2​_​i​n​d​e​x​.​j​son

Board aus­wäh­len

  • Icon für den Board­ver­wal­ter ankli­cken oder Wer­k­­­zeu­­­ge-> Board -> Boardverwalter
  • nach lolin d32 suchen
  • Board instal­lie­ren

Wenn das Wemos D1 R32 nicht auto­ma­tisch erkannt wur­de, kli­cke auf "Wäh­le ein ande­res Board und einen ande­ren Port" und suche nach esp32-wroom. Je nach Betriebs­sys­tem wird der USB-Port eine ande­re Bezeich­nung haben.

Pin­be­le­gung

I2C-Pins

➨Info

I2C -Pins

22 -> SCL
21 -> SDA

Bei­spiel: Anschluss eines LCD

So sieht es aus:

SPI-Pins

➨Info

SPI-Pins

23 -> COPI/SDO
19 -> CIPO/SDI
18 -> CLK
  5 -> CS

Digi­ta­le Pins

Digi­ta­le Pins (INPUT und OUTPUT)

15       22       14
32       21       27
33       18       16
  2       19       17
  4       23       25
             5        26
           13
           12

Die Pins 35, 34 36 und 39 sind eben­falls digi­ta­le Pins, kön­nen aber nur als INPUT ver­wen­det wer­den. Die Pins 15, 32 und 33 kön­nen nur sicher ver­wen­det wer­den, wenn eine Stift­leis­te ange­lö­tet wird.

Bei­spiel:
LED mit einem Tas­ter schal­ten. Die LED leuch­tet, solan­ge der Tas­ter gedrückt wird

Das Pro­gramm

int LED = 13;
int Taster = 12;

void setup()
{
  pinMode(LED, OUTPUT);
  pinMode(Taster, INPUT_PULLUP);
}

void loop()
{
  if (digitalRead(Taster) == LOW) digitalWrite(LED, HIGH);
  else digitalWrite(LED, LOW);
}

Touch-Pins

Der mensch­li­che Kör­per und elek­trisch leit­fä­hi­ge Gegen­stän­de kön­nen elek­tri­sche Ladung spei­chern. Wird einer der Touch-Pins berührt, ver­än­dert sich der Messwert.

Touch-Pins (in Klam­mern alter­na­ti­ve Zuordnung)

4 (T0)
15 (T3)
33 (T8)
32 (T9)
12 (T5)
14 (T6)
27 (T7)

Die Pins 15, 32 und 33 kön­nen nur sicher ver­wen­det wer­den, wenn eine Stift­leis­te ange­lö­tet wird.

Bei­spiel:

Schlie­ße ein Kabel an Touch-Pin 14 (T6) an. Berüh­re das Kabel­en­de mit einem Fin­ger. Soll­te es nicht auf Anhieb funk­tio­nie­ren, feuch­te den Fin­ger ein wenig an.

Das Pro­gramm

void setup()
{
  // Serielle Kommunikation starten
  Serial.begin(9600);
  delay(1000);
}

void loop()
{
  Serial.print("Wert: ");

  // gemessenen Wert am Touch-Pin 14 anzeigen
  Serial.print(touchRead(14));

  // wenn der Wert < 25 -> Pin wurde berührt
  if (touchRead(14) < 25) Serial.println(" -> Pin berührt");

  // bei größeren Werten wurde der Pin nicht berührt
  else Serial.println(" -> Pin nicht berührt");
  delay(1000);
}
Anzei­ge im Seri­el­len Monitor

Ana­lo­ge Pins

Es ste­hen zwei ADC-Wan­d­­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 34 bis 36 als ana­lo­ge Ein­gän­ge ange­spro­chen wer­den. Das Signal hat den Wer­te­be­reich von 0 bis 4095.

Ana­lo­ge Pins

2
4
36
38
39

Aus­ga­be im Seri­el­len Plot­ter bei der Dre­hung des Potentiometers

WiFi

Bei­spiel: Das Pro­gramm zeigt im Brow­ser 6 Zufalls­zah­len an.
Im Seri­el­len Moni­tor wird die mit DHCP ermit­tel­te IP des Wemos D1 R32 angezeigt.

Die­se Adres­se musst du in einem Brow­ser dei­ner Wahl im Adress­feld eingeben.

Das Pro­gramm:

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

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 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 ver­füg­ba­re App Light­Blue sorgt für die Schal­tung der LED (Bild­schirm­schnapp­schüs­se mit iOS).

App Light­Blue