
Den ESP32-C6 gibt es in verschiedenen Bauformen, das abgebildete Modell hat 32 Pins.
Er verfügt über Bluetooth und WiFi.
Die Hersteller führen die Anschlüsse des ESP32-C6 zu verschiedenen Stellen auf dem Board.

Board installieren
Trage unter Datei -> Einstellungen eine zusätzliche Boardverwalter-URL ein:
https://dl.espressif.com/dl/package_esp32_index.json

Board auswählen

- Icon für den Boardverwalter anklicken oder Werkzeuge-> Board -> Boardverwalter
- nach ESP32 suchen
- Board installieren
Wenn der ESP32C6 nicht automatisch erkannt wurde, klicke auf "Wähle ein anderes Board und einen anderen Port" und suche nach esp32c6. Je nach Betriebssystem wird der USB-Port eine andere Bezeichnung haben.

RGB-LED

Wenn du nur die weiße Farbe der RGB-LED verwenden willst, kannst du sie mit der Bezeichnung LED_BUILTIN ansprechen. .
void setup()
{
pinMode(LED_BUILTIN, OUTPUT);
}
void loop()
{
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Auf dem Board ist eine RGB-LED verbaut, sie kann mit Hilfe einer Bibliothek angesprochen werden.

#include "Adafruit_NeoPixel.h"
#define RGBLED 8
#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);
// pink
RGB.fill(RGB.Color(255, 20, 147), 0, AnzahlLED);
RGB.show();
delay(1000);
RGB.clear();
}
Pinbelegung
I2C-Bus
⇒Info

I2C-Pins
23 -> SDA
22 -> SCL
Beispiel: Anschluss eines LCD

So sieht es aus:

Das dazugehörige Programm:

Benötigte Bibliothek 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
21 -> SCK/CLK
20 -> CIPO/SDI
19 -> COPI/SDO
18 -> CS
Schaltplan mit Adafruit 1,8 Zoll TFT

schwarz -> GND
rot -> 3,3V
gelb -> 3
grün -> 2
weiß -> 18
blau -> 19
grau -> 21
rot -> 5V
Schaltplan mit 1,77 Zoll TFT

schwarz -> GND
rot (1) -> 3,3V
gelb (2) -> 18
grün (3) -> 2
weiß (4) -> 3
blau (4) -> 19
grau (6) -> 21
rot (7) -> 5V
schwarz (8) -> GND
Das Programm
// Bibliotheken einbinden
#include "Adafruit_GFX.h"
#include "Adafruit_ST7735.h"
/*
Adafruit TFT 1,8
SPI-Pins
--------------
CS: 18
COPI: 19
CIPO: 20 (nicht verwendet)
SCK: 21
--------------
*/
#define TFT_CS 18
#define TFT_RST 3
#define TFT_DC 2
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
}
Digitale Pins

Digitale Pins
links
4
5
6
7
1
8 (RGB)
10
11
2
3
rechts
15
23 (SDA)
22 (SCL)
21
19
18
9
13
12
Das Blinkprogramm an Pin 9
int LED = 9;
void setup()
{
pinMode(LED, OUTPUT);
}
void loop()
{
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite(LED, LOW);
delay(1000);
}
Analoge Pins
Die Auflösung des ADC-Wandlers kann zwischen 9-Bit (0 - 511), 10 Bit (0 - 1023), 11 Bit (0 - 2047) und 12 Bit (0 - 4095) Die Standardeinstellung ist 12 Bit. Die Anweisung analogReadResolution() beeinflusst den ADC-Wandler.
Beispiel:
void setup()
{
Serial.begin(9600);
analogReadResolution(10);
}
void loop()
{
Serial.println("ADC-Wert: " + String(analogRead(35)));
delay(200);
}

Analoge Pins
4
5
6
0
1
2
3
Beispiel:
Potentiometer an Pin 4
// Potentiometer an Pin 4
int Potentiometer = 4;
// 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

Mit analogReadMilliVolts kann der Wert in Millivolt gelesen werden.
Zeit mit der Bibliothek time.h anzeigen
ESP32-Mikrocontroller können mit der Standardbibliothek Datum und Zeit anzeigen.

Beispiel: ⇒Anzeige 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.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);
}
Webserver
Beispiel
Das Programm zeigt im Browser 6 Zufallszahlen an.
Im Seriellen Monitor wird die mit DHCP ermittelte IP des ESP32-C6 angezeigt.

Diese Adresse musst du in einem Browser deiner Wahl eingeben

Client-Methode
#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();
}
}
}
}
}
Server.on -Methode
#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);
}
Seriellen Monitor einschalten

Letzte Aktualisierung: