#mikrocontroller

[draegerit]

Mikrocontroller anschließen: Warum Windows Treiber braucht und macOS nicht

Wer länger mit Mikrocontrollern arbeitet, kennt das Problem – vor allem unter Windows. Sobald man nicht mehr mit einem „klassischen“ Arduino arbeitet, sondern einen weniger populären Mikrocontroller oder einen Clone mit USB-Serial-Konverter wie dem CP210x einsetzt, geht die Suche los: Welcher Treiber wird benötigt? Wo bekomme ich ihn her?

In der Praxis endet das häufig bei einer Google-Suche und auf Herstellerseiten wie Silicon Labs, um den passenden USB-Serial-Treiber manuell nachzuinstallieren. Erst danach taucht der Mikrocontroller überhaupt als COM-Port auf und lässt sich programmieren – ein zusätzlicher Schritt, der gerade am Anfang für Frust sorgt.

https://youtu.be/uDIYYocCMUE

Unter macOS sieht die Situation deutlich entspannter aus. Viele Mikrocontroller werden direkt nach dem Anstecken erkannt, ganz ohne zusätzliche Treiberinstallation. Das funktioniert sprichwörtlich out of the box – ein echter Vorteil im Entwicklungsalltag.

Gerade wenn man regelmäßig neue Boards testet oder Prototypen aufbaut, nimmt einem das unter macOS eine Menge „Pain“ ab und erlaubt es, sich voll auf das eigentliche Projekt zu konzentrieren – statt auf Treibersuche und Setup-Probleme.

Microsoft Windows - CP2102 - Mikrocontroller nicht erkannt

macOS - CP2102 - Mikrocontroller erkannt

In diesem Beitrag schauen wir uns genau an, warum Windows hier anders tickt als macOS – und wann auch unter macOS doch einmal ein Eingriff nötig ist.

Typischer Alltag unter Windows – der Treiber-Painpoint

Unter Windows entscheidet oft nicht der Mikrocontroller selbst darüber, ob man direkt loslegen kann, sondern der verbaute USB-Serial-Konverter. Genau hier entsteht der typische Painpoint.

Viele Boards – insbesondere Arduino-Clones oder ESP-Varianten – nutzen Chips wie:

- CP2102 / CP2104 - CH340 / CH341 - FT232

Windows erkennt diese Chips nicht automatisch als serielle Schnittstelle, solange kein passender Treiber installiert ist.

Was man unter Windows typischerweise sieht

Nach dem Anschließen des Mikrocontrollers passiert häufig eines der folgenden Dinge:

- In der Arduino IDE erscheint kein COM-Port - Im Gerätemanager taucht ein: - „Unbekanntes Gerät“ - oder ein Eintrag mit Warnsymbol - Das Board erhält zwar Strom, aber der Upload eines Sketches ist nicht möglich

Windows Geräte-Manager - DigiSpark ATTiny85 nicht erkannt

Microsoft Windows - CP2102 - Mikrocontroller nicht erkannt

Ohne installierten Treiber bleibt der Mikrocontroller für die Entwicklungsumgebung unsichtbar.

Der zusätzliche Schritt unter Windows

Um das Board nutzen zu können, ist in vielen Fällen ein manueller Schritt notwendig:

- Identifikation des USB-Serial-Chips - Suche nach dem passenden Treiber - Download von der Herstellerseite (z. B. Silicon Labs bei CP210x) - Installation des Treibers - teilweise ein Neustart

Treiber für CP210x USB-Serial Konverter von Silicon Labs

Erst danach erscheint der Mikrocontroller als klassischer COM-Port und kann ausgewählt werden.

Warum das relevant ist

Technisch ist dieser Ablauf nachvollziehbar – praktisch bedeutet er aber:

- zusätzlicher Setup-Aufwand - Abhängigkeit vom Hersteller - Unterbrechung beim schnellen Testen neuer Boards

Gerade wenn man häufig mit unterschiedlichen Mikrocontrollern oder Clones arbeitet, wird dieser Schritt schnell zum festen Bestandteil des Windows-Alltags.

Genau an dieser Stelle unterscheidet sich macOS deutlich – denn dort entfällt dieser Zwischenschritt in vielen Fällen komplett.

macOS im Vergleich – anschließen und direkt loslegen

Unter macOS zeigt sich im Alltag ein deutlich entspannteres Bild. In meinem bisherigen Einsatz wurden alle getesteten Mikrocontroller direkt erkannt, ohne dass ich manuell zusätzliche Treiber installieren musste.

Egal ob klassische Arduino-Boards oder weniger verbreitete Varianten – macOS erkennt die Geräte beim Anstecken zuverlässig und stellt sie unmittelbar als nutzbaren Port zur Verfügung. Selbst Boards, die unter Windows häufig einen separaten Treiber erfordern, funktionieren hier out of the box.

Ein konkretes Beispiel ist der Keyestudio MAX, der einen CP2102 USB-UART-Chip verwendet. Während unter Windows in der Regel erst der passende Treiber installiert werden muss, erscheint das Board unter macOS sofort als serielles Gerät und kann direkt in der Entwicklungsumgebung ausgewählt werden.

macOS - Keyestudio MAX mit CP2102 USBtoUART Bridge

Auch der Maker Nano, der auf den weit verbreiteten CH340-Chip setzt, wird ohne zusätzliche Schritte erkannt. Nach dem Anschließen lässt sich der Port unmittelbar auswählen – und man kann praktisch sofort mit dem Programmieren beginnen.

macOS - ESP-WROOM-32 mit CH340 USB zu Serial Konverter

macOS - Maker Nano mit CH340 USB zu Serial Konverter

Gerade im Entwicklungsalltag ist das ein spürbarer Vorteil: Kein Suchen nach Treibern, keine Installationsdialoge, kein Neustart. Der Fokus bleibt dort, wo er hingehört – beim eigentlichen Projekt. Im direkten Vergleich fühlt sich die Arbeit mit Mikrocontrollern unter macOS bislang deutlich angenehmer und reibungsloser an als unter Windows.

Praxistest: Welche Boards wurden unter macOS erkannt?

In meinem eigenen Test habe ich bewusst verschiedene Mikrocontroller aus meinen „Kisten“ angeschlossen – darunter klassische Arduino-Boards, ESP32-Varianten sowie einige Clones mit CP2102- oder CH340-Chips.

Das Ergebnis war eindeutig: Alle getesteten Boards wurden unter macOS direkt erkannt und standen unmittelbar als nutzbarer Port zur Verfügung – ganz ohne zusätzliche Treiberinstallation.

Eine Ausnahme bildet jedoch der Digithumb mit ATtiny85. Dieses Board ist technisch ein Sonderfall, da es keinen klassischen USB-Serial-Konverter verwendet, sondern die USB-Kommunikation anders implementiert. Genau deshalb verhält es sich sowohl unter Windows als auch unter macOS anders als typische Arduino- oder ESP-Boards.

Da der Digithumb in mehreren Punkten aus dem üblichen Schema fällt, werde ich diesem Mikrocontroller einen eigenen Beitrag widmen – inklusive Einrichtung, Besonderheiten und typischer Stolperfallen.

Warum funktioniert das unter macOS anders?

Der Unterschied liegt weniger am Mikrocontroller selbst, sondern am Treibermodell des jeweiligen Betriebssystems.

Viele Mikrocontroller-Boards verwenden sogenannte USB-Serial-Konverter, die sich gegenüber dem Betriebssystem als serielle Schnittstelle ausgeben. Technisch basiert das häufig auf der USB-Klasse CDC (Communication Device Class) – einem standardisierten USB-Profil für serielle Kommunikation.

macOS: Generische Klassen-Treiber

macOS bringt bereits seit vielen Jahren generische Klassen-Treiber für USB-CDC-Geräte mit. Das bedeutet:

- Das Betriebssystem erkennt standardkonforme USB-Serial-Geräte automatisch. - Kein herstellerspezifischer Treiber ist notwendig. - Das Gerät wird direkt als /dev/cu.usb…-Port bereitgestellt.

Solange sich der verbaute USB-Serial-Chip an die üblichen Standards hält, kann macOS ihn ohne zusätzliche Installation ansprechen.

Windows: Herstellerabhängiger Ansatz

Unter Windows ist das Modell etwas anders aufgebaut. Zwar unterstützt auch Windows USB-CDC grundsätzlich, viele USB-Serial-Chips setzen jedoch auf herstellerspezifische Implementierungen. In solchen Fällen:

- wird kein generischer Treiber automatisch zugewiesen - das Gerät erscheint zunächst als „Unbekanntes Gerät“ - erst die Installation des passenden Herstellertreibers aktiviert den COM-Port

Windows ist hier stärker auf signierte, explizit zugeordnete Treiber angewiesen. Das erhöht zwar die Kontrolle und Integrität des Systems, sorgt aber im Mikrocontroller-Alltag häufiger für zusätzliche Setup-Schritte.

Fazit & Ausblick

Der direkte Vergleich zeigt deutlich: Unter Windows gehört die manuelle Installation von USB-Serial-Treibern bei vielen Mikrocontrollern zum Alltag. Besonders bei Clones oder weniger verbreiteten Boards ist dieser zusätzliche Schritt häufig notwendig, bevor überhaupt ein COM-Port erscheint.

Unter macOS gestaltet sich der Einstieg in vielen Fällen deutlich unkomplizierter. In meinen Tests wurden nahezu alle verwendeten Mikrocontroller direkt erkannt und standen ohne zusätzliche Treiberinstallation sofort zur Verfügung. Das reduziert Reibung im Setup und sorgt für einen spürbar flüssigeren Entwicklungsprozess.

Eine Ausnahme bildet der Digithumb mit ATtiny85, der technisch einen Sonderweg geht und sich anders verhält als klassische Arduino- oder ESP-Boards. Genau diesem Spezialfall werde ich einen eigenen Beitrag widmen, da hier einige Besonderheiten zu beachten sind.

Im nächsten Artikel der Reihe schauen wir uns daher genauer an, wie sich atypische Mikrocontroller unter macOS einrichten lassen – und wo auch hier gezielte Handarbeit erforderlich sein kann.

[draegerit]

Fox:bit von Keyestudio – der günstige micro:bit-Klon mit ESP32-Power!

Der Fox:bit von Keyestudio erinnert auf den ersten Blick an den bekannten BBC micro:bit – ist aber deutlich größer und tritt mit einem ganz eigenen Stil auf. Seinem Namen macht er dabei alle Ehre: Der Fox:bit besitzt zwei kleine „Ohren“, die ihm einen unverwechselbaren Look verleihen – ganz ohne Funktion, aber mit ordentlich Charme und Wiedererkennungswert.

Technisch spielt er allerdings in einer ganz anderen Liga. Im Inneren arbeitet ein ESP32-Dual-Core-Prozessor, der nicht nur mehr Leistung bietet, sondern auch WLAN und Bluetooth direkt an Bord hat. Damit eignet sich der Fox:bit nicht nur für Einsteigerprojekte, sondern auch für komplexe, drahtlose Anwendungen – von Sensorprojekten bis hin zu IoT-Lösungen.

https://youtu.be/wd4aAVt6WE8

Kurz gesagt: Der Fox:bit vereint Leistung, Lernfreundlichkeit und Design auf eine Art, die ihn zu einem spannenden Alternativboard für Schulen, Maker und kreative Köpfe macht.

Technische Daten des Fox:bit von Keyestudio

Unter der auffälligen „Fuchs“-Optik steckt beim Fox:bit moderne Technik. Das Board basiert auf dem bewährten ESP32-WROOM-32 Modul, das für seine hohe Rechenleistung und vielseitigen Kommunikationsmöglichkeiten bekannt ist. Dadurch eignet sich der Fox:bit sowohl für klassische Arduino-Projekte als auch für MicroPython-Experimente.

ESP32-WROOM-32E auf Fox:bit Technische Spezifikationen MerkmalBeschreibungMikrocontrollerESP32-WROOM-32 (Dual-Core Xtensa® 32-bit LX6 @ 240 MHz)Speicher520 KB SRAM, 4 MB FlashBetriebsspannung3,3 VStromversorgungUSB-C (5 V) oder externer PinKommunikationWLAN 802.11 b/g/n, Bluetooth v4.2 (BLE)GPIO-Pins19 digitale Pins (I2C, SPI, UART, PWM, ADC)SchnittstellenI2C, SPI, UART, PWM, ADCTastenTaster A, Taster B, kapazitiver Touch Sensor Reset-TasterSensorenMikrofon, Lichtsensor, Temperatur & Luftfeuchtesensor, 3-Achsen LagesensorAktorenPiezoBuzzer, 7x5 RGB-LED MatrixSonstigesSD-Kartenslot, PH2.0 Anschluss für LiPo BatterienProgrammierbar mitArduino IDE, MicroPython, MakeCode (ESP32-Erweiterung)Abmessungenca. 60 × 40 mmAnschlussUSB-CGewichtca. 14 gKompatibilitätWindows, macOS, Linux Was sofort auffällt - Der Fox:bit setzt komplett auf USB-C, statt wie viele Lernboards auf micro-USB. - WLAN und Bluetooth sind direkt integriert, was drahtlose Projekte ohne Zusatzmodule ermöglicht. - Die kompakte Bauform und das sympathische Design mit den „Ohren“ machen ihn nicht nur technisch, sondern auch optisch zu einem Hingucker.

Aufbau des Fox:bit – Anschlüsse, Sensoren & Aktoren im Überblick

Der Fox:bit von Keyestudio ist nicht nur leistungsstark, sondern auch clever aufgebaut. Alle wichtigen Schnittstellen, Sensoren und Aktoren sind direkt auf der Platine integriert und gut zugänglich – ideal, um ohne zusätzliche Module sofort mit spannenden Projekten zu starten.

Um dir einen besseren Überblick zu geben, habe ich eine Grafik der Vorder- und Rückseite erstellt. Darin sind alle wichtigen Komponenten, Pins und Funktionen markiert 👇

Aufbau - Mikrocontroller Foxbit von Keyestudio

In der folgenden Tabelle findest du alle Onboard-Ressourcen inklusive der zugehörigen GPIO-Pins im Überblick 👇

Fox:bit – On-board-Ressourcen & GPIO-Zuordnung ModulBeschreibungInterfaceGPIOButton ADigitaler Taster ADigitalGPIO0Button BDigitaler Taster BDigitalGPIO4TouchKapazitive TasteTouchGPIO27IMU (QMI8658C)6-Achs-SensorI²CSDA=GPIO21, SCL=GPIO22LichtsensorUmgebungshelligkeitAnalogGPIO39MikrofonSchalldetektionAnalogGPIO35BuzzerPiezo-AusgabeDigital/PWMGPIO335×7 RGB-Matrix35× WS28121-Draht (NeoPixel)GPIO13Temp/Feuchte (AHT20)Messung T/RHI²CSDA=GPIO21, SCL=GPIO22SD-KartenerweiterungSpeicherSPICS=GPIO5, MOSI=GPIO23, MISO=GPIO19, SCK=GPIO18StromerfassungCurrent SenseAnalogGPIO36

Für wen ist der Fox:bit Mikrocontroller gedacht?

Bevor es an die Programmierung geht, lohnt sich ein Blick auf die Zielgruppe des Fox:bit von Keyestudio. In erster Linie ist er ein kompakter Lern-Mikrocontroller, der sich ideal für den Einstieg in die Welt der Elektronik und Programmierung eignet. Er spricht Schüler, Studierende und Maker gleichermaßen an – also alle, die ohne viel Aufwand eigene Projekte umsetzen möchten.

Was ich persönlich am Fox:bit besonders reizvoll finde: Man muss keine aufwendige Schaltung mehr aufbauen, wenn man nur schnell etwas testen will. Braucht man zum Beispiel einen Sensor oder möchte eine Idee mit einem Mikrocontroller ausprobieren, greift man einfach zum Fox:bit – steckt ihn an, öffnet die Arduino IDE oder MicroPython-Umgebung und kann direkt loslegen.

So wird aus dem kleinen Board ein praktisches Werkzeug für Prototyping, Bildung und Experimente. Ganz gleich, ob im Klassenzimmer, im Makerspace oder auf dem heimischen Schreibtisch – der Fox:bit ist immer bereit für das nächste Projekt.

Alles klar — ab in die Praxis! Hier ist ein kompakter Abschnitt „Erste Schritte mit MicroPython auf dem Fox:bit“ inkl. Setup und direkt lauffähiger Beispielcodes für die wichtigsten Onboard-Module.

Erste Schritte mit MicroPython (Fox:bit / ESP32)

Bevor es losgeht: MicroPython auf den Fox:bit flashen

Bevor wir den Fox:bit in MicroPython programmieren können, muss auf dem Mikrocontroller zunächst die passende MicroPython-Firmware installiert werden. Das klingt komplizierter, als es ist – denn mit der Thonny IDE geht das ganz einfach. Thonny bietet ein integriertes Tool, mit dem sich die Firmware direkt auf den Mikrocontroller flashen lässt – ganz ohne zusätzliche Software oder Kommandozeilen-Befehle.

Konfiguration zum flashen des Fox:bit in Thonny

Wenn das flashen des Mikrocontrollers erfolgreich war, dann wird in der Konsole folgendes Ausgegeben:

MPY: soft reboot MicroPython v1.26.1 on 2025-09-11; Generic ESP32 module with ESP32 Type "help()" for more information.

Hier können wir auch ablesen welche Version installiert wurde, in meinem Fall die neueste vom 11.09.2025.

Pin-Zentrale anlegen

Lege dir eine kleine Datei foxbit_pins.py an – so bleibt alles konsistent:

PINS = { "BTN_A": 0, "BTN_B": 4, "TOUCH": 27, "I2C_SDA": 21, "I2C_SCL": 22, "LIGHT_ADC": 39, "MIC_ADC": 35, "BUZZER": 33, "NEOPIXEL": 13, "SD_CS": 5, "SD_MOSI": 23, "SD_MISO": 19, "SD_SCK": 18, "CURR_ADC": 36, } Schnelltests (funktioniert alles?) I²C-Scan (AHT20 & IMU sichtbar?) from machine import I2C, Pin from foxbit_pins import PINS i2c = I2C(0, scl=Pin(PINS), sda=Pin(PINS), freq=400_000) print("I2C Geräte:", ) Buttons & Touch from machine import Pin, TouchPad from time import sleep from foxbit_pins import PINS btn_a = Pin(PINS, Pin.IN, Pin.PULL_UP) btn_b = Pin(PINS, Pin.IN, Pin.PULL_UP) touch = TouchPad(Pin(PINS)) while True: if btn_a.value() == 0: print("Button A") sleep(0.25) if btn_b.value() == 0: print("Button B") sleep(0.25) if touch.read() < 350: print("Touch!") sleep(0.25) sleep(0.05)

Das kleine Script erzeugt nachfolgende Ausgabe wenn man nacheinander die Tasten betätigt. Dabei ist der aufruf der Funktion "sleep(0.25)" für das entprellen der Taster zuständig.

Ausgabe der Tasten in der Konsole in Thonny Onboard-Module nutzen RGB-LED-Matrix (WS2812 / NeoPixel) import machine, neopixel, time from foxbit_pins import PINS NUM = 35 # 5x7 Matrix np = neopixel.NeoPixel(machine.Pin(PINS), NUM) # alle rot, dann aus np.fill((20, 0, 0)); np.write(); time.sleep(0.8) np.fill((0, 0, 0)); np.write() # Laufschleife über die Pixel for i in range(NUM): np.fill((0,0,0)) np = (0, 0, 30) np.write() time.sleep(0.03)

Die kleinen NeoPixel sind sehr leuchtstark und daher drossel ich im Code diese massiv.

Keyestudio Foxbit - Test NeoPixel Buzzer (Ton/PWM) from machine import Pin, PWM from time import sleep_ms, sleep from foxbit_pins import PINS # Taster mit Pull-Up (0 = gedrückt) btn_a = Pin(PINS, Pin.IN, Pin.PULL_UP) # Buzzer-Pin zuerst sicher auf LOW ziehen buzz_pin = Pin(PINS, Pin.OUT, value=0) p = PWM(buzz_pin) p.duty_u16(0) # stumm im Idle def play_sequence(): for f in (523, 659, 784, 1046): # C5, E5, G5, C6 p.freq(f) p.duty_u16(20000) # Lautstärke sleep_ms(150) p.duty_u16(0) # wieder stumm while True: state = btn_a.value() if state == 0: play_sequence() sleep(0.25) sleep_ms(10)

Wenn man den Taster A betätigt wird eine kleine Tonfolge auf dem Piezo Buzzer abgespielt.

Lichtsensor & Mikrofon (ADC) from machine import ADC, Pin from time import sleep from foxbit_pins import PINS light = ADC(Pin(PINS)) mic = ADC(Pin(PINS)) light.atten(ADC.ATTN_11DB) # vollen Bereich nutzen mic.atten(ADC.ATTN_11DB) for _ in range(50): l = light.read_u16() m = mic.read_u16() print("Lux-Proxy:", l, "Mic-Level:", m) sleep(0.1)

Der Lichtsensor reagiert schon auf kleinste veränderungen an der Helligkeit hier reicht es eigentlich auch schon aus mit der Hand darüber zu wischen.

Fazit & Ausblick

Der Fox:bit von Keyestudio zeigt eindrucksvoll, wie vielseitig moderne Lern-Mikrocontroller geworden sind. Dank ESP32-Power, vielen integrierten Sensoren und MicroPython-Support ist er mehr als nur ein Einsteigerboard – er ist ein echtes Entwicklungswerkzeug für Maker, Schüler und Lehrkräfte.

Wer den BBC micro:bit kennt, wird sich beim Fox:bit sofort zurechtfinden – bekommt aber deutlich mehr Leistung, Speicher und Flexibilität.

In einem der nächsten Beiträge zeige ich, wie man mit dem Fox:bit eine kleine Wetterstation mit Temperaturanzeige auf der RGB-Matrix baut. 🌤️ Bleib also dran, wenn du mehr aus dem kleinen Fuchs rausholen willst!

[draegerit]

Was ist n8n – und wie kann es mir im Smarthome und mit Mikrocontrollern Arbeit abnehmen?

Die Open-Source-Plattform n8n wurde ursprünglich entwickelt, um Geschäftsprozesse zu automatisieren. In Unternehmen kommt sie vor allem dort zum Einsatz, wo regelmäßig wiederkehrende Aufgaben anfallen – etwa beim Datenaustausch zwischen Systemen, bei E-Mail-Benachrichtigungen oder in Kombination mit KI-gestützten Workflows. Ziel ist es, Abläufe zu vereinfachen, Fehler zu vermeiden und Zeit zu sparen.

Doch n8n lässt sich nicht nur im Business-Umfeld einsetzen. Durch seine Offenheit und die über 400 verfügbaren Schnittstellen (Nodes) bietet sich das Tool auch für völlig andere Einsatzgebiete an – beispielsweise im Smarthome oder im Bereich Mikrocontroller.

Hier liegen die Möglichkeiten auf der Hand: Ein Sensor sendet Messwerte an den Raspberry Pi, n8n verarbeitet sie und löst eine Aktion aus – etwa eine Push-Nachricht, das Schalten eines Shelly-Geräts oder das Speichern der Werte in einer Tabelle. Und das Beste: All das funktioniert mit wenig oder ganz ohne Code, direkt über eine grafische Oberfläche und ohne Cloud-Zwang.

Gerade wer sich schon mit dem ESP32, Arduino oder ähnlichen Boards beschäftigt, kann mit n8n viele kleine Routinen und Automatisierungen abbilden, ohne eigene Programme schreiben zu müssen. Damit wird n8n zu einem spannenden Bindeglied zwischen klassischer Software-Automatisierung und den kreativen DIY-Projekten aus der Maker-Welt.

Was ist n8n – und wie funktioniert es?

n8n (ausgesprochen „n-eight-n“) ist eine Open-Source-Automatisierungsplattform, mit der sich Abläufe aus verschiedenen Anwendungen miteinander verknüpfen lassen – ganz ohne klassische Programmierung. Die Idee dahinter: anstatt für jede Aufgabe ein eigenes Script zu schreiben, werden Abläufe visuell als sogenannte Workflows aufgebaut.

n8n - Workspace

Ein Workflow in n8n besteht immer aus drei Grundbausteinen:

- Trigger – Ein Auslöser startet den Prozess. Das kann zum Beispiel ein eintreffender Webhook, eine Zeitsteuerung oder eine neue Nachricht in einem Dienst wie Telegram sein. - Action – Eine oder mehrere Aktionen, die nacheinander ausgeführt werden. Zum Beispiel eine HTTP-Anfrage, das Speichern eines Datensatzes oder das Senden einer Benachrichtigung. - Result – Das Ergebnis, also die ausgeführte Handlung oder erzeugte Antwort.

Alles geschieht in einer grafischen Benutzeroberfläche, in der du einzelne Nodes (Knoten) einfach per Drag & Drop verbindest. So entsteht Schritt für Schritt dein eigener Automatisierungs-Workflow – übersichtlich, nachvollziehbar und jederzeit anpassbar.

Flexibel und erweiterbar

n8n bringt bereits über 400 integrierte Schnittstellen mit, etwa für:

- HTTP-Anfragen, Webhooks und APIs - E-Mail-Dienste - Datenbanken und Google Sheets - Smarthome-Geräte (z. B. über MQTT oder REST) - KI-Modelle wie OpenAI oder HuggingFace

Darüber hinaus können über die Community-Nodes zusätzliche Erweiterungen installiert werden. Fortgeschrittene Anwender können sogar eigene Knoten mit JavaScript schreiben und so individuelle Funktionen integrieren.

Datenschutzfreundlich und selbst gehostet

Ein entscheidender Vorteil gegenüber anderen Plattformen wie Zapier oder Make liegt im Self-Hosting. n8n kann vollständig lokal auf einem Raspberry Pi oder Server betrieben werden, ohne dass Daten an externe Clouds gesendet werden. Gerade im Smarthome-Bereich ist das ein großer Pluspunkt, da sensible Informationen – etwa Sensordaten oder Zugriffsdaten – im eigenen Netzwerk bleiben.

Der typische Ablauf

Ein einfaches Beispiel verdeutlicht das Prinzip: Ein Bewegungssensor sendet beim Auslösen ein Signal an den ESP32 → dieser ruft über HTTP einen Webhook in n8n auf → n8n reagiert darauf und sendet automatisch eine Push-Benachrichtigung auf dein Smartphone.

Ohne zusätzliche Cloud-Dienste, ohne komplizierte Programmierung – und alles läuft direkt auf deinem eigenen System.

Warum passt n8n perfekt zum Smarthome?

Die meisten Smarthome-Systeme sind auf eine bestimmte Plattform oder App festgelegt. Wer Geräte unterschiedlicher Hersteller kombiniert, stößt schnell an Grenzen – besonders, wenn Sensoren, Aktoren oder Mikrocontroller aus verschiedenen Welten stammen. Genau hier spielt n8n seine Stärken aus.

n8n kann als zentrale Schaltstelle zwischen all diesen Systemen dienen. Über die vielen Schnittstellen (Nodes) lassen sich Geräte, Webdienste und APIs miteinander verbinden, ohne dass eine einzige Zeile Code notwendig ist. So entstehen Automatisierungen, die über die Möglichkeiten einzelner Apps oder Cloud-Dienste weit hinausgehen – und das völlig herstellerunabhängig.

Beispiel 1: Sensorwerte auswerten und reagieren

Ein ESP32 misst Temperatur und Luftfeuchtigkeit und sendet die Daten per HTTP an einen Webhook in n8n. Dort prüft ein Function Node, ob der Wert über einem bestimmten Grenzwert liegt. Falls ja, wird automatisch eine Benachrichtigung über Telegram oder ein Eintrag in Google Sheets ausgelöst.

n8n Workflow - ESP32 - Temperatur in Google Sheets schreiben Quellcode für den ESP32-S3 Zero mit DHT11 Sensor #include #include #include // === WiFi-Zugangsdaten === const char* ssid = "abc"; const char* password = "12345678"; // === DHT11 an GPIO1 === DHT11 dht11(1); // === Webserver auf Port 80 === WebServer server(80); // === Hilfsfunktion: Temperatur auslesen === float readTemperatureC() { int t = dht11.readTemperature(); if (t == DHT11::ERROR_CHECKSUM || t == DHT11::ERROR_TIMEOUT) { Serial.println(DHT11::getErrorString(t)); return NAN; } return (float)t; } // === Handler für Root-Seite === void handleRoot() { float tempC = readTemperatureC(); float tempF = (tempC * 9.0 / 5.0) + 32.0; if (isnan(tempC)) { server.send(500, "application/json", "{"error": "Fehler beim Lesen des DHT11 Sensors"}"); return; } // JSON-Antwort erstellen String json = "{"; json += ""temperature_c": " + String(tempC, 1) + ","; json += ""temperature_f": " + String(tempF, 1); json += "}"; // HTTP-Antwort senden server.send(200, "application/json", json); } void setup() { Serial.begin(115200); delay(1000); Serial.println("nStarte ESP32-S3 DHT11 Webserver..."); // WLAN verbinden WiFi.begin(ssid, password); Serial.print("Verbinde mit WLAN: "); Serial.println(ssid); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println("nWLAN verbunden!"); Serial.print("IP-Adresse: "); Serial.println(WiFi.localIP()); // Webserver-Routen definieren server.on("/get", handleRoot); server.begin(); Serial.println("Webserver gestartet. Rufe im Browser die IP-Adresse + /get auf."); } void loop() { server.handleClient(); }

Ausgabe auf der Konsole:

Starte ESP32-S3 DHT11 Webserver... Verbinde mit WLAN: FRITZBox7590GI24 ............................ WLAN verbunden! IP-Adresse: 192.168.178.131 Webserver gestartet. Rufe im Browser die IP-Adresse + /get auf.

Ausgabe der Sensordaten im JSON Format wenn die Adresse die Adresse http:///get aufgerufen wird.

{"temperature_c": 24.0,"temperature_f": 75.2}

So kannst du dir z. B. eine Warnung schicken lassen, wenn die Luftfeuchtigkeit im Keller steigt oder die Temperatur in deinem Gewächshaus zu hoch wird.

Beispiel 2: Geräte automatisch schalten

Über die REST-API von Shelly- oder Tasmota-Geräten kann n8n direkt mit deinem Smarthome interagieren. Ein typisches Szenario: Wenn der air-Q-Sensor eine schlechte Luftqualität meldet, schaltet n8n automatisch einen Shelly Plug ein, der einen Luftreiniger oder Ventilator versorgt.

Shelly - n8n einfacher Workflow umschalten eines zustandes

Der gesamte Ablauf läuft lokal auf dem Raspberry Pi und funktioniert sogar ohne Internetverbindung – schnell, zuverlässig und datenschutzfreundlich.

Beispiel 3: Push-Benachrichtigung vom Mikrocontroller

Du kannst n8n auch als „Postverteiler“ für deine Mikrocontroller einsetzen. Ein ESP32-C3 meldet das Öffnen des Briefkastens per HTTP-Request an n8n. Dieser löst dann eine Push-Nachricht an dein Smartphone aus oder trägt das Ereignis mit Zeitstempel in eine Tabelle ein.

Ein klassisches DIY-Projekt, das du mit wenigen Klicks erweitern kannst – etwa, um die Daten zusätzlich zu loggen oder den Status über ein Dashboard anzuzeigen.

Zusammengefasst:

- n8n verbindet Geräte und Webdienste, die sonst nicht miteinander kommunizieren könnten. - Alle Automatisierungen lassen sich grafisch abbilden – kein komplizierter Code notwendig. - Du entscheidest, ob alles lokal oder über die Cloud laufen soll. - Ideal für Maker, Bastler und Smarthome-Fans, die ohne teure Systeme eigene Ideen umsetzen möchten.

Alternativen zu n8n: Zapier und Make

Neben n8n gibt es noch zwei weitere große Plattformen, die sich auf Automatisierungen spezialisiert haben: Zapier und Make (früher Integromat). Alle drei Tools verfolgen das gleiche Ziel – wiederkehrende Aufgaben zu automatisieren, indem Aktionen miteinander verknüpft werden.

Der größte Unterschied liegt allerdings in der Philosophie und Flexibilität:

- Zapier richtet sich eher an Einsteiger und Business-Nutzer, die schnell und ohne technisches Wissen einfache Workflows aufbauen möchten. Die Plattform bietet tausende Integrationen, ist aber rein Cloud-basiert und weniger anpassbar. - Make ist deutlich visueller und erlaubt komplexe Abläufe mit Verzweigungen, Schleifen und Bedingungen. Auch hier liegt der Fokus auf Cloud-Automatisierung, was für private Projekte oder Smarthome-Szenarien weniger attraktiv sein kann. - n8n dagegen ist Open Source und lässt sich selbst hosten, beispielsweise auf einem Raspberry Pi. Dadurch bleiben alle Daten im eigenen Netzwerk – ein entscheidender Vorteil, wenn Datenschutz und Unabhängigkeit wichtig sind.

Gerade für Maker, Smarthome-Enthusiasten und Entwickler, die gern selbst die Kontrolle behalten, ist n8n deshalb oft die bessere Wahl. Es kombiniert die Offenheit klassischer Softwareentwicklung mit der Einfachheit einer grafischen Oberfläche – und das völlig kostenlos.

Fazit & Ausblick

n8n zeigt eindrucksvoll, wie einfach sich komplexe Automatisierungen umsetzen lassen – und das ganz ohne Cloud-Zwang oder komplizierte Programmierung. Ursprünglich für den Einsatz in Unternehmen entwickelt, eröffnet die Plattform auch für Maker, Bastler und Smarthome-Enthusiasten völlig neue Möglichkeiten. Gerade im Zusammenspiel mit Mikrocontrollern wie dem ESP32 lassen sich Datenflüsse, Benachrichtigungen und Steuerungen so einfach realisieren, wie man es bisher kaum kannte.

Die Kombination aus visuellen Workflows, Open-Source-Freiheit und der Möglichkeit, alles lokal zu betreiben, macht n8n zu einem spannenden Werkzeug für alle, die ihre Projekte smarter und effizienter gestalten möchten.

Wie geht’s weiter?

Im nächsten Schritt werde ich meinen Raspberry Pi 4 B schnappen und darauf n8n in einem Docker-Container installieren. Natürlich folgt dazu ein ausführlicher Beitrag mit Anleitung und Screenshots, damit du das Ganze bei dir nachbauen kannst.

Da der Pi in Sachen Leistung nicht ganz mit einem Desktop-System mithalten kann, wird die KI-Unterstützung vermutlich weiterhin extern erfolgen – aber auch das werde ich in einem späteren Beitrag genauer beleuchten und testen.

Es bleibt also spannend – n8n hat definitiv das Potenzial, fester Bestandteil zukünftiger Smarthome- und Mikrocontroller-Projekte zu werden.

FAQ – Häufige Fragen zu n8n

Was ist n8n eigentlich?

n8n ist eine Open-Source-Plattform zur Workflow-Automatisierung. Damit lassen sich Aufgaben zwischen verschiedenen Anwendungen oder Geräten automatisieren – ganz ohne klassische Programmierung.

Kann ich n8n kostenlos nutzen?

Ja. Die Open-Source-Version von n8n ist kostenlos und kann lokal, zum Beispiel auf einem Raspberry Pi, betrieben werden. Alternativ bietet der Hersteller auch eine gehostete Cloud-Version an.

Ist n8n sicher?

Ja, wenn du n8n selbst hostest, bleiben alle Daten in deinem eigenen Netzwerk. Damit ist die Lösung besonders datenschutzfreundlich und unabhängig von externen Cloud-Diensten.

Kann ich n8n auch mit Mikrocontrollern verwenden?

Absolut! n8n lässt sich hervorragend mit Geräten wie dem ESP32 kombinieren. So kannst du Sensordaten erfassen, verarbeiten und Aktionen wie Benachrichtigungen oder Gerätesteuerungen auslösen – ganz ohne zusätzliche Cloud-Services.

Was sind Alternativen zu n8n?

Bekannte Alternativen sind Zapier und Make (ehemals Integromat). Beide bieten ähnliche Funktionen, sind jedoch Cloud-basiert und weniger flexibel, wenn es um Self-Hosting oder Datenschutz geht.

[draegerit]

Klein, aber oho: Was der neue Arduino Nano R4 wirklich drauf hat

Auf den ersten Blick wirkt er wie ein ganz normaler Arduino Nano V3 – klein, kompakt, mit den typischen Pins links und rechts. Doch dieser Schein trügt: Der neue Arduino Nano R4 bringt die volle Leistung des UNO R4 Minima in das winzige Nano-Format. https://youtu.be/W9SpRIS5vrE Damit steht erstmals ein Nano zur Verfügung, der nicht mehr auf der alten 8-Bit-Technik basiert, sondern mit einem modernen 32-Bit ARM Cortex-M4 Prozessor ausgestattet ist. Kurz gesagt: gleiche Power wie der UNO R4 Minima – aber im Taschenformat. In meinen bisherigen Beiträgen habe ich bereits den UNO R4 Minima im Vergleich zum UNO R3 vorgestellt und praktische Programmierbeispiele gezeigt. Jetzt ist es an der Zeit, die kleine Version genauer unter die Lupe zu nehmen.

👉 Wie unterscheidet sich der Nano R4 vom UNO R4 Minima? Und warum könnte er dein nächster Favorit für kompakte Projekte werden? Transparenz-Hinweis: Den Arduino Nano R4 habe ich mir selbst gekauft. Ich stehe in keiner Verbindung zu Arduino.cc und erhalte keinerlei Vorteile oder Bezahlung für diesen Beitrag. Mein Review basiert ausschließlich auf meinen eigenen Erfahrungen mit diesem Mikrocontroller.

Schneller Überblick: Technische Daten im Vergleich

Bevor wir tiefer in die Details einsteigen, lohnt sich ein direkter Blick auf die technischen Daten. In der folgenden Tabelle habe ich den neuen Arduino Nano R4 den beiden bekannten Boards Arduino Nano V3 und Arduino UNO R4 Minima gegenübergestellt. So erkennst du sofort, wo die größten Unterschiede liegen – und warum der Nano R4 auf den ersten Blick zwar unscheinbar wirkt, unter der Haube aber echte Power mitbringt. Feature / Board Arduino Nano V3 Arduino Nano R4 Arduino UNO R4 Minima Microcontroller ATmega328P (8-bit) Renesas RA4M1 (32-bit, ARM Cortex-M4) Renesas RA4M1 (32-bit, ARM Cortex-M4) Taktfrequenz 16 MHz 48 MHz 48 MHz Flash-Speicher 32 kB 256 kB 256 kB RAM 2 kB 32 kB 32 kB EEPROM 1 kB 8 kB 8 kB Digitale I/Os 14 21 14 Analoge Eingänge 8 8 6 PWM-Pins 6 6 6 DAC – 1 (A0) 1 (A0) OpAmp – A1, A2, A3 A1, A2, A3 Kommunikation UART, I²C, SPI 1×UART, 2×I²C (inkl. Qwiic), SPI, CAN 1×UART, 2×I²C, SPI, CAN USB-Port Mini-USB USB-C USB-C Betriebsspannung 5 V 5 V 5 V VIN 7–12 V 6–21 V 6–24 V Abmessungen 18 × 45 mm 18 × 45 mm 25 × 68 mm

Design & Erster Eindruck

Auf den ersten Blick erinnert der neue Arduino Nano R4 stark an den klassischen Nano V3: kompakte Bauform, gleiche Pin-Reihen, vertrautes Layout. Aber bei genauerem Hinsehen offenbaren sich moderne Details wie USB-C, eine programmierbare RGB-LED oder der Qwiic-Anschluss für I²C-Erweiterungen.

v.l.n.r. - Arduino UNO R4 Minima - Arduino Nano ESP32 - Arduino Nano V3 - Arduino Nano R4 Natürlich gibt es heute schon eine ganze Reihe von Mikrocontrollern im Nano-Format, die ebenfalls mit Micro-USB oder USB-C ausgestattet sind – viele davon basieren allerdings auf dem ESP32. Diese Boards bieten oft noch mehr Rechenleistung, WLAN und Bluetooth an Bord und spielen damit in einer ganz anderen Leistungsklasse.

Der Unterschied: Der Arduino Nano R4 setzt bewusst nicht auf einen ESP32, sondern auf den Renesas RA4M1 Cortex-M4. Damit positioniert er sich als offizieller Arduino-Nachfolger mit voller IDE-Kompatibilität, einfacher Library-Unterstützung und einem Ökosystem, das vor allem Einsteiger und Prototyping-Fans anspricht. Kurz gesagt: nicht der stärkste Nano am Markt – aber der verlässlichste und am besten integrierte.

Besondere Features im Detail

RGB-LED + klassische Status-LED Eine kleine, aber sehr praktische Neuerung ist die integrierte RGB-LED. Sie kann beliebige Farben darstellen und eignet sich ideal, um Systemzustände oder Sensordaten visuell darzustellen. Ob grün für „alles läuft“, rot für „Fehler“ oder blau für „Verbindung hergestellt“ – so bekommst du sofort ein optisches Feedback direkt am Board. Wichtig zu wissen: Die RGB-LED ersetzt nicht die klassische „Buildin-LED“ am Pin D13. Diese ist nach wie vor vorhanden, beim Nano R4 liegt sie links neben dem USB-C-Port und leuchtet in einem gelb/orangen Farbton. Damit hast du sogar zwei LEDs on Board: - 🔸 D13 LED → wie gewohnt für schnelle Tests und Debugging - 🌈 RGB-LED → frei programmierbar für mehrfarbige Anzeigen Ein einfaches Beispiel zum Ansteuern der RGB-LED sieht so aus: /* Arduino Nano R4 – RGB-LED Beispiel Autor: Stefan Draeger Beschreibung: Dieses Beispiel zeigt, wie man die eingebaute RGB-LED am Arduino Nano R4 über eine Funktion mit drei Parametern ansteuert. Parameter: setRGB(red, green, blue) - red → Helligkeit der roten LED (0 = AUS, 255 = volle Helligkeit) - green → Helligkeit der grünen LED (0 = AUS, 255 = volle Helligkeit) - blue → Helligkeit der blauen LED (0 = AUS, 255 = volle Helligkeit) */ void setup() { // Definiere die drei Pins für die RGB-LED als Ausgänge pinMode(LEDR, OUTPUT); pinMode(LEDG, OUTPUT); pinMode(LEDB, OUTPUT); } // Hilfsfunktion zum Setzen der RGB-Farbe void setRGB(uint8_t red, uint8_t green, uint8_t blue) { /* Wichtig: Die RGB-LED am Nano R4 ist *active low*. Das bedeutet: - LOW (0) → LED AN - HIGH (1) → LED AUS Mit analogWrite() (PWM) können wir Helligkeiten steuern. Damit das korrekt funktioniert, müssen wir die Werte invertieren. */ analogWrite(LEDR, 255 - red); // Rot steuern analogWrite(LEDG, 255 - green); // Grün steuern analogWrite(LEDB, 255 - blue); // Blau steuern } void loop() { // Rot setRGB(255, 0, 0); delay(500); // Grün setRGB(0, 255, 0); delay(500); // Blau setRGB(0, 0, 255); delay(500); // Weiß (alle Farben an) setRGB(255, 255, 255); delay(500); // Aus setRGB(0, 0, 0); delay(500); } Qwiic-Connector – Sensoren ohne Löten in Sekunden anschließen Ein weiteres Highlight des Arduino Nano R4 ist der eingebaute Qwiic-Anschluss. Damit lassen sich Sensoren und Aktoren ganz ohne Löten mit nur einem Kabel verbinden. Statt wie bisher Dupont-Kabel an die I²C-Pins zu klemmen, genügt ein fertiges Qwiic-Kabel – einstecken, fertig.

Arduino Nano R4 mit APDS-9960 Gestensensor von Soldered 👉 Der Clou: Die Qwiic-Verbindungen sind kaskadierbar. Das bedeutet, du kannst mehrere Sensoren oder Module einfach hintereinander verbinden, ohne jedes Mal neue Pins am Mikrocontroller zu belegen. Ein Bus – viele Geräte.

Arduino Nano R4 mit Modulinos kaskadierend angeschlossen Arduino selbst bietet dafür die Modulino-Serie an – kleine Boards mit Sensoren und Aktoren, die perfekt auf den Qwiic-Port abgestimmt sind. Der Nachteil: Sie sind im offiziellen Shop nicht ganz günstig. Der Vorteil: absolute Plug & Play-Erfahrung, die gerade für Einsteiger oder schnelle Prototypen extrem praktisch ist.

Qwiic Sensoren auf Aliexpress Wer sparen möchte, findet im Qwiic-Ökosystem aber auch zahlreiche günstige Alternativen von anderen Herstellern. VRTC-Pin (RTC-Backup) Ein spannendes Detail des Arduino Nano R4 ist der VRTC-Pin. Dieser Anschluss ermöglicht es, eine kleine Knopfzelle oder einen Akku anzuschließen, um die eingebaute Echtzeituhr (RTC) des Mikrocontrollers mit Strom zu versorgen. 👉 Der Vorteil: Datum und Uhrzeit bleiben auch dann erhalten, wenn das Board nicht mehr über USB oder VIN mit Spannung versorgt wird. Damit eignet sich der Nano R4 besonders gut für Anwendungen wie Datenlogger, Timer oder zeitgesteuerte Schaltungen, bei denen eine zuverlässige Uhrzeit unabdingbar ist. Ein Vergleich mit den größeren Boards macht den Unterschied deutlich: - Der UNO R4 Minima verfügt nicht über einen VRTC-Pin. - Erst der UNO R4 WiFi bietet, ähnlich wie der Nano R4, separate Anschlüsse für die RTC-Backup-Versorgung – dort sind die Pins unten links am Board herausgeführt.

Arduino UNO R4 WiFi - VRTC Pins

Arduino Nano R4 - VRTC Pin Damit bietet der Nano R4 ein Feature, das man beim UNO R4 Minima vergeblich sucht – und das ihn für Projekte, bei denen eine exakte Zeit auch nach Stromausfall wichtig ist, besonders attraktiv macht. 💡 Hinweis: Ein praktisches Projekt, bei dem ich den VRTC-Pin des Nano R4 mit einer Knopfzelle, einem OLED-Display und einem Taster nutze, um eine Uhr mit Backup-Funktion aufzubauen, werde ich in einem separaten Beitrag veröffentlichen. DAC-Ausgang (A0) – analoge Signale statt PWM Ein echtes Highlight des Arduino Nano R4 ist der eingebaute DAC (Digital-Analog-Converter) am Pin A0. Damit lassen sich im Gegensatz zum klassischen Nano V3 nicht nur PWM-Signale, sondern tatsächlich stufenlose analoge Spannungen zwischen 0 V und 5 V erzeugen. Das eröffnet spannende Möglichkeiten – etwa für Audioausgaben oder einfache Signalgeneratoren. 💡 Hinweis: Ein ausführliches Praxisbeispiel mit Oszilloskop und Code, wie sich der Nano R4 als kleiner Frequenzgeber einsetzen lässt, veröffentliche ich in einem separaten Beitrag. Einseitig bestückt & Castellated Pins Der Arduino Nano R4 ist komplett einseitig bestückt – alle Bauteile befinden sich nur auf der Oberseite der Platine. Das erleichtert nicht nur die Fertigung, sondern macht ihn auch ideal für enge Gehäuse oder den direkten Einbau in eigene Projekte. Zusätzlich verfügt der Nano R4 über sogenannte Castellated Pins (halbkreisförmig eingefräste Lötpads). Damit lässt er sich wie ein SMD-Bauteil direkt auf eine eigene Platine löten – ein klarer Vorteil für Entwickler, die den Mikrocontroller fest in ihr Design integrieren möchten. Den Nano R4 gibt es in zwei Varianten: - Mit Header (Stiftleisten): Praktisch für Prototypen, Breadboards und alle, die flexibel bleiben möchten. - Ohne Header: Lässt sich platzsparend auf eigene Platinen löten und für kompakte Designs einsetzen. Ich persönlich bevorzuge trotz der Vorteile der Header-losen Version die Variante mit Stiftleisten. Denn so bleiben die Komponenten austauschbar, was langfristig ressourcenschonender ist: Geht einmal ein Mikrocontroller kaputt, muss nicht gleich das gesamte System ersetzt werden – man tauscht einfach das Board aus.

Mini-Praxis-Test mit dem Arduino Nano R4

Um den Nano R4 in Aktion zu zeigen, habe ich ihn auf das separat erhältliche Arduino Nano Connect Carrier Board gesteckt. Dieses kleine Zusatzboard erweitert den Nano um: - einen microSD-Kartenslot - vier Grove-Schnittstellen (für Sensoren und Aktoren) - sowie einen weiteren Qwiic-Anschluss

Damit ergeben sich sofort spannende Projektideen – von Datenloggern bis hin zu kleinen IoT-Systemen. IoT nachrüsten über Grove-Module Auch wenn der Arduino Nano R4 keine integrierte WiFi- oder Bluetooth-Schnittstelle mitbringt, ist er dank der Grove-Anschlüsse des Connect Carrier Boards leicht erweiterbar. Über die serielle Grove-Schnittstelle lassen sich passende Kommunikationsmodule einfach anschließen – ganz ohne Lötarbeiten.

Arduino Nano R4 - Nano Connect Carrier - serial ESP8266 Grove Modul So kannst du den Nano R4 bei Bedarf um WiFi oder BLE erweitern und damit auch in IoT-Projekten einsetzen. Der Vorteil: Du entscheidest selbst, ob dein Projekt wirklich eine drahtlose Verbindung benötigt – oder ob du den Mikrocontroller als standalone Logger oder Steuerung nutzen möchtest. 👉 Das macht den Nano R4 besonders flexibel: kompakt, ressourcenschonend und trotzdem offen für Erweiterungen, wenn dein Projekt es erfordert. OpAmp-Eingänge (A1–A3) – Signale direkt verstärken Eine Besonderheit des Arduino Nano R4 sind die analogen Pins A1 bis A3, die zusätzlich als Eingänge für den integrierten Operationsverstärker (OpAmp) genutzt werden können. Damit lassen sich schwache Sensorsignale direkt auf dem Mikrocontroller verstärken oder puffern – ganz ohne externe Schaltung. 👉 Für einfache Projekte spielt das oft keine Rolle, aber bei empfindlichen Sensoren (z. B. Mikrofon oder Lichtsensor) kann der eingebaute OpAmp ein echter Vorteil sein. So sparst du zusätzliche Bauteile und hältst deine Schaltung kompakt.

Preis & Verfügbarkeit

Der Arduino Nano R4 ist aktuell bei vielen Händlern erhältlich – sowohl direkt bei Arduino.cc als auch bei Distributoren wie reichelt.de oder botland.de. Preislich liegen die Boards nah beieinander, die Unterschiede ergeben sich vor allem durch Versandkosten und Lieferzeiten. Ich habe mein Exemplar bei reichelt.de bestellt: Der Preis war nur minimal höher als direkt bei Arduino.cc, dafür kam die Lieferung deutlich schneller an. Zwar liegen die Versandkosten bei Reichelt mit 5,95 € höher, aber bei Arduino.cc muss man trotz günstigerem Versand (3,50 €) längere Lieferzeiten aus Italien einkalkulieren. 👉 Mein Tipp: Wer es schnell braucht, ist mit einem lokalen Händler wie Reichelt besser bedient. Wer etwas warten kann, spart ein paar Euro bei Arduino.cc. Preisvergleich (Stand: 18.08.2025) HändlerPreisVersandkostenhttps://www.reichelt.de/12,80 €5,95 €https://store.arduino.cc/13,40 €3,50 €https://botland.de/13,50 €4,95 €

Fazit & Ausblick

Auf den ersten Blick wirkt der Arduino Nano R4 wie ein klassischer Nano, der lediglich ein längst überfälliges Update auf USB-C bekommen hat. Doch beim genaueren Hinsehen zeigt sich: Mit den zusätzlichen Schnittstellen wie CAN-Bus, DAC, OpAmp und dem Qwiic-Anschluss eröffnet das Board ein deutlich größeres Anwendungsspektrum. Damit eignet es sich nicht nur für Maker und Hobbyisten, sondern auch für komplexere IoT- und Embedded-Projekte. Die integrierte RGB-LED ist zwar kein echtes Alleinstellungsmerkmal mehr – inzwischen Standard bei vielen Boards – aber dennoch ein nettes Gimmick, das schnellen visuellen Feedback im Betrieb ermöglicht. 👉 Mein Fazit: Der Nano R4 ist eine gelungene Weiterentwicklung, die die vertraute Kompaktheit des Nano-Formfaktors mit der Leistung und den Features moderner 32-Bit-Controller verbindet. Für mich ein spannendes Board, das garantiert neue, coole Projekte inspirieren wird. Read the full article

[draegerit]

ESP32-C3: Der kleine Alleskönner für deine IoT-Projekte

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.

ESP32-C3 & Super Mini Arduino Nano Clone Ein wesentlicher Unterschied zum ESP32-C3 ist, dass dieser Mikrocontroller keine WiFi- oder Bluetooth-Schnittstellen bietet, was ihn weniger geeignet für IoT-Anwendungen macht. Allerdings kann dies, wenn die drahtlose Kommunikation im Projekt nicht benötigt wird, als Vorteil in Bezug auf den Stromverbrauch gesehen werden. Der geringere Stromverbrauch macht ihn zu einer attraktiven Wahl für Projekte, bei denen eine konstante Stromversorgung oder der Einsatz von Batterien erforderlich ist. Technische Daten im Vergleich: Super Mini ESP32-C3 vs. Super Mini Arduino Nano Clone Um die beiden Mikrocontroller besser zu vergleichen, findest du hier eine tabellarische Übersicht der technischen Daten: EigenschaftSuper Mini ESP32-C3Super Mini Arduino Nano CloneMicrocontrollerESP32-C3ATMEGA328Betriebsspannung3,3 bis 6 V5 VDigitale I/O-Pins11 (PWM-Unterstützung)22 (6 sind PWM)PWM-Ausgänge46Analoge Eingänge48Flash-Speicher4 MB32 kB (2 kB vom Bootloader verwendet)SRAM400 KB2 kB (ATmega328P)EEPROM-1 kB (ATmega328P)Taktfrequenz160 MHz16 MHzAbmessungen22,52 x 18 mm21 mm x 27 mmdrahtlose SchnittstellenBluetooth 5.0 WiFi-SchnittstellenUART, SPI, I2CUART, SPI, I2CFeatures-3x RGB LEDs Diese Übersicht zeigt die Unterschiede und Gemeinsamkeiten zwischen dem Super Mini ESP32-C3 und dem Super Mini Arduino Nano Clone und verdeutlicht, für welche Anwendungen jeder Mikrocontroller am besten geeignet ist. Read the full article

[draegerit]

Der Arduino DUE im Fokus: Leistungsstärke und Vielseitigkeit für Maker

Der Arduino DUE ist ein leistungsstarker Mikrocontroller, der sowohl Hobbybastlern als auch professionellen Entwicklern eine Fülle von Möglichkeiten bietet. Mit seinem robusten ARM Cortex-M3-Prozessor und einer Vielzahl von Ein- und Ausgangspins ermöglicht der Arduino DUE die Umsetzung anspruchsvoller Technikprojekte. Ob du ein Elektronikliebhaber bist, der seine eigenen Gadgets kreiert, oder ein erfahrener Entwickler, der komplexe Systeme entwickelt – der Arduino DUE ist ein zuverlässiger Partner. In diesem Artikel werden wir uns näher mit den Funktionen und Vorteilen des Arduino DUE befassen und sehen, warum er die erste Wahl für Projekte mit hohen Anforderungen ist.

Technische Daten des Arduino DUE

Hier zunächst ein Auszug aus den technischen Daten des Mikrocontrollers: MikrocontrollerAT91SAM3X8ETaktgeschwindigkeit84 MHzSpeicher512 KB Flash Speicher 96 KB (zwei Bänke 64KB + 32 KB)Betriebsspannung3.3 VEingangsspannung7 bis 12 Vminimale / maximale Eingangsspannung6 V / 16 Vmaximale Stromaufnahme für alle Ein/Ausgänge130 mAmaximale Stromaufnahme am 3.3 V Pin800 mAmaximale Stromaufnahme am 5 V Pin800 mAdigitale Eingänge / Ausgänge54 davon 12 PWM Pinsanaloge Eingänge12analoge Ausgänge2 (DAC)Abmaße (L x B)101,52 mm x 53,3 mmGewicht36 gAuszug aus den technischen Daten des Mikrocontrollers Arduino DUE Dieses ist nur ein kleiner Auszug, welchen ich von der offiziellen Seite zum Mikrocontroller https://store.arduino.cc/collections/boards/products/arduino-due entnommen habe.

Micro-USB Schnittstellen Der Mikrocontroller verfügt über diverse Schnittstelle, wovon als Erstes die beiden Micro-USB Schnittstellen ins Auge fallen. Diese beiden Schnittstellen sind auf der Rückseite mit NATIVE USB SAM3X und PROGRAMMING ATMEGA16U2 beschriftet.

Der Anschluss zum Programmieren des Mikrocontrollers PROGRAMMING ist über einen ATMEGA16U2 mit dem Chip SAM3X verbunden. Wenn du dein Programm über diesen Anschluss auf den Mikrocontroller hoch lädst, dann wird zuvor ein Hard-Reset ausgeführt und der Speicher geleert. Die Programmierung über diesen Anschluss ist meist zuverlässiger und funktioniert auch als Backup, wenn einmal die MCU SAM3X abgestürzt ist. Um die MCU direkt zu programmieren, wird der Anschluss mit der Bezeichnung NATIVE USB SAM3X verwendet. Wenn eine Verbindung mit 1200 baud hergestellt wird, dann wird zunächst der interne Speicher über ein Soft-Erase geleert und der Mikrocontroller neu gestartet. Der Soft-Erase Prozess ist rein Softwarebasiert und kann ggf. auch abstürzen, wenn dieses geschehen ist dann hilft die kleine Taste "ERASE" auf dem Board weiter.

Weitere programmierbare Schnittstellen Der Mikrocontroller hat natürlich auch die bekannten programmierbaren Schnittstellen wie: - UART (3x), - SPI, - CAN, - I2C

Arduino DUE - Übersicht der Schnittstellen

Schutz vor Kurzschluss & Überlast

Der Arduino DUE verfügt über eine selbst rücksetzende Sicherung, welche den USB-Port vor Überlast & Kurzschluss absichert. Wenn mehr als 500 mA an den USB-Anschluss angelegt werden, unterbricht die Sicherung automatisch die Verbindung, bis der Kurzschluss oder die Überlast beseitigt ist.

Besondere Features des Arduino DUE

Der Mikrocontroller hat so einige Features welche der Arduino UNO, Mega oder Nano V3 nicht hat. Zum einen ist der Mikrocontroller der erste mit einem 32-bit SAM Mikrochip. CAN (Controller Area Network) Am Mikrocontroller findest du die Pins CAN-RX & CAN-TX über diese beiden Pins kannst du den seriellen Bus verwenden und eine Übertragungsgeschwindigkeit bis zu 1 Mbit/s erreichen. Du findest zum Beispiel in einem Auto sehr viele von diesen Schnittstellen, denn hier ist Geschwindigkeit und Stabilität sehr wichtig. Mehr zum CAN-Bus System erfährst du auf der Wikipedia-Seite: Seite „Controller Area Network“. In: Wikipedia – Die freie Enzyklopädie. Bearbeitungsstand: 3. Juni 2023, 21:06 UTC. URL: https://de.wikipedia.org/w/index.php?title=Controller_Area_Network&oldid=234287301 (Abgerufen: 5. Juni 2023, 18:10 UTC) JTAG Schnittstelle zum Debuggen Zum Debuggen des Mikrocontrollers findest du ebenso eine spezielle Schnittstelle, an welche du einen speziellen separat erhältlichen Adapter anschließen kannst und so deinen Code zur Laufzeit analysieren kannst.

Programmieren in der Arduino IDE

Wie jeder andere Mikrocontroller lässt auch der Arduino DUE sich in der Arduino IDE programmieren. In der Entwicklungsumgebung wird dieser korrekt erkannt (wenn der Port "PROGRAMMING ATMEGA16U2" verwendet wird).

Arduino IDE - erkannter Mikrocontroller Arduino DUE Installieren des Boardtreibers für den Arduino DUE in der Arduino IDE Jedoch muss noch soweit noch nicht geschehen, der Treiber installiert werden. Dazu wählen wir den Mikrocontroller aus der aufgeklappten Auswahlbox aus und dann sollte unten rechts ein Dialog erscheinen, aus welchem wir die Schaltfläche "INSTALL MANUALLY" wählen.

Es sollte sich nun wiederum der Boardverwalter mit einer vorausgewählten Suche öffnen und das benötigte Installationspaket angezeigt werden. Hier müssen wir jetzt noch die Schaltfläche "INSTALL" wählen.

Wenn die Installation erfolgreich war, dann wird dieses ebenso im Boardverwalter mit dem Label " installed" angezeigt.

Ausblick & Projekte mit dem Mikrocontroller Arduino DUE

Durch die genannte CAN-BUS Schnittstelle gibt es besonders im Bereich gesicherte Datenübertragung interessante und spannende Projekte. Ich werde mir nun einmal ein paar Gedanken machen und schauen, welche Projekte speziell abgestimmt auf diesen Mikrocontroller möglich & vor allem sinnvoll sind. Read the full article

[draegerit]

Automatische Bewässerung mit dem BBC micro:bit

Eine automatische Bewässerung im Garten ist nicht nur praktisch, sondern auch sinnvoll. Denn sie ermöglicht eine gleichmäßige Bewässerung der Pflanzen, die notwendig ist, um ein gesundes Wachstum zu fördern. Zudem spart sie Zeit und Mühe, da man nicht ständig manuell gießen muss. Auch können durch eine automatische Bewässerung Wassermengen und Kosten gespart werden. https://youtu.be/ng9RiCTlWNM In diesem Beitrag möchte ich dir gerne zeigen, wie du das Kit von der Firma Cytron Technologies aufbaust und einsetzen kannst. Der Vorteil von diesem Kit ist, dass alles enthalten ist, was du für deine automatische Bewässerung benötigst. Okay, einzig der BBC micro:bit ist nicht enthalten, aber dieser kann ebenso über den Shop erworben werden.

Lieferumfang des Kits zum Aufbau einer automatischen Bewässerung mit einem Mikrocontroller

Das Kit enthält wie erwähnt alles, was du für den Aufbau benötigst, dazu zählt: - eine Anleitung (auf Englisch), - ein kapazitiver Bodenfeuchtesensor, - eine kleine Pumpe mit Schläuchen, - ein Mikro-Servo Typ 9g mit Anschlusskabel, - diverse Kleinteile zum Aufbau (Schrauben, Kabelbinder etc.)

Zusätzlich benötigen wir noch ein Gefäß für die Pumpe, hier habe ich mir einmal eine 2-Liter-Flasche aus dem örtlichen Baumarkt mit einem breiten Hals besorgt. Des Weiteren empfehle ich dir noch ein Gehäuse für die Schaltung, hier reicht auch schon eine Brotdose welche du im Sonderposten Markt wie Thomas Philips, Zimmermann oder auch bei Kik, T€di etc. finden kannst.

Benötigtes Werkzeug für den Aufbau

In dem Kit ist bereits ein kleiner Schraubendreher enthalten, zusätzlich benötigst du noch: - einen Seitenschneider, - eine Bohrmaschine, inkl. 14er Bohrer

Aufbau der automatischen Bewässerung mit dem BBC micro:bit

Der Aufbau mit einem Kit wie dem von Cytronic ist recht einfach, denn du hast nun alles für deine automatische Bewässerung da und musst dir theoretische keine Sorgen darum machen, wie diese Komponenten zusammenarbeiten müssen. Das Herzstück der Schaltung ist die Hauptplatine mit der Bezeichnung "REKA:BIT" auf welche wir die einzelnen Komponenten anschließen werden.

Schritt 1 - Anschluss des kapazitiven Bodenfeuchtesensors Als erstes schließen wir den Bodenfeuchtesensor an den Pin an den Pin P2:P12 am REKA:BIT Board an.

Aufbau des kapazitiven Bodenfeuchesensors Der Bodenfeuchtesensor von Cytronic verfügt über drei LEDs, welche den aktuellen Zustand anzeigen. - DRY - trocken, - MOIST - feucht, - WET - nass https://youtu.be/qkTMT7CV2VE Schritt 2 - Anschluss des Servomotors Bevor der Servomotor an das Board angeschlossen wird, muss dieser mit zwei doppelseitigen Klebepunkte an ebenso zwei Holzspicker verbunden werden. https://youtu.be/llz2XEaxYvI Wenn dieses geschehen ist, dann wird der Servo mit der Verlängerung (war bei mir bereits angeschlossen) an das REKA:BIT Board an den Pin S1 angeschlossen. Beim Anschluss der Verlängerung musst du ebenso Acht geben, dass du beim Einstecken auch Schwarz mit Braun, Rot mit Rot und Gelb mit Weiß verbindest. Schritt 3 - Anschluss der Pumpe an das REKA:BIT Board Die kleine Pumpe hat zwei Adern, eine Rote und eine Schwarze.

Diese beiden werden wie folgt mit dem Board verbunden: - Rot - M2A - Schwarz - M2B Zum Abschluss wird dann der Schlauch mit der Pumpe verbunden. Dieser sitzt sehr stramm auf der Öffnung, daher muss man ziemlich stark drücken. Es kann auch helfen, wenn man den Schlauch bei Draufdrücken etwas hin und her dreht. Wichtig Laut Anleitung würdest du noch das andere Ende des Schlauches mit dem Ruderhorn am Servomotor verbinden, das machen wir jedoch zunächst NICHT. Der Hintergrund ist dabei, dass wir zunächst den Servomotor ausrichten müssen. Das machen wir mit einem kleinen Programm, welcher ich dir in dem Abschnitt zur Programmierung zeigen werde.

Varianten des BBC micro:bit

Es gibt den BBC micro:bit in derzeit zwei Varianten. Zum einen den alten in der Version 1.5 und den neuen mit der Version 2.2. Beide haben jedoch das gleiche Pinout, somit kannst du auch das alte und günstige Model für deine automatische Bewässerung nutzen.

Der neue BBC micro:bit V2.2 hat zusätzlich noch eine Bluetoothschnittstelle und somit kannst du diesen auch aus der Ferne steuern.

Vorsicht beim Wiederverwenden eines BBC micro:bit

Ich verwende die Mikrocontroller in diversen Projekten, daher kann und wird auf dem Mikrocontroller bereits ein Programm laufen welches diverse Pins aktiviert / deaktiviert. Um hier nicht irgendwas zu zerstören, werde ich zunächst ein leeres Programm auf den BBC micro:bit aufspielen und danach mit der eigentlichen Programmierung beginnen. Hier bekommst du ein leeres Programm als HEX-Datei zum Download. leeres Projekt für den BBC micro:bitHerunterladen

Einstecken des BBC micro:bit in die REKA:BIT Platine

Den Mikrocontroller steckst du in die Platine so ein, dass die 5x5 LED Matrix nach oben zeigt.

Da die Schneidklemmen sehr stramm sitzen, bedarf es etwas Kraft, aber nur etwas!

Programmieren der automatischen Bewässerung mit MakeCode

Die Programmierung erfolgt in MakeCode von Microsoft welches du in einem beliebigen Browser aufrufen kannst.

Oberfläche von MakeCode von Microsoft Erstellen wir also zunächst ein neues Projekt, indem wir auf die Schaltfläche "Neues Projekt" (1) klicken. Im neuen Dialog vergeben wir dem Projekt einen Namen (2) und bestätigen dieses mit der Schaltfläche (3).

Erweiterung für das Board REKA:BIT hinzufügen Bevor wir die Schnittstellen des REKA:BIT Boards aus MakeCode heraus ansteuern können, müssen wir die Erweiterung REKA:BIT hinzufügen. Dazu klicken wir zunächst auf den Eintrag "Erweiterungen" (1), um danach nach "REKA:BIT" (2) zu suchen. In den Suchergebnissen wählen wir den Eintrag "reka:bit" (3) aus. Wenn die Einrichtung abgeschlossen ist, dann solltest du nun einen neuen Menüpunkt "REKA:BIT" (4) mit zusätzlichen Elementen finden.

Damit haben wir jetzt Zugriff auf die Schnittstellen und können die Pumpe, den kapazitiven Bodenfeuchtesensor und den Servomotor ansteuern bzw. auslesen. Wichtig Wenn du dein Programm, also die HEX-Datei auf den BBC micro:bit überspielst, dann darf das REKA:BIT Board nicht aktiv sein. Das heißt, du muss den Schalter oben links auf die Stellung OFF (oben) setzen. Wenn der Upload erfolgt ist, dann kannst du das Board wieder aktivieren (Stellung ON / unten).

Schritt 1 - Ausrichten des Servomotors Zunächst beenden wir den Aufbau und richten den Servomotor aus, um dann den Schlauch anzuschließen. In meinem Fall waren die Winkel

Hier jedoch der Code als HEX-Datei zum Download. Diesen kannst du wieder per Drag'n Drop auf das Laufwerk deines BBC micro:bit ziehen. Servomotor ausrichtenHerunterladen Schritt 2 - Funktion für die Bewegung des Servomotors Der Servomotor kann einen Winkel zwischen 0 und 90 Grad anfahren, dafür benötigt dieser eine Zeit X. In meinem Fall möchte ich das, dass Wasser um die Pflanze verteilt wird, daher steuere ich den 90° Winkel in drei Schritten, mit jeweils 0,5 Sekunden Pause an. Da der Code in MakeCode immer sehr lang wird, lagere ich diese Funktion aus.

MakeCode - ausgelagerte Funktion zum drehen des Servos Schritt 3 - Auslesen des Bodenfeuchtesensors Den Bodenfeuchtesensor haben wir an den Pin P2 angeschlossen, zunächst wollen wir den Wert auf Knopfdruck auslesen und auf der 5x5 LED Matrix anzeigen.

Den Bodenfeuchtesensor habe ich zunächst in ein Glas Wasser gestellt, dieses sorgt für die Anzeige der Grenzen (minimal & maximal). https://youtu.be/Rf1P5xYesCY Der maximale Wert für den Bodenfeuchtesensor liegt in meinem Fall bei 648 und der minimale Wert bei 480. Wobei der kleinste Wert von 480 ermittelt wurde, wo der Bodenfeuchtesensor im Glas Wasser stand und 648, wo dieser trocken war. Unsere Pflanze möchten wir natürlich gar nicht erst an die Grenze bringen und daher wähle ich im Code den Wert von 550. Schritt 4 - Bewässerung starten bei trockenem Boden Die beiden ermittelten Grenzen wollen wir nun nutzen, um die Pumpe zu aktivieren bzw. zu deaktivieren. Wenn du den BBC micro:bit in der Version 2.20 verwendest, dann kannst du auch zusätzlich noch einen Ton über den Piezo Buzzer ausgeben, wenn die Bewässerung gestartet wird.

Finales Programm

Mit dem letzten Schritt haben wir jetzt das Projekt abgeschlossen und unsere automatische Bewässerung fertiggestellt.

Hier nun das fertige Programm zum download. MakeCode Programm für die automatische Bewässerung mit dem BBC micro:bitHerunterladen

Fazit

Der Aufbau des Kits ist sehr einfach und es ist alles dabei, was man für den Aufbau einer automatischen Bewässerung benötigt. Leider musste ich feststellen, dass die Wasserpumpe das Gefäß leer saugt. Hier werde ich mir eine andere Lösung mit einem Relais und einer kleinen Solarpumpe einfallen lassen, damit dieses nicht geschieht. Auch musste ich den Schlauch kürzen, damit die Pumpe es überhaupt schafft das Wasser so weit zu fördern. Read the full article

[draegerit]

LuatOS System #1 - LEDs programmieren

In diesem Beitrag möchte ich dir zeigen, wie du LEDs am Mikrocontroller ESP32-C3 mit LuatOS System programmieren kannst.

ESP32-C3 mit LuatOS System - LEDs programmieren Im letzten Beitrag ESP32-C3 mit LuatOS System und im neuen YouTube Video ESP32-C3 mit LuatOS System programmieren habe ich dir gezeigt, wie du ein einfaches "Hello World!" auf der seriellen Schnittstelle ausgibst. Hier soll es nun darum gehen, wie du eine LED über die vorhandenen GPIO Pins steuerst.

Mikrocontroller ESP32-C3 mit LuatOS System

In diesem Beitrag verwende ich den bereits vorgestellten ESP32-C3 mit LuatOS System.

Vorderseite des ESP32-C3

Rückseite des ESP32-C3 mit Webadresse

ESP32-C3 Chip auf dem Mikrocontroller Bezug Den mir vorliegenden Mikrocontroller habe ich recht günstig über aliexpress.com für knapp 4 € inkl. Versandkosten erworben. Derzeit (stand 08.08.2022) habe ich leider keine andere Quelle für einen solchen Mikrocontroller gefunden.

Mikrocontroller ESP32-C3 mit LuatOS System auf aliexpress.com

Benötigte Ressourcen für den Nachbau

Wenn du die nachfolgenden kleinen Beispiele nachbauen möchtest, dann benötigst du folgende Ressourcen: - einen ESP32-C3 mit LuatOS System,- ein USB-C Datenkabel, - drei, 5 mm, LEDs (rot, gelb, grün), - drei 220 Ohm Widerstände, - ein 170 Pin Breadboard, sowie - diverse Breadboardkabel, 10 cm, männlich-männlich

Benötigte Bauteile für diesen Beitrag Tools für die Programmierung und den Upload des Programmes Des Weiteren benötigst du die Software Visual Studio Code für die Programmierung sowie die LuatTools für den Upload des Programmes.

Pinout des ESP32-C3

Für den Aufbau der Schaltung benötigen noch das Pinout des Mikrocontrollers, welches ich dir hier gerne zeigen möchte.

Pinout des ESP32-C3 von der Wikiseite https://wiki.luatos.com/chips/esp32c3/board.html Die Grafik habe ich von der Wiki-Seite https://wiki.luatos.com/chips/esp32c3/board.html entnommen. Auf dieser Seite findest du noch weitere Informationen zu den Pins und Features des Mikrocontrollers. Auf der Seite https://wiki.luatos.com/_static/bom/esp32c3.html findest du eine interaktive Sicht auf den hier verwendeten Mikrocontroller.

Programmieren einer LED am GPIO Pin des ESP32-C3 mit LuatOS System

Kommen wir jetzt zum eigentlichen Thema, dem Programmieren einer LED am ESP32-C3. Ich gehe in diesem Abschnitt davon aus, dass bei dir die Anwendung Visual Studio Code und die LuatTools installiert und lauffähig sind. https://youtu.be/2XDoAElBmSQ In diesem Video erläutere ich dir, wie du die Schaltung aufbaust und programmierst. Dieses Mal in englischer Sprache. Das Ganze war ein Wunsch einiger meiner Follower auf Instagram, ich hoffe somit einige mehr mit meinem Content zu erreichen. Aufbau der Schaltung Als Erstes wollen wir eine 5 mm LED an den GPIO0 des Mikrocontrollers anschließen, dafür benötigen wir neben der besagten LED noch einen Vorwiderstand von 220 Ohm, 2 Breadboardkabel sowie ein 170 Pin Breadboard.

Schaltung - 5 mm LED am ESP32-C3 mit LuatOS System Programmieren in Visual Studio Code Erstellen wir im zweiten Schritt nun das kleine Programm, um die 5 mm LED zum Blinken zu bringen. PROJECT = "LED" VERSION = "0.1" sys = require("sys") led = gpio.setup(0,0,gpio.PULLUP) local state = false sys.timerLoopStart(function() led(state and 0 or 1) log.info("led", state) state = not state end,500) sys.run() Nachdem wir nun eine LED zum Blinken gebracht haben, schließen wir eine weitere an und steuern diese im gleichen Intervall wie die Erste. Dazu müssen wir lediglich die neue LED initialisieren und in der Timer-Funktion den gleichen Status zuweisen. PROJECT = "LED blink" VERSION = "0.1" sys = require"sys" led_red = gpio.setup(0,0,gpio.PULLUP) led_blue = gpio.setup(1,0,gpio.PULLUP) local state = false sys.timerLoopStart(function() led_red(state and 0 or 1) led_blue(state and 0 or 1) state = not state log.info("led status = ", state) end, 250) sys.run() Abschließen möchte ich damit, die beiden LEDs im wechsel blinken zu lassen, dafür benötigen ein zusätzliches Statusfeld. Dieses Statusfeld initialisieren wir mit "true" und haben somit unser Wechsel blinken erzeugt. PROJECT = "LED blink" VERSION = "0.1" sys = require"sys" led_red = gpio.setup(0,0,gpio.PULLUP) led_blue = gpio.setup(1,0,gpio.PULLUP) local state_red = false local state_blue = true sys.timerLoopStart(function() led_red(state_red and 0 or 1) led_blue(state_blue and 0 or 1) state_red = not state_red state_blue = not state_blue log.info("red led status = ", state_red) log.info("blue led status = ", state_blue) end, 250) sys.run() Read the full article