XIAO-ESP32-C3

Lese­zeit: 10 Minu­ten

Das Board

Den XIAO-ESP32-C3 ver­fügt über Blue­tooth und WiFi.

Die Anten­ne für WiFi und Blue­tooth wird auf dem XIAO-ESP32-C3 befestigt.

Board instal­lie­ren

Tra­ge unter Datei -> Ein­stel­lun­gen eine zusätz­li­che Board­ver­wal­ter-URL ein:
https://​raw​.git​hubu​ser​con​tent​.com/​e​s​p​r​e​s​s​i​f​/​a​r​d​u​i​n​o​-​e​s​p​3​2​/​g​h​-​p​a​g​e​s​/​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 ESP32 suchen
  • Board instal­lie­ren

Wenn der XIAO-ESP32-C3 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 xiao_esp32c3. Je nach Betriebs­sys­tem wird der USB-Port eine ande­re Bezeich­nung haben.

Pin­be­le­gung

Quel­le: https://​wiki​.see​ed​stu​dio​.com/​X​I​A​O​_​E​S​P​3​2​C​3​_​G​e​t​t​i​n​g​_​S​t​a​r​ted (abge­ru­fen am 06.10.24)

I2C-Bus

Info

I2C-Pins

D5 -> SCL
D6 -> SDA

Bei­spiel: Anschluss eines LCD

So sieht es aus:

Das dazu­ge­hö­ri­ge Programm:

Benö­tig­te Biblio­thek installieren

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

  // LCD starten
  lcd.begin();

  // Cursor "verstecken"
  lcd.setCursor(false);

  // Ausgabe auf dem LCD
  // Cursor auf Position 0 in Zeile 0 setzen
  lcd.setCursor(0, 0);
  lcd.print("Zufallszahlen:");
  lcd.setCursor(0, 1);
  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-Bus

Info

SPI-Pins

D10 -> COPI/SDO
D9 -> CIPO/SDI
D8 -> CLK

Bei­spiel: Anschluss eines Adafruit-TFTs

(1) -> GND
(2) -> 5V
(3) -> D1
(4) -> D2
(5) -> nicht ange­schlos­sen
(6) -> D0
(7) -> D10
(8) -> D8
(9) -> nicht ange­schlos­sen
(10) -> 5V

// Bibliotheken einbinden
#include "Adafruit_GFX.h"
#include "Adafruit_ST7735.h"

// Adafruit TFT, WaveShare TFT 1,8 Zoll
#define TFT_CS       D0
#define TFT_RST      D1
#define TFT_DC       D2

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

void setup()
{
  Serial.begin(9600);
  delay(500);
  Serial.println("Bildschirm: " + String(tft.height()) + " x " + String(tft.width()));

  tft.initR(INITR_BLACKTAB);

  // Rotation anpassen
  tft.setRotation(2);

  // schwarzer Hintergrund
  tft.fillScreen(ST7735_BLACK);

  // verschiedene Schriftgrößen
  tft.setTextSize(1);
  tft.setCursor(1, 5);
  tft.setTextColor(ST7735_BLUE);
  tft.print("Text");
  delay(500);

  tft.setTextSize(2);
  tft.setCursor(1, 20);
  tft.setTextColor(ST7735_GREEN);
  tft.print("Text");
  delay(500);

  tft.setTextSize(3);
  tft.setCursor(1, 40);
  tft.setTextColor(ST7735_RED);
  tft.print("Text");
  delay(500);

  tft.setTextSize(4);
  tft.setCursor(1, 70);
  tft.setTextColor(ST7735_YELLOW);
  tft.print("Text");
  delay(2000);

  // Linien ziehen
  tft.fillScreen(ST7735_BLACK);
  for (int i = 1; i < tft.height(); i+=10)
  {
    tft.drawLine(1, i, tft.width(), i, ST7735_ORANGE);
  }
  delay(2000);

  // Kreise zeichnen
  tft.fillScreen(ST7735_BLACK);
  tft.fillCircle(tft.width() / 2, tft.height() / 2, 50, ST7735_MAGENTA);
  tft.fillCircle(tft.width() / 2, tft.height() / 2, 30, ST7735_GREEN);
  tft.fillCircle(tft.width() / 2, tft.height() / 2, 10, ST7735_YELLOW);
  delay(2000);

  // Rechtecke zeichnen
  tft.fillScreen(ST7735_BLACK);
  tft.drawRect(1, 1, 50, 50, ST7735_ORANGE);
  tft.drawRect(5, 5, 50, 50, ST7735_ORANGE);
  tft.drawRect(10, 10, 50, 50, ST7735_ORANGE);
  delay(2000);

  // ausgefüllte Rechtecke zeichnen
  tft.fillScreen(ST7735_BLACK);
  tft.fillRect(5, 5, 50, 50, ST7735_GREEN);
  tft.fillRect(10, 10, 70, 70, ST7735_BLUE);
  tft.fillRect(15, 15, 90, 90, ST7735_RED);
}

void loop()
{
  // nichts zu tun, das Programm
  // läuft nur einmal
}

Digi­ta­le Pins

Digi­ta­le Pins

rechts
D10
D9
D8
D7

Das Blink­pro­gramm an Pin D10

int LED = D10;

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

void loop()
{
  digitalWrite(LED, HIGH);
  delay(1000);
  digitalWrite(LED, LOW);
  delay(1000);
}

Ana­lo­ge Pins

Die Auf­lö­sung des ADC-Wand­lers kann zwi­schen 9-Bit (0 - 511), 10 Bit (0 - 1023), 11 Bit (0 - 2047) und 12 Bit (0 - 4095) bestimmt wer­den. Die Stan­dard­ein­stel­lung ist 12 Bit. Die Anwei­sung ana­logRe­ad­Re­so­lu­ti­on() beein­flusst den ADC-Wandler.

Bei­spiel:

void setup() 
{
  Serial.begin(9600);
  analogReadResolution(10);
}

void loop() 
{
  Serial.println("ADC-Wert: " + String(analogRead(35)));
  delay(200);
}

Ana­lo­ge Pins

D0 (A0)
D1 (A1)
D2 (A2)

Bei­spiel:
Poten­tio­me­ter an Pin D0 (A0)

// Potentiometer an Pin D0
int Potentiometer = D0; // A0

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

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

Blue­tooth BLE

Das Pro­gramm

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

Das Pro­gramm schal­tet eine LED an Pin D10:
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 D10
int LED = D10;

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

Smart­phone-Apps

ESP32 BLE Terminal

BLE Ter­mi­nal

Blue­tooth­LE

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 XIAO-ESP32-C3 angezeigt.

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

Cli­ent-Metho­de

#include "WiFi.h"

char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";

WiFiServer Server(80);
WiFiClient Client;

// Minimum und Maximum der Zufallszahlen
int Minimum = 1;
int Maximum = 49;

// statischeIP = false -> IP-Adresse über DHCP vergeben
// statischeIP = true -> statische IP festlegen
bool statischeIP = false;

// ip und gateway müssen an das lokale Netz angepasst werden
IPAddress ip(192, 168, 1, 100);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

void setup() 
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);

  // WiFi starten
  WiFi.begin(Router, Passwort);

 // statische IP vergeben
  if (statischeIP) 
  {
    WiFi.config(ip, gateway, subnet); 
    Serial.print("Verbunden mit ");
    Serial.println(Router);

    // IP anzeigen
    Serial.print("Statische IP: ");
    Serial.println(ip);
  }

  // IP über DHCP ermitteln
  else
  {
    while (WiFi.status() != WL_CONNECTED) 
    {
      delay(200);
      Serial.print(".");
    }
    Serial.println();
    Serial.print("Verbunden mit ");
    Serial.println(Router);
    Serial.print("IP über DHCP: ");
    Serial.println(WiFi.localIP());
  }

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

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

Server.on -Metho­de

#include "WiFi.h"
#include "WebServer.h"

// SSID und Passwort des Routers
char Router[] = "Router_SSID";
char Passwort[] = "xxxxxxxx";

WebServer Server(80);

// Minimum und Maximum der Zufallszahlen
int Minimum = 1;
int Maximum = 49;

// statischeIP = false -> IP-Adresse über DHCP vergeben
// statischeIP = true -> statische IP festlegen
bool statischeIP = false;

// ip und gateway müssen an das lokale Netz angepasst werden
IPAddress ip(192, 168, 1, 100);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

void setup() 
{
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(1000);

  // WiFi starten
  WiFi.begin(Router, Passwort);

  // statische IP vergeben
  if (statischeIP) 
  {
    WiFi.config(ip, gateway, subnet); 
    Serial.print("Verbunden mit ");
    Serial.println(Router);

    // IP anzeigen
    Serial.print("Statische IP: ");
  }

  // IP über DHCP ermitteln
  else
  {
    while (WiFi.status() != WL_CONNECTED) 
    {
      delay(200);
      Serial.print(".");
    }
    Serial.println();
    Serial.print("Verbunden mit ");
    Serial.println(Router);
    Serial.print("IP über DHCP: ");
  }

  // IP anzeigen
  Serial.println(WiFi.localIP());

  // Zufallsgenerator mit dem Signal an A0 starten
  randomSeed(analogRead(A0));

  Server.begin();
  Server.on("/", SeiteBauen);
}

void loop() 
{
  Server.handleClient();
}

void SeiteBauen() 
{
  // Seite zusammenbauen
  // Kopf der HTML-Seite: aktualisierung alle 60 Sekunden
  // kann angepasst werden
  String Nachricht = "<head><meta http-equiv=\"refresh\" content=\"60\"></head>";
  Nachricht += "<h1>Zufallszahlen</h1>";
  Nachricht += "<hr>";

  // Zufallszahlen anzeigen
  for (int i = 0; i < 7; i++) 
  {
    int Zahl = random(Minimum, Maximum);
    Nachricht += String(Zahl) + " ";
  }

  Nachricht += "<hr>";

  // Nachricht senden -> Seite anzeigen
  Server.send(200, "text/html", Nachricht);
}

WiFi-Daten auf dem ESP32 speichern

Pro­ble­me beim Hochladen

Der Port des XIAO-ESP32-C3 wird nicht erkannt:

Reset-But­ton bei ver­bun­de­nem USB-Kabel drücken

Wenn das nicht hilft:

USB-Kabel tren­nen, Boot-But­ton drü­cken und USB-Kabel verbinden

Quel­le: 🔗https://​wiki​.see​ed​stu​dio​.com/​X​I​A​O​_​E​S​P​3​2​C​3​_​G​e​t​t​i​n​g​_​S​t​a​r​ted (abge­ru­fen am 07.10.24)


Letzte Aktualisierung: 18. Okt 2024 @ 6:59