LearningFactoryBox

📦 FactoryBox – Der Guide für Deine Lernerfahrung

Willkommen! Dieser Guide hilft dir mit der FactoryBox und dem ESP32 als Microcontroller loszulegen

- ein nutzerfreundliches Setup mit LEDs, Tastern, Sensoren, Displays und fest verbundenen GPIO-Pins.

❇️ Einfach nur auf's Coden konzentrieren.

Wenn das Dein erstes Mal arbeiten mit Arduino, ESP32 und PlatformIO ist, empfehlen wir Dir, diesen Guide zunächst einmal vollständig durchzulesen um die Basics zu verstehen.
Aber auch wenn Du direkt eintauchst und loslegst, kannst du natürlich jederzeit hierhin zurückkommen, um etwas nachzuschlagen.

Erfahre mehr über das Konzept hinter der FactoryBox

Konzept von LearningFactoryBox

Du möchtest wissen, was du überhaupt mit der FactoryBox machen kannst?

Sie dir diese Programmier-Challenges
zur Inspiration an.

In diesem Guide lernst du

  • LEDs und Motoren zu kontrollieren
  • Sensoren auszulesen
  • Informationen auf Displays anzeigen
  • Deine eigenen kreativen Programm schreiben um die Box zum Leben zu erwecken

Wir werden das Arduino framework nutzen, zusammen mit PlatformIO (PIO) - einer gro

Die FactoryBox enthält nicht nur den ESP32 selbst, sondern auch einen I2C-GPIO-Erweiterungsmodul (MCP23018), der Dir zusätzliche Ein- und Ausgangspins bietet – ideal, um weitere LEDs oder Tasten anzuschließen, wenn die GPIOs des ESP32 nicht mehr ausreichen.

📝 Hinweis:
Dieser Guide wurde explizit für die FactoryBoxerstellt, die Beispiele und Erklärungen über targen sich jedoch genauso auf jedes andere ESP32- basierte Projekt.
Solltest Du ein anderes Setup nutzen - oder einfach lernen wollen, wie man mit dem ESP32 programmiert - dann wirst Du hier auch fündig.

Diser Guide ein Startpunkt für Dein experimentieren. Wenn du mit der Grundlagen vertraut bist, dann schaue doch mal in die Links und Hinweise zu fortgeschritteneren Themen rein.

Diese Listen sind zum Anklicken gedacht. Um sie zurückzusetzen, lade einfach die Seite neu.

Setup Checklist

0 / 6 completed
✅ All done!

Close-up Checklist

0 / 4 completed
✅ All done!

Hardware Informationen

Dieses Kapitel stellt den ESP32 als Mikrocontroller und seine Kernfunktionen vor. Dazu gibt eine Übersicht über die GPIO Pins und deren Funktionalitäten.

Triff das "Brain" der FactoryBox:

Hardware Overview

Der ESP32 ist ein kostengünstiger Mikrocontroller mit extrem geringem Stromverbrauch, der über integriertes WLAN und Dual-Mode-Bluetooth verfügt. Er eignet sich für eine Vielzahl von Anwendungen – von Sensornetzwerken mit geringem Stromverbrauch bis hin zu Sprachcodierung, Musik-Streaming und MP3-Decodierung. Der ESP32 ist der Nachfolger des ESP8266 und wird von Espressif Systems hergestellt.

Haupt-Markmale

  • Dual-core 32-bit processor (up to 240 MHz)
  • 520 KB SRAM (Static RAM, for variables and data)
  • Built-in Wi-Fi and Bluetooth (Classic + BLE)
  • Zahlreiche GPIOs mit Unterstützung für PWM, ADC, DAC, SPI, I2C, UART und mehr
  • Tiefschlafmodus zur Energieeinsparung

In der Regel verwendest Du ein Entwicklungsboard mit einem ESP32-Chip, das über einen USB-Seriell-Wandler, einen Spannungsregler und Stiftleisten verfügt. Das Entwicklungsboard für dieses Projekt ist mit dem ESP-WROOM-32-Modul ausgestattet.

Um die Anzahl der verfügbaren GPIOs zu erweitern, enthält die FactoryBox außerdem einen MCP23018 I2C-GPIO-Erweiterungsmodul.Dieser Chip wird über den I2C-Bus mit dem ESP32 verbunden und bietet 16 zusätzliche digitale Ein- und Ausgänge. Er eignet sich ideal für Komponenten, die nicht direkt an den ESP32 angeschlossen werden müssen, sodass Du wertvolle GPIO-Pins für wichtigere oder zeitkritische Aufgaben freihalten kannst.

💡 Tipp:
Last Minute Engineers’ Getting Started with ESP32 Guide liefert eine gut-strukturierte und detaillerte Einleitung zum ESP32, welche durch Praxis-Beispiele und viele Anwendungsfälle für Anfänger und Ecperten gleichermaßen vervollständigt wird.

🔗 Springe zu: 🧠 ESP32 · 📖 Inhaltsverzeichnis

Allgemeines Pin-Layout

The ESP32 features a versatile set of GPIO pins, each with specific functions and limitations.

You can configure these pins as inputs or outputs using the pinMode() function. Once configured, you can read their state with digitalRead() or set their state with digitalWrite().

For more details on these functions, please see the dedicated section: 💡 Häufig gebrauchte Funktionen.

The internal registers also allow you to enable built-in pull-up or pull-down resistors, offering a flexible platform for interfacing with various sensors and actuators.

Die folgenden Diagramme und Tabellen helfen Dir dabei, festzustellen, welche Pins für deine Projekte verfügbar sind:

Pinout Diagram ESP32, 38 pins (Source)

📝 Hinweis:
Während die internen GPIO-Nummern (wie GPIO23) bei allen ESP32-Entwicklungsboards einheitlich sind, kann das physische Layout (Pin-Position und Beschriftung) je nach Ihrem spezifischen Board variieren. Die darüber gezeigten Pinbelegungsbilder zeigen ein gängiges Layout, stimmen jedoch möglicherweise nicht eins zu eins mit dem genauen Design Ihres Boards überein.

🔗 Springe zu: 🧠 ESP32 · 📖 Inhaltsverzeichnis

Sicher nutzbare Pins

⚠️ Achtung:
Manche Pins des RSP32 bedienen speifische Anwendungszwecke (z.B. internes Flash-Memory, Boot-modus-Auswahl, Input-only) und können daher nicht als General-Purpose-Input-Output (GPIO) verwendet werden. Für mehr Details, prüfe das Pin-Reference Sheet bevor Du dein eigenes Projekt startest.

💡 Tipp:
Ausführliche Informationen zu den Pins findest Du in der ESP32-Pinbelegungsübersicht von Last Minute Engineers, die einen hervorragenden Überblick über die Pinbelegung des ESP32 und die verschiedenen Funktionen der Pins bietet. Du kannst auch das Datenblatt des von Ihnen verwendeten ESP32-Dev-Boards zu Rate ziehen.

🔗 Springe zu: 🧠 ESP32 · 📖 Inhaltsverzeichnis

Der MCP23018 ist ein I2C-basierter GPIO-Erweiterungsbaustein, der in der FactoryBox verwendet wird, um 16 zusätzliche digitale Ein-/Ausgangspins bereitzustellen – ideal zum Anschließen weiterer Taster, LEDs und einfacher Ausgabekomponenten, wenn deinem ESP32 die GPIOs ausgehen.

Haupt-Markmale

  • Breite Spannungskompatibilität: Der Betrieb ist über einen weiten Bereich (typischerweise 2,5 V bis 5,5 V) möglich, was eine nahtlose Integration sowohl in 3,3-V- als auch in 5-V-Systeme gewährleistet.
  • Integrierte Pull-up-Widerstände: Tragen zur Stabilisierung der Eingangssignale bei, ohne dass zusätzliche externe Bauteile erforderlich sind.
  • Open-Drain-Ausgänge: Diese sind darauf ausgelegt, die Leitungen auf Low-Pegel zu ziehen, eignen sich perfekt für viele grundlegende Anwendungen, erfordern jedoch eine externe Schaltung, wenn ein Push-Pull-High-Pegel benötigt wird.

Der Chip kommuniziert mit dem ESP32 über den I2C-Bus und benötigt dafür lediglich zwei spezielle Pins (SDA und SCL), wodurch wertvolle Ressourcen des Mikrocontrollers geschont werden.

💡 Tipp:
Neu bei I2C? Schau dir die offizielle Arduino-I2C-Dokumentation (Wire) an, um zu verstehen, wie die I2C-Kommunikation funktioniert und wie du sie in deinen eigenen Projekten einsetzen kannst.

Durch die Integration des MCP23018 kannst Du die E/A-Fähigkeiten deines Systems erheblich erweitern, ohne zusätzliche ESP32-Pins zu belegen – so bleibt mehr Spielraum für zeitkritische Aufgaben oder andere Peripheriegeräte.

Datenblatt:MCP23018 – I2C GPIO Expander (Microchip)

GPIO Struktur und Konfiguration

Die 16 GPIOs sind auf zwei 8-Bit-Ports aufgeteilt (siehe Abbildung oben):

  • Port A: GPA0 to GPA7
  • Port B: GPB0 to GPB7

Jeder Pin kann individuell konfiguriert werden als Eingang oder Ausgang, und über die Register des Erweiterungsmoduls kannst Du die Richtung festlegen, die integrierten Pull-ups aktivieren sowie die Pin-Zustände lesen oder schreiben.

Obwohl man diese Register direkt bearbeiten kann, ist es üblich, eine Bibliothek (z. B. MCP23017_WE von Wolfgang Ewald) zu verwenden, die die Low-Level-Details abstrahiert. Auf diese Weise kannst Du die Pins nach der Einrichtung genauso steuern wie die nativen GPIOs des ESP32.

📝 Hinweis:
I2C Addresse: 0x20
The MCP23018 features a multi-bit analog address decoder, allowing up to eight unique I2C addresses using just a single address pin (ADDR).
It selects the address based on the voltage level present on ADDR, using an internal voltage comparator.
In the FactoryBox, this pin is connected to GND, so the MCP23018 uses the address 0x20.

⚠️ Achtung:
Nicht alle Bauteile sind für den MCP23018 geeignet!
Its outputs are open-drain, which means it can pull a line low but not drive it high.
This is fine for LEDs, buttons and buzzers (or similar), but won’t work with components like servos, NeoPixels, or other devices that require push-pull or precisely timed signals.

💡 Tipp:
Für flexiblere Ausgangsmöglichkeiten sollten Sie stattdessen den Einsatz des MCP23017 in Betracht ziehen.
Er verfügt über Push-Pull-Ausgänge (wodurch er für eine größere Bandbreite an Komponenten geeignet ist) und ist in der Maker-Community sogar beliebter.
Außerdem unterstützt er bis zu acht Geräte am I2C-Bus über einfache Adresspins (A0–A2), was die Konfiguration einfacher macht als beim MCP23018.

🔗 Springe zu: 🔌 MCP23018 – GPIO Expander · 📖 Inhaltsverzeichnis

Die FactoryBox ist eine vorverkabelte LErnumgebung, welche auf einem ESP32 basiert.

Sie inkludiert LEDs, Taster, Sensoren, Displays und viele weitere Komponenten welche fest mit dem ESP32 verbunden sind.

Dieser Guide nutzt die festgelegten ID's und Pins in allen Beispiele.

Sensor Layout

GPIO Pinouts

Jede Komponente der FactoryBoxist mit einem spezifischen GPIO Pin auf dem ESP32 und MCP23018 verbunden.

Die folgenden Tabellen zeigen welcher Pin für was genutzt wird. So musst Du nicht raten oder mühsam das Schematic nachverfolgen.

You’ll use these GPIO numbers directly in your code when controlling LEDs, reading sensors, or displaying data.

📝 Hinweis:
Die Part-ID referenzeiert die Tabelle electronic_parts_list.xlsx in den Herstell-Unterlagen.
Sie identifiziert die Bauteile welche in der FactoryBox verwendet werden. Dies kann hilfreich sein, wenn Du mehr über ein bestimmtes Bauteil online nachschauen oder nachbestellen willst.

ESP32 GPIO Pinout
GPIOBauteilPart-IDBereichInput/Output
36LDR322Input, Analog
39Lichtschranke481Input, Digital
34Grove Air Quality (Luftqualität) Sensor583Input, Analog
35Taster #4 (Reset)443Input, Digital
32Stepper Motor mit Treiber – IN4512Output, Digital
33Stepper Motor mit Treiber – IN3512Output, Digital
25Stepper Motor mit Treiber – IN2512Output, Digital
26Stepper Motor mit Treiber – IN1512Output, Digital
27Solenoid461Output, Digital
14Lüfter471Output, analog (PWM)
12NCNCNCNC
13RGBW LED Strip (SK6812)401Output, Digital
15NCNCNCNC
2Servo #1491Output, analog (PWM)
0NCNCNCNC
4Servo #2503Output, analog (PWM)
16Grove 4-Digit Display – DCLK561Output, Digital
17DHT11553Bidirectional, Digital
5Grove 4-Digit Display – DIO561Output, Digital
18Grove LED-Bar – DI573Output, Digital
19Grove LED-Bar – DCKI573Output, Digital
21MCP23018 (I2C GPIO Expander) – SDA522I2C (Digital)
21I2C LCD Display – SDA532I2C (Digital)
21I2C TOF Sensor – SDA542I2C (Digital)
3NCNCNCNC
1NCNCNCNC
22MCP23018 (I2C GPIO Expander) – SCL522I2C (Digital)
22I2C LCD Display – SCL532I2C (Digital)
22I2C TOF Sensor – SCL542I2C (Digital)
23LED Weiß #3 (Beleuchtung)363Output, Digital

NC = Nicht verbunden (Not Connected)

Bereiche: 1 = Wareneingang, 2 = Fertigung, 3 = Warenausgang/Versand

🔗 Springe zu: 🧰 FactoryBox · 📖 Inhaltsverzeichnis

MCP23018 GPIO Pinout
GPIOBauteilPart-IDBereichNotizen
B0Taster #1 (Start/Stop)412Input, Digital
B1LED Blau (Start/Stop)392Output, Digital
B2Taster #2 (Lichtschalter)422Input, Digital
B3LED Weiß #4 (Lichtschalter)342Output, Digital
B4Taster #3 (Notaus)432Input, Digital
B5LED Rot #2 (Notaus)382Output, Digital
B6LED Weiß #1 (Beleuchtung)331Output, Digital
B7NCNCNCNC
A0NCNCNCNC
A1NCNCNCNC
A2NCNCNCNC
A3NCNCNCNC
A4NCNCNCNC
A5LED Rot #1 (Alarrm TOF Sensor)372Output, Digital
A6Buzzer (Alarm TOF Sensor)452Output, Digital
A7LED Weiß #2 (Beleuchtung)352Output, Digital

NC = Nicht verbunden (Not Connected)

Bereiche: 1 = Wareneingang, 2 = Fertigung, 3 = Warenausgang/Versand

📝 Hinweis:
I2C Addresse: 0x20
Der MCP23018 nutzt die I2C Adresse 0x20 in der FactoryBox. Für mehr Details, siehe:
🔌 MCP23018 – GPIO Expander.

🔗 Springe zu: 🧰 FactoryBox · 📖 Inhaltsverzeichnis

Coding Informationen

Dieses Kapitel führt dich durch die Nutzung von PlatformIO mit VisualStudioCode. Es zeigt die wie du Projekte mit deinem ESP32 kreierst, öffnest und verwaltest.

Übersicht

PlatformIO ist eine plattformübergreifende Open-Source-IDE, die speziell für die Entwicklung eingebetteter Software konzipiert wurde. Sie bietet eine integrierte Bibliotheksverwaltung, umfassende ESP32-Unterstützung und Kompatibilität mit dem Arduino-Framework.

Dieser Guide nutzt PlatformIo mit Visual Studio Code. Obwohl der bereitgestellte Code aus main.cpp generell auch mit der Arduino IDE kompatibel ist, kann sich die Benutzung und die Projektstruktur unterscheiden,

💡 Tipp:
Du brauchst mehr Unterstützung im Nutzen von PlatformIo mit VSCode? Schaue doch mal in die offizielle Dokumentation:
PlatformIO IDE for VS Code.

Installieren von PlattformIo in VSCode

  1. Klicke in der Seitenleiste von Visual Studio auf die Registerkarte „Erweiterungen“

2. Suche nach "PlattformIO"

3. Installiere die Erweiterung. Ggf. musst du danach VSCode neustarten.

Contratulations 🎉 You’re now ready to start working with PlatformIO.
You will find all the things you need for the following steps in the PIO Home-Tab

Neues Projekt erstellen

Lasse uns zunächst ein neues PlatformIO-Projekt für Ihr ESP32-Board erstellen:

  1. Öffne PlattformIO Home
  2. Klicke auf "Neues Projekt/New Project"
  3. Wähle ein Board aus: Gebe „esp32 dev“ in die Suchleiste ein und wähle „Espressif ESP32 Dev Module“ aus.
  4. Wähle das Arduino Framework (Standard)
  5. Wähle den Projekt Speicherort, indem Du "Use default location" deselektierst und einen eigenen Ordner auswählst
  6. Klicke "Beenden/Finish"

Sobald Dein Projekt erstellt und geöffnet ist, wird dessen Name in der unteren Leiste von VS Code angezeigt (z. B. Default (demo_project)), was bestätigt, dass Ihr neues Projekt aktiv ist:

🔗 Springe zu: 🧑‍💻 PlatformIO IDE · 📖 Inhaltsverzeichnis

Öffnen eines existierenden Projektes

Want to continue working on an existing project? Here’s how to open it in PlatformIO.

  1. Öffne PlattformIO Home
  2. Klicke auf "Projekt öffnen/ Open Project"
  3. Wähle den Projektordner aus, der die Datei platformio.ini enthält
  4. Klicke auf "Öffnen/Open"

Wenn das Projekt geladen ist, wird sein Name ebenfalls in der unteren Leiste angezeigt, genau wie bei einem neu erstellten Projekt:

🔗 Springe zu: 🧑‍💻 PlatformIO IDE · 📖 Inhaltsverzeichnis

Struktur des Projekt-Ordners

Wenn Sie ein PlatformIO-Projekt erstellen oder öffnen (z. B. 01_led_blink), sehen Sie eine Ordnerstruktur wie diese:

Hier ist, was die einzelnen Ordner können:

  • src/ Hier kommt dein Hauptcode hin. Du beginnst mit main.cpp
  • lib/ – Benutzerdefinierte Bibliotheken, die Du für dein Projekt erstellst oder manuell hinzufügst (z. B. von GitHub heruntergeladen)
  • include/ – Header-Dateien (.h) zur Deklaration von Funktionen, Konstanten usw.
  • .pio/ – PlatformIO verwendet diesen Ordner intern, um Build-Ergebnisse (build/) und über den Bibliotheksmanager installierte Bibliotheken (libdeps/) zu speichern
  • platformio.ini – Die Konfigurationsdatei deines Projekts (legt den Board-Typ, die Bibliotheken und die Build-Einstellungen fest)

Für deine Programme, schreibe deinen Code in src/main.cpp.

PlatformIO kompiliert den Inhalt dieser Datei automatisch und lädt ihn auf deinen ESP32 hoch.

🔗 Springe zu: 🧑‍💻 PlatformIO IDE · 📖 Inhaltsverzeichnis

Bibliotheken

PlatformIO verwendet einen Bibliotheksmanager zum Durchsuchen und Installieren von Bibliotheken. Bibliotheken werden projektbezogen installiert, sodass Du in verschiedenen Projekten unterschiedliche Bibliotheken verwenden kannst. Sie sind in der Datei platformio.ini unter der Zeile lib_deps aufgeführt und werden im Ordner .pio innerhalb deines Projektverzeichnisses gespeichert. Wenn Du eine Bibliothek nicht mehr benötigst, kannst Du sie über den Bibliotheksmanager deinstallieren.

Installieren einer Bibliothek
  1. Gehe zu PlatformIo
  2. Klicke auf "Bibliotheken/Libraries"
  3. Öffne den "Registry"-Reiter
  4. Suche die Bibliothek, welche Du installieren möchtest
  5. Klicke auf die Bibliothek
  6. Klicke auf " Dem Projekt hinzufügen/ Add new Project"
  7. Wähle dein Projekt
  8. Klicke auf "Hinzufügen/ Add"
Deinstallieren einer Bibliothek
  1. Gehe zu PlatformIo
  2. Klicke auf "Bibliotheken/Libraries"
  3. Öffne den "Installierst/Installed" Reiter
  4. Finde Die Bibliothek, welche du deinstallieren willst (stelle sicher, dass Du dabei auch das korrekte Projekt ausgewählt hast).
  5. Klicke "Deinstallieren/Uninstall" und bestätige mit "Ja/Yes"

In manchen Fällen kann es vorkommen, dass die Version einer Bibliothek im PlatformIO Library Manager veraltet ist, während auf GitHub eine neuere Version verfügbar ist. Wenn Du stattdessen die GitHub-Version verwenden möchten, kannst Du diese manuell zu Deinem Projekt hinzufügen:

Manuelles Installieren einer Bibliothek aus GitHub
  1. Kopiere die GitHub repository URL der Bibliothek, welche Du verwenden willst.
  2. Öffne die platformio.ini Datei deines Projektes.
  3. Füge die URL der lib_deps Zeile zu, z.B.: lib_deps = https://github.com/Seeed-Studio/Grove_LED_Bar.git
  4. Speichere die Datei
  5. Die Bibliothek wird automatisch heruntergeladen und installiert wenn du das nächste mal einen Code kompillierst oder hochlädsts.
  6. Du kannst Deine installierten Bibliotheken auch in dem lib Ordner deines Projektes finden.

🔗 Springe zu: 🧑‍💻 PlatformIO IDE · 📖 Inhaltsverzeichnis

Deinen Code ausführen

Sobald Dein Code bereit ist, kannst du ihn auf den EPS32 uploaden.

  1. Stelle sicher, dass in der unteren Leiste das richtige Projekt ausgewählt ist (z. B. Standard (01_led_blink)).
  2. Click the ➡️ Upload button (right arrow icon) in the bottom bar to build and flash your code to the ESP32.
  3. Optionally, you can click the ✅ Build button first (checkmark icon) to compile the code without uploading – useful if you just want to check for errors.
  4. Öffne den Serial Monitor (Steckersymbol), um Meldungen von Serial.print() und andere serielle Ausgaben anzuzeigen.

Stelle sicher, dass Dein Board über USB angeschlossen ist und der richtige COM-Port ausgewählt ist (PlatformIO erkennt dies in der Regel automatisch).

Falls dein ESP während des Uploads keine Verbindung herstellt oder nicht reagiert, drücke die BOOT-Taste, bis auf dem Terminal die Meldung „Verbindung wird hergestellt“ angezeigt wird.
Falls der Fehlercode „COM3 existiert nicht“ lautet, ziehe einfach für einen Moment das USB-C-Kabel von deinem Laptop ab.

Wenn im Serial Monitor keine Meldungen angezeigt werden, überprüfe bitte noch einmal, ob Du Serial.begin(baud-rate), in Deine setup()-Funktion aufgenommen hast, und stelle sicher, dass die Baudrate (z. B. 9600) mit der in den Einstellungen des Serial Monitors ausgewählten übereinstimmt.

🔗 Springe zu: 🧑‍💻 PlatformIO IDE · 📖 Inhaltsverzeichnis

Dieses Kapitel soll Dir eine Hilfe sein, falls DuPlatformIO nicht als IDE verwendest.
Es vermittelt einen kurzen Überblick über die Grundlagen der Arduino-IDE.

Bitte schaue nach mehr Anleitungen im Internet wenn notwendig.

❗IMPORTANT

Du kannstdie Beispielcodes nicht direkt verwenden, da sie für PlatformIO erstellt wurden.
In den separaten Beispielordnern findest Du den Code jedoch im scr-Ordner in der Datei main.cpp.
Du kannst sen dortigen Code direkt in die Datei .ino eines neuen Arduino-Projekts kopieren.

Installieren des ESP32 über den Boardmanager

Open the Board Manager over Tools> Board> Boardmanager

If the ESP32 is not already installed, search for esp32 by espressiv and install it.
Select the DOIT DEVKIT V1 Version

Neues Projekt anlegen

Bestehendes Projekt öffnen

Folder structure (or lack thereof)

In Arduino V2 you can set a sketchbook location, where the program is able to find existing code to open.

However, it does not work with subfolders

Bibliotheken

Deinen Code ausführen

You can compile your code with the first button on the top-left

if you want to compile and upload it, choose the second button, as shown.

Always make sure the correct board is selected.

Ein typischer Arduino-Sketch besteht aus drei Hauptteilen:

  1. Bibliotheken und Definitionen
  2. Der Setup Code
  3. Der Loop Code
/* 
     1. Bibliotheken einbinden, Konstanten definieren, globale Variablen deklarieren usw.
*/
void setup() {
  // 2. Diese Funktion wird einmalig ausgeführt, wenn das Gerät startet oder zurückgesetzt wird.
}
void loop() {
  // 3. Diese Funktion wird nach dem Aufruf von `setup()` wiederholt ausgeführt und enthält Ihren Hauptcode.
}

📝 Hinweis:
Bei der Nutzung von PlatformIO, musst die die Arduino.h Bibliothek einschließen um die Standard Arduino-Funktionen nutzen zu können (Dies ist in der Arduino IDE nicht notwendig)

Was ist Arduino?

Arduino is a open source platform that makes coding easy. And it’s crossplattform! 🎉
Since the language it’s based on C/C++ you can not only build simple projects with it. You can include .h, .cpp files and build your project to insane sizes – if you dare 😉

Es gibt jedoch auch zahlreiche Mikrocontroller der Arduino-Familie, die Sie programmieren können. Sie sind mit den meisten Sensoren kompatibel, und aufgrund ihrer Beliebtheit ist die dahinterstehende Open-Source-Community sehr aktiv und bietet zahlreiche Ressourcen für nahezu alle Probleme, egal wie knifflig diese auch sein mögen.

Aber es ist ebenfalls komatibel mit weiteren Mikrokontrollern wie dem ESP32.

To learn more about the history of Arduino go hier or watch an introductory video 🙃

Bibliotheken und Definitionen

Starte indem die alle notwendigen Bibliotheken einbindest und alle globalen Konstanten, Variablen und Objekte anlegst. In diesem Abschnitt ist alles, das während demProgrammieren genutzt werden soll, enthalten.

Beispiel:

#include <Arduino.h>  // Unverzichtbar für PlatformIO-Projekte (die Arduino-IDE bindet dies automatisch ein).
#include <ExampleLibrary.h>  // Ersetze dies mit den von dir benötigten Bibliotheken
// Hier kannst du die Konstanten für Hardware-Verbindungen definieren. Diese Werte sollten sich nicht ändern.
const int LED_PIN = 23;  // Example: assign the LED to GPIO pin 23
// Hier kannst du die Globale Variablen deklarieren, deren Werte sich während der Programmausführung ändern können.
int exampleVariable = -1;  // Beispiel-Variable, initialisiert mit dem Wert -1

🔗 Springe zu: 🧩 Arduino Code Struktur · 📖 Inhaltsverzeichnis

Der Setup Code

Die Funktion setup() wird einmalig ausgeführt, wenn das ESP32 (oder ein beliebiges Arduino-Board) startet oder zurückgesetzt wird. Verwenden Sie diese Funktion, um die serielle Kommunikation zu initialisieren, Pin-Modi zu konfigurieren und Anfangszustände für Variablen festzulegen.

Beispiel:

void setup() {
  Serial.begin(9600);          // Initialisiere die serielle Kommunikation mit 9600 Baud für die Fehlersuche.
  Serial.println("LED Blink"); // Eine Startmeldung auf dem Serial Monitor ausgeben.
  
  pinMode(LED_PIN, OUTPUT);    // Den LED-Pin als Ausgang konfigurieren.
  
  // Hier kann zusätzlicher Setupscode (z. B. zur Initialisierung von Sensoren) hinzugefügt werden.
}

🔗 Springe zu: 🧩 Arduino Code Struktur · 📖 Inhaltsverzeichnis

Der Loop Code

Die Funktion loop() wird nach Abschluss von setup() kontinuierlich ausgeführt. Sie enthält die Hauptlogik Ihres Programms und wird so lange wiederholt, bis das Board ausgeschaltet oder zurückgesetzt wird.

Beispiel:

void loop() {
  // Die LED einschalten, eine Meldung ausgeben und warten.
  digitalWrite(LED_PIN, HIGH);   // Aktiviere die LED
  Serial.println("LED ON");      // Gebe den aktuellen Status auf dem Seriellen Monitor aus
  delay(1000);                   // Warte für eine Sekunde (1000 Millisekunden)
  // Die LED ausschalten, eine Meldungs ausgeben und warten
  digitalWrite(LED_PIN, LOW);    // Deaktiviere die LED
  Serial.println("LED OFF");     // Gebe den aktuellen Status auf dem Seriellen Monitor aus
  delay(1000);                   // Warte für eine Sekunde
}

Diese Struktur sorgt für einen übersichtlichen Code und erleichtert die Verwaltung und Erweiterung Ihrer Projekte.

🔗 Springe zu: 🧩 Arduino Code Struktur · 📖 Inhaltsverzeichnis

Dieser Abschnitt behandelt die am häufigsten gebrauchten Funktionen die Du in in deinen Arduino-Projekten nutzen wirst:

Pin Konfiguration

Lerne Pins zu definieren und korrekt als Input/Output zu konfigurieren:

  • Definiere einen PIN
    • Lege eine Konstante für den entsprechenden Pin an, um deinen Code lesbarer und wartbarer zu machen.
    • Beispiel:
const int LED_PIN = 2;  // Ersetze die 2 mit der tatächlich genutzten GPIO Nummer
  • pinMode(pin, mode)🔗
    • Konfiguriere einen bestimmten Pin um sein Verhalten als Input oder Output zu definieren.
    • Beispiel:
pinMode(LED_PIN, OUTPUT);
pinMode(SENSOR_PIN, INPUT);
pinMode(BUTTON_PIN_1, INPUT_PULLDOWN);
pinMode(BUTTON_PIN_2, INPUT_PULLUP);

📝 Hinweis:
Unsicher, welchen GPIO Pin du nutzen kannst?
Sieh die GPIO Pinouts an, um deren Verfügbarkeit und Belegungen auf dem ESP32 und
MCP23018 in der FactoryBox anzusehen.

🔗 Springe zu: 💡 Häufig gebrauchte Funktionen · 📖 Inhaltsverzeichnis

Serielle Kommunikation

Debugging ist einfach mit seriellen Ausgaben.

Serielle Kommunikation ermöglicht Dir, Daten an den Seriellen Monitor zu senden. DIes kann z.B. für Debugging oder Log schreiben verwendet werden. Im folgenden sind die am regelmäßigsten verwendeten Serial-Funktionen aufgelistet.

  • Serial.begin(baudRate)🔗
    • Muss vorhanden sein! Diese Funktion muss einmalig in der setup() Funktion aufgerufen werde, um die serielle Kommunikation zu initialisieren.
    • Wenn Serial.begin()nicht aufgerufen wird, wird keine der anderen Serial-Funktionen )print, println, printf) funktionieren - d.h. Du wirst auch keine Ausgabe am Seriellen Monitor sehen.
    • Beispiel:
Serial.begin(9600);  // Serielle Kommunikation mit 9600 Baud initialisieren
  • Serial.print(data)🔗
    • Sendet die Daten als für Menschen lesbaren ASCII Text ohne Zeilenumbruch am Ende.
    • Hinweis zur Speichernutzung: Strings (Textzeile) die nicht mit einem F() umgeben sind, werden im RAM gespeichert. Nutze F("string") um RAM zu sparen und die Strings in den Flash Speicher zu legen.
    • Beispiel:
float temperature = 23.456;
int humidity = 45;
Serial.print("Hello, world!");    // Gibt eine Zeichenkette aus dem SRAM aus
Serial.print(F("Hello, Flash!")); // Gibt eine Zeichenkette aus dem Flash-Speicher aus
Serial.print(temperature, 2);     // Gibt eine Variable mit 2 Dezimalstellen aus
Serial.print(humidity);           // Gibt eine Variable aus

Ausgabe:

Hello, world!Hello, Flash!23.4645
  • Serial.println(data)🔗
    • Ähnlich wie Serial.print(), fügt jedoch einen Wagenrücklauf und einen Zeilenumbruch (\r\n) an, sodass die nächste Ausgabe in einer neuen Zeile beginnt.
    • Speicher Hinweis: As with Serial.print(), use F() to move constant strings to Flash memory and save RAM.
    • Beispiel:
float temperature = 23.456;
int humidity = 45;
Serial.println("Hello, world!");      
 // Gibt die Zeichenfolge aus und wechselt in eine neue Zeile
Serial.println(F("Hello, Flash!"));   
// Gibt die im Flash-Speicher abgelegte Zeichenfolge aus und wechselt in eine neue Zeile
Serial.println();                     
 // Gibt eine Leerzeile aus und springt in eine neue Zeile
Serial.println(temperature, 2);       
// Gibt eine Variable mit zwei Dezimalstellen aus und wechselt in eine neue Zeile
Serial.println(humidity);             
// Gibt eine Variable aus und wechselt in eine neue Zeile

Ausgabe:

Hello, world!
Hello, Flash!
23.46
45

🔗 Springe zu: 💡 Häufig gebrauchte Funktionen · 📑 Inhaltsverzeichnis

Read/Write Data (Lesen/Schreiben)

Erfahren, wie Du mit Sensoren, Tasten, LEDs und vielem mehr arbeiten kannst:

digitalWrite(LED_PIN, HIGH);  // Schalte die LED an
digitalWrite(LED_PIN, LOW);   // Schalte die LED aus
  • digitalRead(pin)🔗
    • Liest den Wert (HIGH oder LOW) von einem angegebenen digitalen Pin aus.
    • Beispiel:
int buttonState = digitalRead(BUTTON_PIN);
int sensorReading = digitalRead(SENSOR_PIN);
  • analogWrite(pin, value)🔗
    • Schreibt einen analogen (PWM-) Wert auf einen Pin. Die Auflösung der meisten Boards hierfür beträgt 8-Bit (0-255).
    • Beispiel:
analogWrite(LED_PIN, 180);  // Setze die LED Helligkeit ( 0 = aus, 255 = volle Helligkeit)
  • analogRead(pin)🔗
    • Liest den Wert eines analogen Pins aus. Die analogen Inputs des ESP32 haben eine 12-Bit Auflösung (0 bis 4095).
    • Beispiel:
int sensorReading = analogRead(SENSOR_PIN);

🔗 Springe zu: 💡 Häufig gebrauchte Funktionen · 📑 Inhaltsverzeichnis

Timing und Logik

Essentielle Funktionen für den Flow und das Timing deines Programms:

  • delay(milliseconds)🔗
    • Pausiere das Programm für eine vorgegebene Weile. Das ist nützlich um z.B. eine LED blinken zu lassen, Tasterprellen abzufangen und Abfragen zu verzögern.
    • Beispiel:
digitalWrite(LED_PIN, HIGH);
delay(500);  // Wait 500 milliseconds (code execution is paused)
digitalWrite(LED_PIN, LOW);
delay(500);

📝 Hinweis:
Obwohl delay() simple und nützlich ist, blockiert es dein Programm d.h. ist ist nicht möglich anderen Code währenddessen auszuführen.
Wenn Du mehrere Dinge gleichzeitig machen musst (bspw. eine LED blinken lassen während du einen Taster prüfst),
verwende den nicht- blockenden millis() Ansatz als Alternative..

  • if🔗 / else🔗 Statement (Bedingte Statements)
    • Beeinflusse den Ablauf deines Programmes basierenden auf bestimmtem Konditionen. Perfekt um Sensor-Werte, Taster oder Zustände abzufragen.
    • Beispiel:
if (buttonState == HIGH) {
  digitalWrite(LED_PIN, HIGH);  // LED on
} else {
  digitalWrite(LED_PIN, LOW);   // LED off
}
  • for Loop🔗
    • Nutze den for Loop, wenn du etwas für eine bestimmte Anzahl an Wiederholungen ausführen oder über einen bestimmten Wertebreich iterieren willst.
    • Generelle Sytanx:
for (initialization; condition; increment) {
  // statement(s);
}
// Eine for-Schleife beginnt mit einer Initialisierung, die einmal ausgeführt wird.
// Dann wird die Bedingung ausgewertet – ist sie wahr, wird der Schleifenkörper ausgeführt.
// Nach jedem Durchlauf wird der Inkrementierungsschritt ausgeführt.
// Dies wiederholt sich, bis die Bedingung nicht mehr erfüllt ist und die Schleife endet.
  • Beispiel:
// Lasse eine LED 5 mal blinken
for (int i = 0; i < 5; i++) {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}
// Zähle von 0-4 und gebe die Zahlen aus
for (int i = 0; i < 5; i++) {
  Serial.println(i);
}
// Erklärung des Loops
// int i = 0: Initialisieren des Loop-Zählers i
// i < 5: Der Loop läuft solange diese Bedingung wahr ist
// i++: Inkrementiert i nach jedem Loop um den Wert 1

🔗 Springe zu: 💡 Häufig gebrauchte Funktionen · 📖 Inhaltsverzeichnis

Utility Funktionen

Hilfreiche Built-In Funktionen die häufig auftretende Aufgaben innerhalb deines Codes vereinfachen.

int ledValue = map(potiRead, 0, 4095, 0, 255);
// Ordnet den Potentiometerwert (0 bis 4095, 12 Bit) dem Bereich von `analogWrite` (0 bis 255, 8-Bit-PWM) zu
int constrainedValue = constrain(sensorValue, 1000, 3000);  Limitiert den Wert auf 1000-3000

🔗 Springe zu: 💡 Häufig gebrauchte Funktionen · 📖 Inhaltsverzeichnis

Unsicher womit du starten sollst? Erkunde den Order Beispiele den Du oben herunterladen kannst. Jedes Beispiel demonstriert wie du eine spezifische Komponente der FactoryBox nutzt - der perfekte Ausgangspunkt für alles was kommt.

Versuche zunächst, einen der fertigen Beispielcodes hochzuladen. Dieser funktioniert direkt.

Solltest du bestimmte Bibliotheken brauchen um den Code auszuführen, ist dies klar in dessen Kommentaren vermerkt.

Das Blinken einer LED ist so ein bisschen das "Hello World!" der Hardware-Programmierung.

#include <Arduino.h>                // Binde die Arduino Library ein
const int LED_PIN = 23;             // Nummer des GPIO Pins der LED
void setup() {
  pinMode(LED_PIN, OUTPUT);         // Initialisiere den LED Pin als OUTPUT
}
void loop() {
  digitalWrite(LED_PIN, HIGH);      // Schalte die LED ein
  delay(1000);                       // Warte für 500 Millisekunden
  digitalWrite(LED_PIN, LOW);       // Schalte die LED aus
  delay(1000);                       // Warte für 500 Millisekunden
}
  1. Lege ein neues PlatformIO Projekt an (weiter oben erklärt)
  2. Kopiere diesen Code und füge in in deine main.cpp ein
  3. Lade den Code hoch (Upload)
  4. Sieh zu wie die LED im Sekundentakt blinkt

📝 Hinweis:
Du möchtest den entsprechenden GPIO für deine Komponente finden?
Die GPIO Pinouts zeigen alle Pins der FactorBox, sowohl die des ESP32 als auch die des MCP23018.

Wenn es nur ein kleines Problem ist - nutze Print-Statements.
Wenn du prüfen möchtest, ob dein Code eine Funktion jemals aufruft. Wenn Du nur sicherstellen willst, ob eine Variable auch tatsächlich ihren Wert ändert...
Füge eine Ausgabe in der entsprechenden Code-Zeile hinzu.
Da Arduino einen Interpreter-basierte Sprache ist, wird jede Zeile einzeln gelesen und am Fehler aufgehört.

Solltest Du wirklich wissen wollen, wir man korrekt debuggt, lese in diesem Link hier.

Ein simples Serial.println(“Debug Nachricht hier”) wirkt Wunder wenn man wissen möchte, ob ein Code eine gewisse Bedingung erfüllt oder Funktion erreicht hat.

📖 Weitere Informationen

Du möchtest mehr lernen? Du brauchst mehr Details?
Hier sind Links zu offiziellen Arduino Ressourcen, welche dir dabei helfen sollen merh über Programmierung, Syntac und Best-Practices zu lernen.

Hilfreiche Abschnitte:

Die Arduino-Community ist riesig und Dein Problem hatte mit hoher Wahrscheinlichkeit bereits jemand anderen heimgesucht.
Hillfe ist nur eine Google-Suche weit entfernt

Und am wichtigsten - habe Spaß 😉

🔗 Springe zu: 💡 Häufig gebrauchte Funktionen · 📖 Inhaltsverzeichnis