Espressif ESP32-C3-AWS-ExpressLink-DevKit: Seamless Cloud Connectivity for IoT Developers

Explore the Espressif ESP32-C3-AWS-ExpressLink-DevKit—an IoT development board with built-in AWS IoT ExpressLink support. Discover how to simplify secure cloud connectivity for smart devices using this compact, RISC-V-based Wi-Fi and Bluetooth module.

In einem früheren Beitrag habe ich mit der Arduino-gestützten Eieruhr bereits eine flexible Countdown-Anzeige mit akustischem Alarm vorgestellt. Die ursprüngliche Version, die ich auf meinem Blog unter diesem Link veröffentlicht habe, basierte auf einem klassischen Arduino. Doch nun wird es Zeit für ein Upgrade: Der ESP32-C3 Mini bietet nicht nur mehr Leistung mit seinen 160 MHz, sondern bringt auch WiFi- und Bluetooth-Konnektivität mit – und das in einem äußerst kompakten Format. https://youtu.be/5CGeBJfi6Gc Die Portierung der bestehenden Arduino-Schaltung auf den ESP32-C3 Mini war erstaunlich einfach, da dieser ebenfalls in der Arduino IDE programmiert werden kann. Der eigentliche Fokus lag jedoch darauf, die Schaltung auf eine eigene Platine (PCB) zu bringen, um sie für ein bevorstehendes Event im JFZ Schöningen einsatzbereit zu machen.

In diesem Beitrag zeige ich, wie die Timerschaltung mit dem ESP32-C3 Mini realisiert wurde, welche Anpassungen notwendig waren und wie die finale Version als fertige Platine umgesetzt wurde.

Warum der ESP32-C3 Mini besser als ein Arduino ist

Zunächst einpaar Gründe warum der ESP32-C3 Mini besser als ein Arduino ist: ✔ WiFi & Bluetooth integriert – Kein extra Modul nötig, ideal für IoT. ✔ Mehr Leistung & Speicher – 160 MHz, 384 KB RAM vs. 16 MHz, 2 KB RAM beim Arduino. ✔ Energieeffizient – Sleep-Modi für geringen Stromverbrauch. ✔ Vielseitigere GPIOs – Mehr analoge Eingänge, PWM, SPI, I2C, UART gleichzeitig nutzbar. ✔ Moderne Programmierung – Neben der Arduino IDE auch MicroPython & ESP-IDF unterstützt.

ESP32-C3 Super Mini

Benötigte Bauteile für die Timerschaltung

Für den Aufbau der Schaltung werden folgende Komponenten benötigt. Diese ermöglichen eine einfache Umsetzung und sind flexibel auf einem 800-Pin-Breadboard testbar. - 1x ESP32-C3 Mini – Der Mikrocontroller als Steuerzentrale - 4x Taster mit Köpfen – Zur Steuerung der Timer-Funktionen - 1x 3mm LED mit 220-Ohm-Vorwiderstand – Statusanzeige - 2x 5mm LED mit 220-Ohm-Vorwiderstand – Visuelles Feedback beim Alarm - 2x Piezo-Buzzer – Akustischer Signalgeber - diverse Breadboardkabel – Zur Verbindung der Komponenten - 1x 800-Pin-Breadboard – Für eine flexible Verdrahtung Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Timerschaltung am Schaltung am ESP32-C3 Mini im Detail

Nachfolgend die Timerschaltung am ESP32-C3 auf einem Breadboard.

ESP32-C3 Mini - Countdown Schaltung Bauteil / PinESP32-C3 Mini4fach 7 SegmentanzeigeCLK > 3 (GPIO3) SDA > 4 (GPIO4) GND > GND VCC > 5VTaster - Start / Stopp5 (GPIO5)Taster - Plus6 (GPIO6)Taster - Minus7 (GPIO7)Taster - Select8 (GPIO8)LED 120 (GPIO20)LED 221 (GPIO21)Status LED9 (GPIO9)Piezo Buzzer - links10 (GPIO10)Piezo Buzzer - rechts2 (GPIO2) Pinout des ESP32-C3 Mini Nachfolgend findest du den Aufbau des ESP32-C3 Mini, der dir hilft, die richtigen Pins für deine Schaltung schneller und einfacher zu identifizieren. Eine klare Übersicht der GPIO-Belegung erleichtert die Verdrahtung und reduziert Fehler beim Anschluss der Komponenten.

ESP32-C3 Pinout Falls du spezielle Funktionen wie PWM, I2C, SPI oder UART nutzen möchtest, lohnt sich ein Blick auf die multiplen Belegungsmöglichkeiten der Pins. Unterschiedliche - 4fach 7Segmentanzeigen Es gibt verschiedene Arten von 7-Segment-Anzeigen auf dem Markt. Einerseits gibt es kompakte, einfache Modelle, andererseits größere Varianten mit farbigen Segmenten. Für dieses Projekt entscheide ich mich für die größere Version, da sie nicht nur besser lesbar ist, sondern durch die unterschiedlichen Farben auch optisch ansprechender wirkt und das Projekt aufwertet.

Ausbau einer LED In der Schaltung kommen drei LEDs zum Einsatz, die sich durch ihre hohe Leuchtkraft und lange Lebensdauer auszeichnen. Sie dienen nicht nur als Statusanzeige, sondern ermöglichen auch eine visuelle Rückmeldung über den aktuellen Betriebszustand der Timerschaltung. Die LEDs werden über einen GPIO-Pin des ESP32-C3 Mini angesteuert und mit einem 220-Ohm-Vorwiderstand in Reihe geschaltet, um den Stromfluss zu begrenzen und die Lebensdauer der LEDs zu erhöhen. Durch diese Beschaltung ist sichergestellt, dass die LEDs effizient betrieben werden, ohne den Mikrocontroller zu überlasten. Beim Einbau einer LED ist darauf zu achten, dass sie richtig gepolt angeschlossen wird. Die Kathode (Minuspol) wird mit dem Vorwiderstand verbunden, der anschließend an GND führt. Die Anode (Pluspol) hingegen wird direkt mit dem entsprechenden GPIO-Pin des ESP32-C3 Mini verbunden. Eselsbrücke: Die Kathode erkennt man am kürzeren Bein der LED.

Aufbau einer LED Falls du mehr über die Funktionsweise und den Anschluss von LEDs erfahren möchtest, findest du eine detaillierte Erklärung auf der Seite "Bauteile: Leuchtdiode (LED)", wo ich dieses Bauteil ausführlich vorstelle.

Programmieren in der Arduino IDE

Wie bereits erwähnt, habe ich dieses kleine Projekt zuvor für den Arduino entwickelt und programmiert. Dadurch war die Portierung auf den ESP32-C3 Mini relativ unkompliziert – es mussten lediglich die Pinbelegungen angepasst werden. Eine zusätzliche Optimierung bestand darin, die Start- und Stopp-Funktion auf einen einzigen Taster zu legen, anstatt zwei separate Taster zu verwenden. Dadurch spart man nicht nur einen GPIO-Pin, sondern macht die Bedienung auch kompakter und effizienter. Dies ist besonders vorteilhaft, da der ESP32-C3 Mini im Vergleich zu einem klassischen Arduino weniger verfügbare GPIOs hat. Programm: Timerschaltung am ESP32-C3 Mini in der Arduino IDEHerunterladen fertiges Programm für eine Timerschaltung am ESP32-C3 Mini /* * Autor: Stefan Draeger * Webseite: https://draeger-it.blog * Beitrag: https://draeger-it.blog/esp32-c3-mini-die-perfekte-basis-fuer-eine-moderne-timerschaltung/ * * Beschreibung: * Diese Firmware steuert eine Timerschaltung mit einer 7-Segment-Anzeige (TM1637), * Tastern zur Zeiteinstellung, LEDs zur Statusanzeige und einem akustischen Alarm über einen Buzzer. * Die Zeit kann in Sekunden oder Minuten eingestellt und per Start/Stopp-Taste gesteuert werden. * * Funktionen: * - Anzeige der verbleibenden Zeit auf einer TM1637 7-Segment-Anzeige * - Steuerung der Zeit über Taster (Erhöhung/Verringerung in Sekunden oder Minuten) * - Akustischer Alarm nach Ablauf des Timers mit abwechselnden LED-Signalen * - Speicherung und Aktualisierung des Timers in der Loop * - Start/Stopp-Funktion für den Timer */ #include // Bibliothek für 7-Segment-Anzeige TM1637 #include // Bibliothek für die Taster-Entprellung // Definition der LED-Pins #define led1 20 #define led2 21 // Definition der Pins für die 7-Segment-Anzeige (TM1637) #define segmentanzeige_CLK 3 #define segmentanzeige_DIO 4 TM1637Display display(segmentanzeige_CLK, segmentanzeige_DIO); // Anzeige-Objekt erstellen // Definition der Taster-Pins #define tasterStartStopp 5 #define tasterPlus 6 #define tasterMinus 7 #define tasterSelect 8 // Taster-Objekte für die Entprellung Bounce bceTasterStartStopp = Bounce(); Bounce bceTasterPlus = Bounce(); Bounce bceTasterMinus = Bounce(); Bounce bceTasterSelect = Bounce(); // Definition der Pins für Buzzer und Status-LED #define buzzerLeft 10 #define buzzerRight 2 #define statusLed 9 // Variablen für die Timer-Logik unsigned int timeAuswahl = 0; // Auswahlmodus für Zeit (Sekunden/Minuten) unsigned int seconds = 0; // Aktuelle Zeit in Sekunden const unsigned int PAUSE = 1000; // Zeitintervall für Timer-Update (1 Sekunde) const unsigned int PAUSE_ALARM = 250; // Zeitintervall für Alarmton unsigned long lastAction = 1L; // Zeitstempel für letzte Aktion bool clockStarted = false; // Timer läuft oder nicht bool clockAlarm = false; // Alarmstatus bool lastStateLED = false; // Zustand der LEDs für Alarm void setup() { // Setzt die Pin-Modi für LEDs, Buzzer und Status-LED pinMode(led1, OUTPUT); pinMode(led2, OUTPUT); pinMode(buzzerLeft, OUTPUT); pinMode(buzzerRight, OUTPUT); pinMode(statusLed, OUTPUT); // Helligkeit der 7-Segment-Anzeige einstellen (0-7, hier maximale Helligkeit) display.setBrightness(7); // Anzeige mit allen Segmenten aktivieren (zum Test) uint8_t data = { 0xff, 0xff, 0xff, 0xff }; display.setSegments(data); // Taster mit Pullup-Widerständen initialisieren und Entprellzeit setzen bceTasterStartStopp.attach(tasterStartStopp, INPUT_PULLUP); bceTasterStartStopp.interval(5); bceTasterPlus.attach(tasterPlus, INPUT_PULLUP); bceTasterPlus.interval(5); bceTasterMinus.attach(tasterMinus, INPUT_PULLUP); bceTasterMinus.interval(5); bceTasterSelect.attach(tasterSelect, INPUT_PULLUP); bceTasterSelect.interval(5); // LEDs und Status-LED ausschalten digitalWrite(led1, LOW); digitalWrite(led2, LOW); digitalWrite(statusLed, LOW); displayTime(); // Startanzeige aktualisieren } // Zeigt die aktuelle Zeit auf der 7-Segment-Anzeige an void displayTime() { int minutes = seconds / 60; // Maximale Anzeige auf 99 Minuten begrenzen if (minutes > 99) { minutes = 99; } // Anzeige im Format MM:SS int fourDigitValue = (minutes * 100) + (seconds % 60); display.showNumberDecEx(fourDigitValue, 0b01000000, true, 4, 4); } // Reduziert die verbleibende Zeit um eine Sekunde void incrementTime() { unsigned long currentMillis = millis(); if ((lastAction + PAUSE) lastAction = currentMillis; if (seconds > 0) { seconds--; // Eine Sekunde abziehen if (seconds == 0) { clockAlarm = true; // Timer abgelaufen, Alarm aktivieren } } } displayTime(); } // Spielt einen akustischen Alarm ab und wechselt die LEDs void playAlarm() { unsigned long currentMillis = millis(); if ((lastAction + PAUSE_ALARM) lastAction = currentMillis; // Wechselton für den Alarm (zwei verschiedene Frequenzen) if (lastStateLED) { noTone(buzzerRight); tone(buzzerLeft, 1400); } else { noTone(buzzerLeft); tone(buzzerRight, 700, 175); } // LED-Zustand ändern, um visuelles Signal zu erzeugen digitalWrite(led1, lastStateLED); digitalWrite(led2, !lastStateLED); lastStateLED = !lastStateLED; } } void loop() { // Taster-Status aktualisieren bceTasterPlus.update(); bceTasterMinus.update(); bceTasterSelect.update(); // Wenn der Timer nicht läuft, kann die Zeit eingestellt werden if (!clockStarted) { bool buttonPressed = false; // Umschalten zwischen Sekunden- und Minutenmodus if (bceTasterSelect.fell()) { timeAuswahl = (timeAuswahl == 0) ? 1 : 0; } // Zeit erhöhen if (bceTasterPlus.fell()) { buttonPressed = true; if (timeAuswahl == 0) { seconds++; } else { seconds += 60; } } // Zeit verringern, falls Sekunden > 0 sind if (bceTasterMinus.fell() && seconds > 0) { buttonPressed = true; if (timeAuswahl == 0) { seconds--; } else { seconds -= 60; } } // Anzeige aktualisieren, falls sich die Zeit geändert hat if (buttonPressed) { displayTime(); } } // Falls der Timer läuft und der Alarm noch nicht aktiv ist, Zeit herunterzählen else if (clockStarted && !clockAlarm) { incrementTime(); } if (clockStarted && clockAlarm) { playAlarm(); } // Start/Stopp-Taster auslesen bceTasterStartStopp.update(); // Timer starten oder stoppen if (bceTasterStartStopp.fell()) { clockStarted = !clockStarted; clockAlarm = false; digitalWrite(statusLed, clockStarted); // LEDs zurücksetzen digitalWrite(led1, LOW); digitalWrite(led2, LOW); noTone(buzzerRight); noTone(buzzerLeft); } }

Aufbau der Schaltung mit EasyEDA

Die Platine habe ich in der Online Version von EasyEDA entwickelt, durch die große Bibliothek welche vom Hersteller und der Community gepflegt wird ist diese meine erste Wahl.

Das Hintergrundbild also quasi den "Wecker" habe ich mir recht günstig bei Etsy.com gekauft und somit sogar noch einen anderen Creator mit diesem Projekt unterstützt ;).

Ausblick

Der ESP32-C3 Mini ist ein leistungsstarker Mikrocontroller mit integriertem Wi-Fi und Bluetooth, ideal für energieeffiziente IoT-Projekte. Doch gerade in batteriebetriebenen Anwendungen ist es entscheidend, den Stromverbrauch so gering wie möglich zu halten. Eine effektive Methode dafür ist der Deep Sleep Modus, in dem der ESP32-C3 Mini nur minimal Energie verbraucht und dennoch jederzeit aufwachen kann. https://youtu.be/qS03yO8yFQg In diesem Beitrag zeige ich dir, wie du den ESP32-C3 Mini in den Deep Sleep versetzt und mit zwei verschiedenen Methoden wieder aufweckst: - Per Taster und Interrupt-Pin – Eine praktische Lösung, um den Mikrocontroller durch eine externe Eingabe zu aktivieren. - Per Timer – Hier wacht der ESP32-C3 Mini nach einer voreingestellten Zeit automatisch auf. Mit diesen Techniken kannst du die Akkulaufzeit deines Projekts erheblich verlängern, ohne auf wichtige Funktionen zu verzichten. Los geht’s!

ESP32-C3 mit LED

ESP32-C3 mit Taster und LED

Deep Sleep für stromsparenden Einsatz der Schaltung am ESP32

Der ESP32 kann ganz einfach in den Tiefschlaf-Modus (Deep Sleep) versetzt werden, um Strom zu sparen. Dabei gibt es verschiedene Möglichkeiten, ihn wieder aufzuwecken: - Per Timer – Der Mikrocontroller wird nach einer bestimmten Zeit automatisch aufgeweckt, führt eine definierte Aufgabe aus und geht anschließend selbstständig wieder in den Tiefschlaf. - Per Interrupt-Pin – Der Mikrocontroller wacht auf, sobald ein externes Signal (z. B. ein Taster oder Sensor) den Interrupt auslöst. Aufwecken aus dem Deep Sleep via Timer Dieses Beispiel zeigt, wie ein ESP32-C3 in einem Intervall von 5 Sekunden aufwacht, eine LED aktiviert und dann wieder in den Tiefschlaf (Deep Sleep) geht. Funktionsweise: - Der ESP32 wacht alle 5 Sekunden auf. - Er aktiviert eine LED für 250 Millisekunden. - Anschließend wird die Anzahl der Boot-Zyklen gezählt und ausgegeben. - Danach geht der ESP32 wieder in den Tiefschlaf.

ESP32-C3 mit LED

Schaltung: ESP32-C3 Mini mit LED Quellcode /* Autor: Stefan Draeger Webseite: https://draeger-it.blog Beschreibung: Dieses Beispiel zeigt, wie ein ESP32-C3 in einem Intervall von 5 Sekunden aufwacht, eine LED aktiviert und dann wieder in den Tiefschlaf (Deep Sleep) geht. Funktionsweise: - Der ESP32 wacht alle 5 Sekunden auf. - Er aktiviert eine LED für 250 Millisekunden. - Anschließend wird die Anzahl der Boot-Zyklen gezählt und ausgegeben. - Danach geht der ESP32 wieder in den Tiefschlaf. */ // Umrechnungsfaktor für Mikrosekunden zu Sekunden #define uS_TO_S_FACTOR 1000000ULL // 1 Sekunde = 1.000.000 Mikrosekunden #define TIME_TO_SLEEP 5 // Zeitspanne des Tiefschlafs in Sekunden // LED-Pin Definition #define led 4 // Die LED ist mit GPIO4 verbunden // Speichert die Anzahl der Boot-Zyklen im RTC-Speicher (bleibt beim Deep Sleep erhalten) RTC_DATA_ATTR int bootCount = 0; void setup() { Serial.begin(115200); // Startet die serielle Kommunikation mit 115200 Baud delay(1000); // Kurze Wartezeit zur Stabilisierung pinMode(led, OUTPUT); // Setzt den LED-Pin als Ausgang // LED für 250 Millisekunden aktivieren digitalWrite(led, HIGH); delay(250); // Kurze Verzögerung, um das Blinken sichtbar zu machen // Boot-Zähler erhöhen und ausgeben ++bootCount; Serial.println("Start: #" + String(bootCount)); // Konfigurieren des Timers für den Tiefschlaf esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); Serial.println("Der ESP32 geht nun für " + String(TIME_TO_SLEEP) + " Sekunden schlafen!"); Serial.println("Gute Nacht!"); Serial.flush(); // Wartet darauf, dass die serielle Ausgabe abgeschlossen ist // Tiefschlafmodus aktivieren esp_deep_sleep_start(); // Diese Zeile wird nie erreicht, da der ESP32 in den Tiefschlaf geht Serial.println("!!Diese Ausgabe wird nie erscheinen!!"); } void loop() { // Die Loop-Funktion bleibt leer, da der ESP32 immer wieder in den Tiefschlaf geht. } Aufwecken aus dem Deep Sleep via Interrupt Pin Dieses Programm nutzt einen Taster, um den ESP32-C3 aus dem Deep Sleep zu wecken. Nach dem Aufwachen blinkt eine LED 10 Mal, während ein Indexwert über die serielle Schnittstelle ausgegeben wird. Danach geht der ESP32 wieder in den Tiefschlaf, bis der Taster erneut gedrückt wird. Hardware: - Der Taster ist an GPIO2 angeschlossen. - Die LED ist an GPIO4 angeschlossen. - Der ESP32 geht in den Tiefschlaf und wird durch den Taster wieder aktiviert.

ESP32-C3 mit Taster und LED

I got some ESP32-C3 dev boards with built-in OLED screens for a Halloween costume project, and I've been troubled by the lack of documentation and general information about both the ESP32-C3 platform and the board, so here are some notes for future hackers:

OLED type is SH1106, not SSD1306, as seen in some forum posts and even in the blurry screenshot that accompanies these boards. Specifically, the U8G2 constructor for this board is U8G2_SH1106_72X40_WISE_F_HW_I2C(). With the SSD1306 driver, the screen pixels are shifted to the left and there's a column or two of corrupted data on the right-hand-side of the OLED screen.

Apparently the ESP32-C3 chip cannot measure its supply voltage internally, something that even ATtiny chips can do :(

Proper Arduino configuration is:

(CPU frequency and partition setup are of course configurable).

I'm not sure yet if I2C is actually hardware-offloaded here, but the pins are apparently non-default, with SDA=5, SCL=6. At least the display speed doesn't change at all when changing the I2C frequency. I don't have the equipment to measure this, but so far it looks like I2C clock speed is ignored. Anyway, I can get about 73 FPS, or about 11ms per frame draw on the built-in 72x40 OLED.

But overall, looks like a nice dev board, and it's neat that it's powered by a RISC-V microcontroller. Perfect for hobby projects that don't need many pins.

Der Super Mini ESP32-C3 ist ein leistungsstarker Mikrocontroller im Miniformat, der sich perfekt für platzsparende Projekte eignet. Mit seinem 32-Bit-RISC-V-Prozessor, integrierter WiFi- und Bluetooth 5.0-Konnektivität sowie einer Vielzahl von digitalen und analogen I/O-Pins bietet er eine flexible Grundlage für IoT- und Smart-Home-Anwendungen. In diesem Beitrag stelle ich dir die technischen Spezifikationen des ESP32-C3 vor und zeige, warum dieser kompakte Mikrocontroller eine ausgezeichnete Wahl für Entwickler und Bastler ist, die Leistung auf kleinstem Raum benötigen. https://youtu.be/tza4NTj7xgM Der Mikrocontroller wurde von mir für knapp 3 € zzgl. Versandkosten auf Aliexpress erworben. Für einen Mikrocontroller mit einem ESP32-Chip ist das ein äußerst angemessener Preis, besonders angesichts der gebotenen Funktionen und Konnektivitätsoptionen.

Technische Daten des Super Mini ESP32-C3

Der Super Mini ESP32-C3 bietet trotz seiner kompakten Abmessungen eine beeindruckende Leistung. Dank des leistungsstarken 32-Bit-RISC-V-Prozessors, umfangreichen Speicheroptionen und vielseitigen Kommunikationsschnittstellen eignet er sich besonders für IoT-Projekte und andere platzsparende Anwendungen. Die folgende Tabelle fasst die wichtigsten technischen Spezifikationen zusammen: EigenschaftDetailsProzessorESP32-C3, 32-Bit-RISC-V, 160 MHzSpeicher400 KB SRAM, 384 KB ROMFlash-Speicher4 MBDigitale I/O-Pins11, mit PWM-UnterstützungAnaloge I/O-Pins4, 12-Bit-SARADC, 6 KanäleKommunikationWiFi 802.11b/g/n, Bluetooth 5.0, I2C, SPI, 2xUARTSpannungsbereich3,3 bis 6 VAbmessungen22,52 x 18 mm Diese Übersicht verdeutlicht, dass der ESP32-C3 eine solide Grundlage für vielfältige elektronische Projekte darstellt. Pinout des Super Mini ESP32-C3 Nachfolgend das Pinout des Mikrocontrollers:

ESP32-C3 Pinout

Erweiterungsboard für den Super Mini ESP32-C3: Mehr Anschlussmöglichkeiten und autarker Betrieb

Zusätzlich zum Super Mini ESP32-C3 gibt es ein praktisches Erweiterungsboard, auf das der Mikrocontroller gesteckt werden kann. Über dieses Board lassen sich die digitalen I/Os bequem abgreifen, und es bietet die Möglichkeit, Servomotoren direkt anzuschließen. Darüber hinaus ist eine Schnittstelle für eine LiPo-Batterie vorhanden, sodass die gesamte Schaltung auch unabhängig von einer externen Stromquelle betrieben werden kann. Dieses Erweiterungsboard macht den Mikrocontroller noch vielseitiger und besonders geeignet für mobile oder autarke Projekte.

ESP32-C3 mit LiPo Batterie

Programmierung des Super Mini ESP32-C3: Einfache Anleitung mit der Arduino IDE

Der Super Mini ESP32-C3 kann in verschiedenen Entwicklungsumgebungen programmiert werden, darunter Arduino IDE, PlatformIO, Espressif und Visual Studio Code. Jede dieser Umgebungen bietet ihre eigenen Vorteile und Tools, um Projekte zu entwickeln und zu verwalten. Für Einsteiger und alle, die schnell Ergebnisse sehen wollen, bleibt die Arduino IDE jedoch die einfachste und zugänglichste Option. In diesem Abschnitt zeige ich dir, wie du den Mikrocontroller in der Arduino IDE programmierst und die Grundlagen für dein erstes Projekt legst.

klassische Arduino IDE - Version 1.8.19

Arduino IDE 2.3.3 mit neuen Features und Updates Von der Arduino IDE gibt es sowohl die klassische Version als auch die neue 2.x Version, die kontinuierlich weiterentwickelt wird. Für die meisten grundlegenden Arbeiten reicht die klassische Version aus, da sie einfach zu bedienen und funktionsfähig ist. Dennoch empfehle ich, die neue Version zu verwenden, da sie eine verbesserte Benutzeroberfläche und zusätzliche Funktionen bietet, die die Programmierung erleichtern und effizienter gestalten. Die neuen Features unterstützen dich dabei, schneller und einfacher mit deinen Projekten voranzukommen. Einrichten des Mikrocontrollers in der Arduino IDE Bevor wir mit der Programmierung beginnen können, müssen wir den Boardtreiber installieren. Den Boardtreiber können wir jedoch erst installieren, wenn wir die nachfolgende Zeile unter den "Zusätzlichen Boardverwalter URLs" hinzugefügt haben. https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Wenn die URL hinzugefügt wurde, dann können wir im Boardverwalter nach ESP32 oder genauer ESP32-C3 suchen. Es sollte dann der Eintrag "esp32 von Espressif Systems" angezeigt werden, wo wird die Schaltfläche INSTALLIEREN finden. (In meinem Fall steht dort ENTFERNEN, da ich diese bereits installiert habe.)

Beispiel - Ansteuern von LEDs Starten wir mit einem wirklich einfachen Beispiel, dem Ansteuern von Leuchtdioden. Der Mikrocontroller verfügt selber über eine kleine, blaue SMD LED am GPIO8 welche wir ansteuern können. //interne BUILTIN LED am GPIO8 angeschlossen #define led 8 void setup() { //definieren das der Pin der LED als Ausgang dient pinMode(led, OUTPUT); } void loop() { //aktivieren der LED digitalWrite(led, HIGH); //eine kleine Pause von 500 Millisekunden delay(500); //deaktivieren der LED digitalWrite(led, LOW); //eine kleine Pause von 500 Millisekunden delay(500); } Der obige Code bewirkt lediglich, dass die kleine LED im Takt von 500 Millisekunden blinkt. Das kleine Programm können wir auch einfach ändern und um weitere LEDs erweitern.

Vorstellung des Super Mini Arduino Nano Clone

Am Ende dieses Beitrags möchte ich einen weiteren kleinen Mikrocontroller vorstellen: den "Super Mini Arduino Nano Clone". Dieser Mikrocontroller hat ähnliche Abmessungen wie der ESP32-C3 und bietet eine vergleichbare Anzahl von Pins, jedoch mit einigen zusätzlichen Features. Der Super Mini Arduino Nano Clone arbeitet mit einer Taktfrequenz von 16 MHz und verfügt über 32 kB Speicher.