Gutes Einsteiger Entwicklungsboard um Arduino, ESP32 und RasPi Pico leicht zu erlernen

Hallo Tüftler und Bastler! Wer in die Welt der Mikrocontroller einsteigen möchte, steht oft vor einer großen Hürde: Man muss nicht nur eine neue Programmiersprache lernen, sondern gleichzeitig auch verstehen, wie elektronische Bauteile auf einem Steckbrett (Breadboard) fehlerfrei verdrahtet werden.

In meinem Alltag als Ausbilder für angehende Fachinformatiker für Systemintegration (FiSi) und IT-Systemelektroniker (ITSE) sehe ich das regelmäßig: Ein einziges loses Kabel oder ein falsch gesteckter Widerstand reicht aus, und der Code funktioniert scheinbar nicht. Die Fehlersuche wird dann schnell frustrierend. Genau hier setzt der Funduino Cube an, den ich mir in den letzten Tagen intensiv auf dem Schreibtisch angeschaut habe.

Was macht den Funduino Cube so besonders?

Der Ansatz ist genial einfach: Es handelt sich um ein All-in-One-Board (eine Alles-in-einem-Platine), bei dem die gängigsten Sensoren (Messfühler) und Aktoren (Antriebe oder Leuchtmittel) bereits fest auf der Platine verlötet und miteinander verbunden sind.

Man steckt den Mikrocontroller auf, verbindet das Ganze per Universal Serial Bus (USB) mit dem Computer und kann sich zu 100 Prozent auf die Programmierung konzentrieren. Keine fliegenden Kabel, keine versehentlichen Kurzschlüsse.

Die Ausstattung: Ein ganzer Werkzeugkasten auf einer Platine

Obwohl das Board erfreulich handlich ist, hat der Hersteller enorm viele Bauteile integriert. Hier ist ein kurzer Überblick, was direkt an Bord ist:

Zusätzlich liegt ein kleiner Servomotor (ein Motor, der exakte Winkel anfahren kann) bei, der direkt auf dem Board eingesteckt werden kann.

Der Clou: Drei Welten mit einem Board

Standardmäßig wird das Board mit einem Arduino Nano (in diesem Fall ein Nachbau, ein sogenannter Clone) betrieben. Das ist perfekt für die ersten Schritte in der Integrierten Entwicklungsumgebung (IDE) von Arduino mit der Programmiersprache C++. Die General Purpose Input/Output (GPIO) Anschlüsse – also die Allzweck-Ein- und Ausgänge – sind auf dem Board hervorragend beschriftet. Steht an der grünen LED „D10“, spricht man im Code einfach den Pin 10 an.

Was das Board für mich aber zu einer echten Empfehlung macht, sind die zusätzlich erhältlichen Adapter-Platinen. Damit wächst das Board mit den eigenen Fähigkeiten mit:

• ESP32 Adapter: Wer WLAN, Bluetooth und mehr Rechenleistung braucht, steckt den ESP32-Adapter auf.
• Raspberry Pi Pico Adapter: Ideal für alle, die lieber mit der Sprache Python (speziell MicroPython) arbeiten möchten.

Erste Schritte mit dem Funduino Cube und einem Raspberry Pi Pico, habe ich eine separate Seite gewidmet, die ihr hier findet:
Funduino Cube: Einfacher Einstieg mit Raspberry Pi Pico

Wichtiger Hinweis beim Wechseln: Wenn ihr vom Arduino Nano auf den ESP32 oder den Raspberry Pi Pico wechselt, ändert sich die Logikspannung! Der Nano arbeitet mit 5 Volt, die anderen beiden mit 3,3 Volt. Außerdem verschieben sich durch die Adapter die Anschlussnummern (Pin-Nummern). Der Bewegungsmelder, der beim Nano noch auf Pin 8 lag, ist beim ESP32-Adapter plötzlich über Pin 18 erreichbar. Man muss also im Code die Variablen anpassen.

Die gute Nachricht: Laut Hersteller sind alle auf dem Board verwendeten Sensoren (Messfühler) und Aktoren (wie der kleine Motor oder die Leuchtdioden) sowohl für 3,3 Volt als auch für 5 Volt ausgelegt. Beachtet werden muss aber zwingend, dass nicht zu viele dieser Module gleichzeitig betrieben werden dürfen. Die Mikrocontroller haben eine Obergrenze, wie viel Strom sie insgesamt liefern können:

• Arduino Nano: maximal ca. 500 Milliampere (mA) bzw. 0,5 Ampere (A)
• ESP32: maximal ca. 500 mA (0,5 A) – Achtung: Bei aktivem WLAN (Wireless Local Area Network) benötigt der Chip selbst schon bis zu 250 mA!
• Raspberry Pi Pico: maximal 300 mA (0,3 A)

Wenn man also alle Lampen gleichzeitig leuchten lässt und noch Motoren bewegt, kann das System schnell instabil werden oder sich unerwartet neu starten. Beispiel siehe ganz unten.

---

Spartipp:
Der Funduino Cube gibt es auch als Bausatz für Lötübung incl. Handbuch

---

Pinbelegung ESP32 Adapter:

Wenn ihr beim bestellen direkt den passenden ESP32 mitbestellt, dann ist das passende Board mit der korrekten Belegung unproblematisch.
Jedoch fliegen bei euch sowieso viele verschiedene Boardvarianten in der Schublade rum, ist es gut zu wissen, welche GPIO Pin´s an welcher stelle sein sollten:

Programmierung:
Von der Einsteiger Textausgabe „Hello World“ zur eigenen Wetterstation

Für den Start bietet die Webseite des Herstellers gute Schritt-für-Schritt-Anleitungen.

Wer es ganz simpel mag, kann sogar blockbasiert mit „OpenRoberta“ programmieren (ähnlich wie Scratch, wo Code-Bausteine mit der Maus zusammengeschoben werden). Um sich ein Bild davon machen zu können, hier gibt es das Einsteigertutorial mit den Praxisaufgaben in OpenRoberta.

Ich persönlich bleibe für unsere Ausbildungsprojekte bei der klassischen Arduino IDE oder nutze später Visual Studio Code (VS Code) mit PlatformIO.

Sobald man in der ersten Lektion mit dem Nano, die erste Lampe erfolgreich zum Blinken gebracht hat, weiß man:
Die Schaltung ist korrekt aufgebaut, die Entwicklungsumgebung funktioniert, die Schnittstellen sind richtig angebunden – und das Programmieren ist leichter, als man dachte.
Mit diesem sicheren Fundament lassen sich dann das nächste Projekte wie „Der schlaue Wächter“ umsetzen: Ein Bewegungsmelder erkennt eine Person und schaltet sofort die rote Warn‑LED ein.

Im nächsten Schritt lässt man Töne über den kleinen Lautsprecher (Buzzer) erklingen, misst mit dem Ultraschallsensor Entfernungen oder reagiert mit dem Lichtsensor auf die Helligkeit im Raum – und das alles, ohne auch nur ein einziges Kabel auf einem Steckbrett (Breadboard) suchen zu müssen.

Das ist das Schöne an diesem Board: Wenn einem alle einzelnen Aktoren (Antriebe/Leuchten) und Sensoren (Messfühler) bekannt sind und man sicher mit ihnen umgehen kann, beginnt der eigentliche Spaß. Nun können mehrere Bauteile miteinander verknüpft werden. Ein tolles Folgeprojekt wäre zum Beispiel, die aktuelle Raumtemperatur über den DHT11-Sensor auszulesen und diese sauber formatiert auf dem kleinen Bildschirm (OLED-Display) anzeigen zu lassen. So wachsen die Projekte organisch mit dem eigenen Wissen mit.

Youtube Video:

Mein Fazit

Für Einsteiger, Azubis oder auch für den Informatikunterricht ist das Konzept hervorragend. Es nimmt die Frustration aus den ersten Programmierstunden. Hat man die Software-Logik verstanden, kann man immer noch den Schaltplan studieren und die Projekte mit losen Bauteilen selbst nachstecken, um auch die Hardware-Seite komplett zu durchdringen.

Ein Video mit dem kompletten Unboxing und meinen ersten Tests findet ihr drüben auf meinem YouTube-Kanal. Den Beispielcode für den Raspberry Pi Pico, bei dem ich den Temperatur-Sensor über MicroPython auslese und auf dem Display darstelle, erscheint in einem weiteren Beitrag und ich lade den euch die Tage wie gewohnt in mein GitHub-Repository hoch.

Viel Spaß beim Tüfteln, Basteln und Lernen!

Nachträgliches Update:

Multisensor‑Anzeige auf dem OLED‑Display unter Berücksichtigung der elektrischen Belastbarkeit des Nano

Ein besonders spannender nächster Schritt ist es, die vielen bereits verlöteten Sensoren des Funduino Cube sinnvoll miteinander zu kombinieren. Mit dem Arduino Nano lassen sich Temperatur, Luftfeuchtigkeit, Helligkeit, Abstand und der Wert des Drehreglers gleichzeitig erfassen und übersichtlich auf dem kleinen OLED‑Display darstellen.

Dabei lohnt sich auch ein Blick auf den Stromverbrauch der einzelnen Module, denn alle Komponenten werden direkt vom Nano gespeist. So versteht man nicht nur die Sensorlogik, sondern auch die elektrischen Grenzen des Boards besser.

Du benötigst zwei Libraries:

In der Arduino IDE:

• Adafruit SSD1306
• Adafruit GFX

Beide über Bibliotheken verwalten installierbar.

und diesen Sketch:

/****************************************************
 *   Umgebung erfassen + OLED-Ausgabe – Arduino Nano
 *   Temperatur, Feuchte, Licht, Abstand, Drehregler
 ****************************************************/

#include <DHT.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// --- Sensor-Pins ---
#define DHTPIN A3
#define DHTTYPE DHT11

#define LDR_PIN A7
#define POTI_PIN A6

#define TRIG_PIN 6
#define ECHO_PIN 5

// --- OLED ---
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

DHT dht(DHTPIN, DHTTYPE);

// ---------------------------------------------------
void setup() {
  Serial.begin(9600);
  dht.begin();

  pinMode(LDR_PIN, INPUT);
  pinMode(POTI_PIN, INPUT);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);

  // OLED starten
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("OLED nicht gefunden!");
    while(true);
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

  Serial.println("Umgebungssensoren gestartet...");
}

// ---------------------------------------------------
float readDistanceCM() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(5);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  long duration = pulseIn(ECHO_PIN, HIGH);
  float distance = duration * 0.0343 / 2;
  return distance;
}

// ---------------------------------------------------
void loop() {

  float temp = dht.readTemperature();
  float hum  = dht.readHumidity();

  int lightRaw = analogRead(LDR_PIN);
  int lightPercent = map(lightRaw, 0, 1023, 0, 100);

  float distance = readDistanceCM();

  int potiRaw = analogRead(POTI_PIN);
  int potiPercent = map(potiRaw, 0, 1023, 0, 100);

  // --- OLED-Ausgabe ---
  display.clearDisplay();
  display.setCursor(0, 0);

  display.print("Temp: ");
  display.print(temp);
  display.println(" C");

  display.print("Feuchte: ");
  display.print(hum);
  display.println(" %");

  display.print("Licht: ");
  display.print(lightPercent);
  display.println(" %");

  display.print("Abstand: ");
  display.print(distance);
  display.println(" cm");

  display.print("Poti: ");
  display.print(potiPercent);
  display.println(" %");

  display.display();

  delay(1000);
}

Ausgabe:

Stromverbrauch der verwendeten Komponenten

Gesamt im Projekt „Umgebung erfassen + OLED“: etwa 60–100 mA, je nach Displayhelligkeit.
Alle weiteren verlöteten Module verbrauchen ein kleines bisschen Strom, auch wenn du sie im Sketch nicht ansprichst. Aber: Dieser Verbrauch ist extrem gering und spielt praktisch keine Rolle, solange du keine stromhungrigen Aktoren aktivierst.

Damit bleibt das Projekt deutlich unter der maximalen Belastbarkeit des Arduino Nano (ca. 500 mA) und ist auch für lange Laufzeiten stabil.
Erst das zusätzliche Aktivieren stromintensiver Module wie Servo (200–300 mA), LED‑Ring (bis 300 mA) oder Buzzer (30–50 mA) treibt den Verbrauch deutlich nach oben und kann die Laufzeit instabil machen.