Wemos D1 R32 UNO-Format

Was kann das Wemos D1 R32 Board

Das Wemos D1 R32 Board ist mit dem ESP32-WROOM-32 von Espressif bestückt.
Das Board bietet:

Pinbelegung

Viele Pins des Wemos D1 R32 sind mehrfach belegt. Die I2C-Pins, die Touch-Pins und die SPI-Pins können auch als digitale Pins verwendet werden.

I2C-Pins

Der I²C-Bus (Inter Integrated Circuit) wurde ursprünglich von Philips entwickelt. Ein Controller (hier das Wemos D21 R32) 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

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

Digitale Pins

Digitale Pins (INPUT und OUTPUT)

links rechts

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 ebenfalls digitale Pins, können aber nur als INPUT verwendet werden. Die Pins 15, 32 und 33 können nur sicher verwendet werden, wenn eine Stiftleiste angelötet wird.

Beispiel:
LED mit einem Taster schalten. Die LED leuchtet, solange der Taster gedrückt wird.

Das dazugehörige Programm:

				
					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 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 (in Klammern alternative Zuordnung)

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

Die Pins 15, 32 und 33 können nur sicher verwendet werden, wenn eine Stiftleiste angelötet wird.

Beispiel:

Schließe ein Kabel an Touch-Pin 14 (T6) an. Berühre das Kabelende mit einem Finger. Sollte es nicht auf Anhieb funktionieren, feuchte den Finger ein wenig 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 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);
}

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 34 bis 36 als analoge Eingänge angesprochen werden. Das Signal hat den Wertebereich von 0 bis 4095.

Analoge Pins

2
4
36
38
39

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

WiFi

Beispiel: Das Programm zeigt im Browser 6 Zufallszahlen an.
Im Seriellen Monitor wird die mit DHCP ermittelte IP des Wemos D1 R32 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.

Über das Menü:

Sketch -> Bibliothek einbinden -> Bibliotheken verwalten
Suche nach ArduinoBLE

oder über das entsprechende Icon

Das Programm schaltet die interne LED:
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);

// interne LED
int LED = 2;

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 Wemos D1 R32 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.