ESP32-C3 Zero

Inhalt

Der ESP32-C3 Zero hat ins­ge­samt 18 Pins, 3 die­nen der Strom­ver­sor­gung, es blei­ben 15 Pins, die mehr­fach belegt sind.
Er ver­fügt über Blue­tooth und WiFi.

Board instal­lie­ren

Tra­ge unter Datei -> Ein­stel­lun­gen eine zusätz­li­che Board­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 ESP32 suchen
  • Board instal­lie­ren

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

Seri­el­len Moni­tor einschalten

Der Seri­el­le Moni­tor steht erst nach einer Ände­rung der Kon­fi­gu­ra­ti­on zur Verfügung:

RGB-LED

Auf dem Board ist eine RGB-LED ver­baut, sie kann mit Hil­fe einer Biblio­thek ange­spro­chen werden.

#include "Adafruit_NeoPixel.h"

#define RGBLED 10
#define AnzahlLED 1

// RGB -> Name der RGB-LED
Adafruit_NeoPixel RGB(AnzahlLED, RGBLED, NEO_GRB + NEO_KHZ800);

void setup()
{
  // setBrightness(0..255)
  RGB.setBrightness(200);

  // NeoPixel Bibliothek initialisieren
  RGB.begin();
}

void loop()
{ 
  // rot
  RGB.fill(RGB.Color(255, 0, 0), 0, AnzahlLED);
  RGB.show();
  delay(1000);
  
  // grün
  RGB.fill(RGB.Color(0, 255, 0), 0, AnzahlLED);
  RGB.show();
  delay(1000);

  // blau
  RGB.fill(RGB.Color(0, 0, 255), 0, AnzahlLED);
  RGB.show();
  delay(1000);

  // gelb
  RGB.fill(RGB.Color(255, 255, 0), 0, AnzahlLED);
  RGB.show();
  delay(1000);

  RGB.clear();
}

Pin­be­le­gung

I²C

⇒Info

I²C-Pins

9 -> SCL
8 -> SDA

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

⇒Info

SPI-Pins

4 -> SCK/CLK
5 -> CIPO (MISO)
7 -> CS
6 -> COPI (MOSI)

Bei­spiel: Anschluss eines run­den TFTs

gelb -> 3 (RST)
weiß -> 7 (CS)
grün -> 2 (DC)
blau -> 6 (SDA)
braun -> 4 (SCL)
schwarz -> GND
rot -> 5V
schwarz -> GND

Benö­tig­te Bibliothek

#include "Adafruit_GFX.h"
#include "Adafruit_GC9A01A.h"

#define TFT_RST      2
#define TFT_DC       3
#define TFT_CS       7

// Farben
#define SCHWARZ     0x0000
#define WEISS       0xFFFF
#define BLAU        0x001F
#define ROT         0xF800
#define GRUEN       0x07E0
#define CYAN        0x07FF
#define MAGENTA     0xF81F
#define GELB        0xFFE0
#define BRAUN       0x9A60
#define GRAU        0x7BEF
#define GRUENGELB   0xB7E0
#define DUNKELCYAN  0x03EF
#define ORANGE      0xFDA0
#define PINK        0xFE19
#define BORDEAUX    0xA000
#define HELLBLAU    0x867D
#define VIOLETT     0x915C
#define SILBER      0xC618
#define GOLD        0xFEA0

Adafruit_GC9A01A tft(TFT_CS, TFT_DC);

void setup()
{
  // Zufallsgenerator starten
  randomSeed(analogRead(A0));
  Serial.begin(9600);
  delay(500);
  Serial.println("Bildschirm: " + String(tft.height()) + " x " + String(tft.width()));

  // TFT starten
  tft.begin();

  // Rotation anpassen
  tft.setRotation(2);
 
  // schwarzer Hintergrund
  tft.fillScreen(SCHWARZ);

  // interne Textdarstellung
  tft.setTextSize(3);
  tft.setCursor(30, 50);
  tft.setTextColor(BLAU);
  tft.print("Text");
  delay(500);

  tft.setTextSize(4);
  tft.setCursor(30, 80);
  tft.setTextColor(GRUEN);
  tft.print("Text");
  delay(2000);

  // zufällige Pixel
  tft.fillScreen(SCHWARZ);
  for  (int i = 0; i < 700; i++)
  {
    int PixelX = random(1, tft.width());
    int PixelY = random(1, tft.height());
    tft.drawPixel(PixelX, PixelY, tft.color565(random(255),random(255),random(255)));
    delay(5);
  }
  delay(2000);

  // Kreise vom Mittelpunkt zeichnen
  tft.fillScreen(SCHWARZ);
  for (int i = 1; i < tft.width() / 2; i+=5)
  {
    tft.drawCircle(tft.width() / 2, tft.height() / 2, tft.width() / 2 - i, tft.color565(random(255),random(255),random(255)));
    delay(50);
  }
  delay(2000);

  for (int i = 1; i < tft.width() / 2; i+=5)
  {
    tft.drawCircle(tft.width() / 2, tft.height() / 2, tft.width() / 2 - i, SCHWARZ);
    delay(50);
  }
  delay(2000);

  // Kreise vom Mittelpunkt zeichnen
  tft.fillScreen(SCHWARZ);
  for (int i = 1; i < tft.width() / 2; i+=10)
  {
    tft.fillCircle(tft.width() / 2, tft.height() / 2, tft.width() / 2 - i, tft.color565(random(255),random(255),random(255)));
    delay(50);
  }
  delay(2000);

  /*
    alle 30° Linie vom Mittelpunkt zeichnen
    120 = Radius des TFTs (240/2)
    90 = PI/4 (Viertelkreis)
    DEG_TO_RAD (0.0174532925) -> Winkel in Bogenmaß umrechnen
    es ensteht ein Dreieck mit einem Rechten Winkel
    -> Winkelfunktionen sin/cos anwenden
  */
  tft.fillScreen(SCHWARZ);
  for (int i = 0; i < 360; i += 30) 
  {
    float PosX = cos((i - 90) * DEG_TO_RAD) * 120;
    float PosY = sin((i - 90) * DEG_TO_RAD) * 120;
    int PunktX = PosX + 120;
    int PunktY = PosY + 120;
    tft.drawLine(120, 120, PosX + 120, PosY + 120, WEISS);
  }
   delay(2000);
}

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

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

Ana­lo­ge Pins
0
1
2
3
4 (SPI)

Bei­spiel:

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

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

Zeit mit der Biblio­thek time.h anzeigen

ESP32-Mikro­con­trol­ler kön­nen mit der Stan­dard­bi­blio­thek Datum und Zeit anzeigen.

Bei­spiel: ⇒Anzei­ge von Datum und Zeit auf einem OLED-Display

#include "WiFi.h"
#include "time.h"

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

// NTP-Server aus dem Pool
#define Zeitserver "de.pool.ntp.org"

/*
  Liste der Zeitzonen
  https://github.com/nayarsystems/posix_tz_db/blob/master/zones.csv
  Zeitzone CET = Central European Time -1 -> 1 Stunde zurück
  CEST = Central European Summer Time von
  M3 = März, 5.0 = Sonntag 5. Woche, 02 = 2 Uhr
  bis M10 = Oktober, 5.0 = Sonntag 5. Woche 03 = 3 Uhr
*/
#define Zeitzone "CET-1CEST,M3.5.0/02,M10.5.0/03"

// time_t enthält die Anzahl der Sekunden seit dem 1.1.1970 0 Uhr
time_t aktuelleZeit;

/* 
  Struktur tm
  tm_hour -> Stunde: 0 bis 23
  tm_min -> Minuten: 0 bis 59
  tm_sec -> Sekunden 0 bis 59
  tm_mday -> Tag 1 bis 31
  tm_wday -> Wochentag (0 = Sonntag, 6 = Samstag)
  tm_mon -> Monat: 0 (Januar) bis 11 (Dezember)
  tm_year -> Jahre seit 1900
  tm_yday -> vergangene Tage seit 1. Januar des Jahres
  tm_isdst -> Wert > 0 = Sommerzeit (dst = daylight saving time)
*/
tm Zeit;
WiFiServer Server(80);
WiFiClient Client;

void setup() 
{
  // Zeitzone: Parameter für die zu ermittelnde Zeit
  configTzTime(Zeitzone, Zeitserver);

  Serial.begin(9600);

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

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

  Serial.println("------------------------");
  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());
}

void loop() 
{
  // aktuelle Zeit holen
  time(&aktuelleZeit);

  // localtime_r -> Zeit in die lokale Zeitzone setzen
  localtime_r(&aktuelleZeit, &Zeit);

  Serial.println("------------------------");

  // es kann bis zu 30 Sekunden dauern
  // bis die Zeit ermittelt wird
  // Name des Wochentages 0-6
  switch (Zeit.tm_wday)
  {
    case 0:
      Serial.print("Sonntag");
      break;
    case 1:
      Serial.print("Montag");
      break;   
   case 2:
      Serial.print("Dienstag");
      break;
   case 3:
      Serial.print("Mittwoch");
      break;
   case 4:
      Serial.print("Donnerstag");
      break;
   case 5:
      Serial.print("Freitag");
      break;
   case 6:
      Serial.print("Samstag");
      break;
  }

  Serial.print(",");
  if (Zeit.tm_mday < 10)  Serial.print("0");
  Serial.print(Zeit.tm_mday);
  Serial.print(".");

  // Monat: führende 0 ergänzen
  // Zählung beginnt mit 0 -> +1
  if ((Zeit.tm_mon + 1) < 10) Serial.print("0");

  Serial.print(Zeit.tm_mon + 1);
  Serial.print(".");

  // Anzahl Jahre seit 1900
  Serial.print(Zeit.tm_year + 1900);
  Serial.print(" ");

  // Stunde: wenn Stunde < 10 -> 0 davor setzen
  if (Zeit.tm_hour < 10) Serial.print("0");
  Serial.print(Zeit.tm_hour);
  Serial.print(":");

  // Minuten
  if (Zeit.tm_min < 10) Serial.print("0");
  Serial.print(Zeit.tm_min);
  Serial.print(":");

  // Sekunden
  if (Zeit.tm_sec < 10) Serial.print("0");
  Serial.print(Zeit.tm_sec);

  Serial.println();
  Serial.println("Tage seit dem 1.1. " + String(Zeit.tm_yday));

  // Normalzeit/Sommerzeit
  if(Zeit.tm_isdst > 0) Serial.println("MESZ = Mitteleuropäische Sommerzeit");
  else Serial.println("MEZ = Mitteleuropäische Zeit");
  delay(5000);
}

Web­ser­ver

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

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

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

Quel­len