Keyestudio ESP32 Inventor Starter Kit im Test: Raumklima-Monitor als Praxisprojekt

Das Keyestudio ESP32 Inventor Starter Kit kombiniert zahlreiche Sensoren, Displays, LEDs und Bedienelemente auf einem einzigen Experimentierboard. Dadurch lassen sich ESP32-Projekte umsetzen, ohne jedes Bauteil zunächst einzeln auf einem Breadboard verkabeln zu müssen.

In diesem Praxistest schaue ich mir den Lieferumfang, die Verarbeitung und die Besonderheiten des Boards genauer an. Außerdem baue ich einen vollständigen Raumklima-Monitor mit DHT11, LCD, Punktmatrix, RGB-Ampel und lokalem Webserver. Damit zeigt sich, ob das Kit nur für einfache Lernübungen geeignet ist oder auch einen praktischen Nutzen bieten kann.

Transparenzhinweis: Das Keyestudio ESP32 Inventor Starter Kit wurde mir von Keyestudio kostenfrei für dieses Review zur Verfügung gestellt. Eine Vergütung für diesen Beitrag habe ich nicht erhalten. Die Bereitstellung des Produkts hat keinen Einfluss auf meine Bewertung – alle im Beitrag beschriebenen Erfahrungen, Einschätzungen und Kritikpunkte entsprechen meiner persönlichen Meinung.

Was ist das Keyestudio ESP32 Inventor Starter Kit?

Das Keyestudio ESP32 Inventor Starter Kit ist ein vielseitiges Lern- und Experimentierboard, auf dem bereits zahlreiche Sensoren, Anzeigen und Bedienelemente fest verbaut sind. Dadurch kannst du viele typische Mikrocontroller-Projekte umsetzen, ohne zunächst einzelne Bauteile auf einem Steckbrett miteinander verbinden zu müssen.

Besonders interessant ist der vorgesehene Steckplatz für den Mikrocontroller. Neben dem mitgelieferten ESP32-Modul soll das Board laut Aufbau auch Mikrocontroller im Arduino-Nano-Format aufnehmen können. Bei meinem Test zeigte sich allerdings ein Problem mit dem Abstand der beiden Buchsenleisten, auf das ich im folgenden Abschnitt noch genauer eingehe.

Mit einem ESP32 stehen zusätzlich WLAN und Bluetooth zur Verfügung. Damit eignet sich das Kit nicht nur für einfache Übungen mit LEDs und Tastern, sondern ebenso für vernetzte Anwendungen, kleine Webserver, Sensormessungen und erste IoT-Projekte. Mit einem Arduino-Nano-kompatiblen Mikrocontroller können dagegen klassische Übungen und kompakte Projekte ohne Funkverbindung umgesetzt werden.

Auf der Draufsicht wird schnell deutlich, wie umfangreich das Board ausgestattet ist. Zu den direkt nutzbaren Komponenten gehören unter anderem verschiedene farbige LEDs und Taster, Displays, ein Ultraschallsensor sowie mehrere Sensoren zur Erfassung von Umgebungswerten. Auch ein Potentiometer, ein Summer und weitere Ein- und Ausgabemöglichkeiten sind bereits integriert.

Der große Vorteil dieser Bauweise liegt in der unkomplizierten Nutzung: Statt jedes Projekt zunächst aufwendig verkabeln zu müssen, können viele Komponenten direkt über die jeweiligen Pins angesprochen werden. Das reduziert mögliche Fehlerquellen und sorgt besonders bei Einsteigern für schnelle Erfolgserlebnisse.

Gleichzeitig ist das Board nicht ausschließlich als Lernplattform interessant. Auch erfahrene Entwickler können damit schnell eine Bibliothek testen, einen Programmablauf ausprobieren oder einen kleinen Prototyp erstellen. Für ein erstes Experiment muss dadurch nicht jedes Mal eine neue Schaltung auf einem Breadboard aufgebaut werden.

Das Keyestudio Inventor Starter Kit ersetzt zwar keinen vollständig frei aufgebauten Prototyp, bietet dafür aber eine vielseitige und sofort einsatzbereite Testumgebung. Der vorgesehene Steckplatz für Mikrocontroller im Arduino-Nano-Format könnte die Plattform zusätzlich flexibler machen. Bei meinem Testexemplar war diese Kompatibilität allerdings aufgrund des Abstands der Buchsenleisten nicht gegeben.

Wichtiger Hinweis zur Nano-Kompatibilität

Das Inventor Starter Kit besitzt zwei Buchsenleisten, die offenbar für Mikrocontroller im Arduino-Nano-Format vorgesehen sind. Bei meinem Testexemplar zeigte sich jedoch, dass der Abstand zwischen den beiden Leisten nicht zum Pinraster meines Arduino Nano passt.

Der Mikrocontroller lässt sich deshalb nicht gleichzeitig gerade in beide Buchsenleisten einsetzen. Eine Seite kann zwar angesetzt werden, auf der gegenüberliegenden Seite liegen die Pins jedoch sichtbar neben den entsprechenden Kontakten. Ein Einsetzen wäre nur mit deutlichem Druck oder durch ein Verbiegen der Pins möglich. Davon würde ich ausdrücklich abraten, da dabei sowohl der Mikrocontroller als auch die Buchsenleisten beschädigt werden könnten.

Ob dieses Problem bei allen Exemplaren des Inventor Starter Kits auftritt oder lediglich mein Testexemplar betrifft, kann ich derzeit nicht abschließend beurteilen. Möglich wäre sowohl ein Fehler im Platinenlayout als auch eine fehlerhafte Positionierung der Buchsenleisten bei der Fertigung.

Unabhängig von der genauen Ursache ist die Nano-Kompatibilität bei meinem Exemplar praktisch nicht gegeben. Das ist besonders ärgerlich, da der austauschbare Mikrocontroller eigentlich zu den interessanten Eigenschaften des Boards gehört.

Die Besonderheit: freie Verbindung statt fester Pinbelegung

Eine Besonderheit des Keyestudio ESP32 Inventor Starter Kits ist die Art, wie die integrierten Komponenten mit dem eingesetzten Mikrocontroller verbunden werden. Die Sensoren, LEDs, Taster und Anzeigen sind nicht automatisch fest mit bestimmten digitalen oder analogen Pins des Mikrocontrollers verdrahtet.

Stattdessen befinden sich auf dem Board mehrere Stiftleisten, an denen die jeweiligen Signalanschlüsse der Komponenten herausgeführt sind. Die Stromversorgung ist bereits auf der Platine vorhanden, sodass in der Regel nur noch die benötigten digitalen oder analogen Signale mit den passenden Pins des Mikrocontrollers verbunden werden müssen.

Dafür liegen dem Kit Breadboardkabel mit Buchse-zu-Buchse-Anschlüssen in zwei unterschiedlichen Längen bei:

• 10 cm für kurze Verbindungen
• 20 cm für weiter auseinanderliegende Anschlüsse

Damit geht das Inventor Starter Kit einen anderen Weg als viele der bisher hier vorgestellten Lernboards. Bei vollständig verdrahteten Boards sind die Komponenten meist fest bestimmten GPIO-Pins zugeordnet. Das ist besonders bequem, schränkt aber die Flexibilität ein.

Beim Keyestudio-Board entscheidest du selbst, welcher Sensor oder Aktor mit welchem verfügbaren Pin verbunden wird. Dadurch kannst du die Pinbelegung an dein Projekt anpassen, verschiedene Mikrocontroller im Nano-Format verwenden und mögliche Pin-Konflikte gezielt vermeiden.

Gleichzeitig bleibt der Aufbau übersichtlich, da die Stromversorgung der Komponenten bereits intern gelöst ist. Du erhältst somit eine gute Mischung aus vorkonfektioniertem Lernboard und frei planbarer Breadboard-Schaltung.

Diese Bauweise hat allerdings auch zur Folge, dass vor dem Hochladen eines Programms geprüft werden muss, ob die im Sketch verwendeten Pins tatsächlich mit den entsprechenden Komponenten verbunden wurden. Stimmen Verkabelung und Pinbelegung nicht überein, reagiert die Komponente entweder gar nicht oder eine andere Funktion wird angesprochen.

Lieferumfang und erster Eindruck

Zum Lieferumfang des Keyestudio ESP32 Inventor Starter Kits gehört deutlich mehr als nur das eigentliche Experimentierboard. Neben dem Board befinden sich folgende Komponenten in der Verpackung:

• ein Batteriefach für sechs AA-Batterien
• ein 9-g-Servomotor
• eine Infrarot-Fernbedienung
• Breadboardkabel mit Buchse-zu-Buchse-Anschlüssen in 10 cm und 20 cm Länge

Die Kappen für die Taster sowie der Knauf des Drehpotentiometers sind bereits vormontiert. Dadurch wirkt das Board direkt nach dem Auspacken weitgehend einsatzbereit.

Lediglich die Acrylplatte muss noch unter dem Board befestigt werden. Dafür liegen passende Abstandshalter, Schrauben und sogar ein kleiner Schraubendreher bei. Zusätzlich gehören selbstklebende Silikonpads zum Lieferumfang, die an der Unterseite angebracht werden können. Sie sorgen dafür, dass das Board später sicher auf dem Schreibtisch steht und beim Arbeiten nicht ständig verrutscht.

Gerade diese kleinen Details machen auf mich einen durchdachten Eindruck. Keyestudio liefert nicht nur die eigentliche Elektronik, sondern auch alles mit, was für einen stabilen und praktischen Aufbau benötigt wird. Nach wenigen Minuten ist das Board montiert und bereit für die ersten Experimente.

Offizielle Dokumentation und Beispielprojekte

Keyestudio stellt für das ESP32 Inventor Starter Kit eine umfangreiche Online-Dokumentation in deutscher Sprache bereit. Darin findest du neben einer Übersicht über den Lieferumfang und die verbauten Komponenten auch Hinweise zur Montage, zur Einrichtung der Arduino IDE und zur Installation der benötigten Bibliotheken und Treiber.

Besonders hilfreich sind die zahlreichen Beispielprojekte. Die Dokumentation führt schrittweise von einfachen Übungen wie einer blinkenden LED oder einer Ampelschaltung bis hin zu umfangreicheren Anwendungen mit LCD, LED-Matrix, Servomotor, Ultraschallsensor, Infrarot-Fernbedienung und WLAN. Insgesamt werden für die Arduino-Programmierung mehr als 30 Projekte vorgestellt. Zusätzlich gibt es einen eigenen Bereich für die grafische Programmierung mit Scratch beziehungsweise KidsBlock.

Die offizielle Dokumentation findest du hier: Dokumentation zum Keyestudio ESP32 Inventor Starter Kit

Die Anleitungen sind eine gute Grundlage für die ersten Experimente. Bei älteren Beispielprogrammen solltest du jedoch darauf achten, ob die verwendeten Bibliotheken noch mit der aktuell installierten Version des ESP32-Boardpakets kompatibel sind. Bei meinem ersten Test musste ich beispielsweise eine veraltete Version des ESPAsyncWebServer durch den aktuellen Fork ersetzen.

Das Keyestudio Inventor Starter Kit in der Arduino IDE einrichten

Für meinen ersten Praxistest verwende ich das mitgelieferte ESP32-Modul und programmiere es über die Arduino IDE. Die Einrichtung unterscheidet sich grundsätzlich nicht von anderen ESP32-Boards: Zunächst wird das ESP32-Boardpaket installiert, anschließend das passende Board sowie der verwendete COM-Port ausgewählt.

Eine feste Pinbelegung für die verbauten Komponenten gibt es beim Inventor Starter Kit allerdings nicht. Die Signalanschlüsse der LEDs, Sensoren, Taster und Anzeigen liegen auf separaten Stiftleisten. Erst durch die mitgelieferten Buchse-zu-Buchse-Kabel werden sie mit den gewünschten GPIOs des ESP32 verbunden.

Dadurch kann die Pinbelegung für jedes Projekt individuell festgelegt werden. Gleichzeitig muss die Verkabelung jedoch immer zum verwendeten Sketch passen. Wird beispielsweise der DHT11 mit GPIO 26 verbunden, muss im Programm ebenfalls GPIO 26 angegeben sein.

ESP32-Raumklima-Monitor mit DHT11, LCD und Webserver

Nach der Einrichtung des ESP32 möchte ich das Keyestudio Inventor Starter Kit nun mit einem kleinen Praxisprojekt testen. Dafür entsteht ein kompakter Raumklima-Monitor, der die aktuelle Temperatur und relative Luftfeuchtigkeit erfasst und die Messwerte auf mehreren Wegen darstellt.

Das LCD zeigt die konkreten Sensorwerte an. Auf der Punktmatrix erscheint abhängig vom Raumklima ein passendes Gesicht, während die sechs WS2812B-LEDs den Zustand zusätzlich als farbige Ampel visualisieren. Über einen kleinen Webserver können die Messwerte außerdem im Browser aufgerufen werden.

Damit werden gleich mehrere Komponenten des Boards in einem einzigen Projekt kombiniert. Gleichzeitig zeigt der Aufbau sehr gut, wie flexibel die Signalanschlüsse des Inventor Starter Kits mit den GPIOs des ESP32 verbunden werden können.

Benötigte Komponenten

Für das Projekt benötigst du:

• das Keyestudio Inventor Starter Kit
• das mitgelieferte ESP32-Modul
• ein USB-Kabel zur Programmierung und Stromversorgung
• fünf kurze Buchse-zu-Buchse-Verbindungskabel mit 10 cm Länge
• zwei lange Buchse-zu-Buchse-Verbindungskabel mit 20 cm Länge

Alle benötigten Bauteile und Verbindungskabel sind bereits im Lieferumfang des Keyestudio Inventor Starter Kits enthalten. Zusätzliches Elektronikzubehör ist für dieses Projekt daher nicht erforderlich.

Die kurzen Kabel eignen sich für die Verbindungen zwischen den nahe beieinanderliegenden Stiftleisten. Für weiter entfernte Komponenten wie den DHT11 oder einzelne Anschlüsse der Punktmatrix sind die längeren 20-cm-Kabel praktischer.

Funktionen des Raumklima-Monitors

Das Projekt übernimmt folgende Aufgaben:

• Temperatur und relative Luftfeuchtigkeit mit dem DHT11 messen
• Messwerte auf dem 16×2-LCD anzeigen
• Raumklimastatus über die 8×8-Punktmatrix darstellen
• Status über sechs WS2812B-LEDs als Ampel anzeigen
• Messwerte über WLAN auf einer lokalen Webseite bereitstellen

Als Richtwerte für ein angenehmes Raumklima verwende ich eine Temperatur zwischen 20 und 22 °C sowie eine relative Luftfeuchtigkeit zwischen 40 und 60 %. Die Grenzwerte im Sketch können später problemlos an die eigenen Anforderungen angepasst werden.

Der Arduino-Sketch für den Raumklima-Monitor

Der Sketch verbindet die verschiedenen Komponenten des Projekts miteinander. In regelmäßigen Abständen wird der DHT11 ausgelesen und aus Temperatur sowie relativer Luftfeuchtigkeit ein gemeinsamer Raumklimastatus ermittelt. Dabei unterscheidet das Programm zwischen einem guten Bereich, einem erweiterten Grenzbereich und ungünstigen Werten.

Die aktuellen Messwerte werden auf dem 16×2-LCD dargestellt. Gleichzeitig zeigt die 8×8-Punktmatrix abhängig vom ermittelten Status ein lächelndes, neutrales oder trauriges Gesicht. Die sechs WS2812B-LEDs ergänzen diese Anzeige als farbige Ampel: Grün steht für gute Werte, Gelb für den Grenzbereich und Rot für ungünstige Bedingungen. Kann der DHT11 nicht ausgelesen werden, erscheinen ein Warnsymbol auf der Punktmatrix und eine violette Anzeige auf den RGB-LEDs.

Zusätzlich verbindet sich der ESP32 mit dem heimischen WLAN und startet einen kleinen Webserver. Die Messwerte und der aktuelle Status können dadurch über die lokale IP-Adresse des ESP32 im Browser aufgerufen werden. Die Webseite passt sich auch an kleinere Displays an und aktualisiert sich automatisch alle fünf Sekunden.

Vor dem Hochladen müssen im Sketch lediglich die eigenen WLAN-Zugangsdaten eingetragen werden:

const char* WIFI_SSID = "DEINE-SSID";
const char* WIFI_PASSWORD = "DEIN-PASSWORT";

Die im Sketch verwendeten GPIOs müssen außerdem mit der tatsächlichen Verkabelung auf dem Inventor Starter Kit übereinstimmen. Für dieses Projekt verwende ich den DHT11 an GPIO 26, die Punktmatrix an GPIO 23, 18 und 15 sowie die WS2812B-LEDs an GPIO 13. LCD, Punktmatrix, RGB-Ampel und Weboberfläche greifen anschließend auf denselben ermittelten Raumklimastatus zurück.

Benötigte Bibliotheken

Für den Sketch werden neben den bereits im ESP32-Boardpaket enthaltenen Bibliotheken einige zusätzliche Bibliotheken benötigt:

• LiquidCrystal_I2C
• LedControl
• xht11
• Adafruit NeoPixel

Die Bibliotheken WiFi, WebServer und Wire sind Bestandteil des ESP32-Boardpakets und müssen normalerweise nicht separat installiert werden.

Hinweis zur LedControl-Bibliothek

Damit sich die verwendete LedControl-Bibliothek mit dem ESP32 kompilieren lässt, muss je nach installierter Version eine kleine Anpassung in der Datei LedControl.h vorgenommen werden.

Öffne dazu die Datei im Bibliotheksordner der Arduino IDE. Unter Windows befindet sie sich beispielsweise hier:

C:\Users\<BENUTZERNAME>\Documents\Arduino\libraries\LedControl\LedControl.h

Suche anschließend diese Zeile:

#include <avr/pgmspace.h>

und ersetze sie durch:

#if defined(ARDUINO_ARCH_AVR)
  #include <avr/pgmspace.h>
#else
  #include <pgmspace.h>
#endif

Dadurch wird bei klassischen AVR-Boards weiterhin die bisherige Headerdatei verwendet, während beim ESP32 die passende pgmspace.h eingebunden wird. Nach einem Update oder einer Neuinstallation der Bibliothek muss diese Änderung möglicherweise erneut durchgeführt werden.

Vollständiger Programmcode

Im folgenden Sketch musst du vor dem Hochladen noch deine WLAN-Zugangsdaten eintragen. Veröffentliche an dieser Stelle niemals deine tatsächliche SSID und dein WLAN-Passwort.

#include <WiFi.h>
#include <WebServer.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <LedControl.h>
#include <xht11.h>
#include <Adafruit_NeoPixel.h>

// ------------------------------------------------------------
// WLAN
// ------------------------------------------------------------

const char* WIFI_SSID = "DEINE-SSID";
const char* WIFI_PASSWORD = "DEIN-PASSWORT";

// ------------------------------------------------------------
// Pinbelegung
// ------------------------------------------------------------

// DHT11
#define DHT11_PIN 26

// MAX7219-Punktmatrix
#define MATRIX_DIN_PIN 23
#define MATRIX_CLK_PIN 18
#define MATRIX_CS_PIN 15

// Standard-I2C-Pins des ESP32
#define I2C_SDA_PIN 21
#define I2C_SCL_PIN 22

// WS2812B NeoPixel
#define WS2812_PIN 13
#define WS2812_COUNT 6

#define LED_BRIGHTNESS 40

// ------------------------------------------------------------
// LCD, Sensor, Punktmatrix und Webserver
// ------------------------------------------------------------

LiquidCrystal_I2C lcd(0x27, 16, 2);
xht11 dht11(DHT11_PIN);
Adafruit_NeoPixel pixels(WS2812_COUNT, WS2812_PIN, NEO_GRB + NEO_KHZ800);

LedControl matrix = LedControl(MATRIX_DIN_PIN, MATRIX_CLK_PIN, MATRIX_CS_PIN, 1);

WebServer server(80);

// ------------------------------------------------------------
// Grenzwerte
// ------------------------------------------------------------

// Optimaler Bereich
constexpr float TEMP_GOOD_MIN = 18.0;
constexpr float TEMP_GOOD_MAX = 25.0;

constexpr float HUMIDITY_GOOD_MIN = 40.0;
constexpr float HUMIDITY_GOOD_MAX = 60.0;

// Erweiterter Grenzbereich
constexpr float TEMP_WARNING_MIN = 16.0;
constexpr float TEMP_WARNING_MAX = 28.0;

constexpr float HUMIDITY_WARNING_MIN = 30.0;
constexpr float HUMIDITY_WARNING_MAX = 70.0;

// ------------------------------------------------------------
// Messwerte und Status
// ------------------------------------------------------------

float temperature = 0.0;
float humidity = 0.0;

bool sensorAvailable = false;

unsigned char sensorData[] = { 0, 0, 0, 0 };

unsigned long lastSensorRead = 0;
unsigned long lastLcdChange = 0;
unsigned long lastWifiCheck = 0;

constexpr unsigned long SENSOR_INTERVAL_MS = 2500;
constexpr unsigned long LCD_INTERVAL_MS = 4000;
constexpr unsigned long WIFI_CHECK_INTERVAL_MS = 10000;

bool showTemperatureOnLcd = true;

// ------------------------------------------------------------
// Raumklimastatus
// ------------------------------------------------------------

enum class ClimateStatus { GOOD,
                           WARNING,
                           BAD,
                           SENSOR_ERROR };

ClimateStatus currentStatus = ClimateStatus::SENSOR_ERROR;

// ------------------------------------------------------------
// Symbole für die 8x8-Punktmatrix
// ------------------------------------------------------------

// Lächelndes Gesicht – 90° gegen den Uhrzeigersinn gedreht
const byte HAPPY_FACE[8] = {
  B00111100,
  B01000010,
  B10101001,
  B10000101,
  B10000101,
  B10101001,
  B01000010,
  B00111100
};

// Neutrales Gesicht – 90° gegen den Uhrzeigersinn gedreht
const byte NEUTRAL_FACE[8] = {
  B00111100,
  B01000010,
  B10100101,
  B10000101,
  B10000101,
  B10100101,
  B01000010,
  B00111100
};

// Trauriges Gesicht – 90° gegen den Uhrzeigersinn gedreht
const byte SAD_FACE[8] = {
  B00111100,
  B01000010,
  B10100101,
  B10001001,
  B10001001,
  B10100101,
  B01000010,
  B00111100
};

// Warnsymbol bei Sensorfehler – 90° gegen den Uhrzeigersinn gedreht
const byte ERROR_SYMBOL[8] = {
  B00011110,
  B00111110,
  B01111010,
  B11110111,
  B11110111,
  B01111010,
  B00111110,
  B00011110
};

// ------------------------------------------------------------
// Hilfsfunktionen
// ------------------------------------------------------------

bool isInside(float value, float minimum, float maximum) {
  return value >= minimum && value <= maximum;
}

const char* climateStatusText(ClimateStatus status) {
  switch (status) {
    case ClimateStatus::GOOD: return "Gut";
    case ClimateStatus::WARNING: return "Grenzbereich";
    case ClimateStatus::BAD: return "Ungünstig";
    case ClimateStatus::SENSOR_ERROR: 
    default: return "Sensorfehler";
  }
}

const char* climateStatusCssClass(ClimateStatus status) {
  switch (status) {
    case ClimateStatus::GOOD: return "good";
    case ClimateStatus::WARNING: return "warning";
    case ClimateStatus::BAD: return "bad";
    case ClimateStatus::SENSOR_ERROR: 
    default: return "error";
  }
}

// ------------------------------------------------------------
// Status bestimmen
// ------------------------------------------------------------

ClimateStatus determineClimateStatus() {
  if (!sensorAvailable) {
    return ClimateStatus::SENSOR_ERROR;
  }

  const bool temperatureGood = isInside( temperature, TEMP_GOOD_MIN, TEMP_GOOD_MAX);
  const bool humidityGood = isInside( humidity, HUMIDITY_GOOD_MIN, HUMIDITY_GOOD_MAX);

  if (temperatureGood && humidityGood) {
    return ClimateStatus::GOOD;
  }

  const bool temperatureInWarningRange = isInside( temperature, TEMP_WARNING_MIN, TEMP_WARNING_MAX);
  const bool humidityInWarningRange = isInside( humidity, HUMIDITY_WARNING_MIN, HUMIDITY_WARNING_MAX);

  if (temperatureInWarningRange && humidityInWarningRange) {
    return ClimateStatus::WARNING;
  }

  return ClimateStatus::BAD;
}

// ------------------------------------------------------------
// Punktmatrix
// ------------------------------------------------------------

void drawMatrixImage(const byte image[8]) {
  matrix.clearDisplay(0);

  for (uint8_t row = 0; row < 8; row++) {
    matrix.setRow(0, row, image[row]);
  }
}

void updateMatrix() {
  switch (currentStatus) {
    case ClimateStatus::GOOD: drawMatrixImage(HAPPY_FACE); break;
    case ClimateStatus::WARNING: drawMatrixImage(NEUTRAL_FACE); break;
    case ClimateStatus::BAD: drawMatrixImage(SAD_FACE); break;
    case ClimateStatus::SENSOR_ERROR: 
    default: drawMatrixImage(ERROR_SYMBOL); break;
  }
}

// ------------------------------------------------------------
// DHT11 auslesen
// ------------------------------------------------------------

void readSensor() {
  if (dht11.receive(sensorData)) {
    humidity = sensorData[0];
    temperature = sensorData[2];

    sensorAvailable = true;
    currentStatus = determineClimateStatus();

    Serial.print("Temperatur: ");
    Serial.print(temperature, 1);
    Serial.print(" °C | Luftfeuchtigkeit: ");
    Serial.print(humidity, 1);
    Serial.print(" % | Status: ");
    Serial.println(climateStatusText(currentStatus));
  } else {
    sensorAvailable = false;
    currentStatus = ClimateStatus::SENSOR_ERROR;

    Serial.println("DHT11 konnte nicht ausgelesen werden.");
  }
  updateMatrix();
  updateStatusLeds();
}

// ------------------------------------------------------------
// LCD-Anzeige
// ------------------------------------------------------------

void clearLcdLine(uint8_t row) {
  lcd.setCursor(0, row);
  lcd.print("                ");
}

void showIpAddress() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Webserver:");

  lcd.setCursor(0, 1);
  lcd.print(WiFi.localIP());
}

void updateLcd() {
  lcd.clear();

  if (!sensorAvailable) {
    lcd.setCursor(0, 0);
    lcd.print("DHT11 Fehler");

    lcd.setCursor(0, 1);
    lcd.print("Sensor pruefen");
    return;
  }

  lcd.setCursor(0, 0);
  lcd.print("Temp: ");
  lcd.print(temperature, 1);
  lcd.print((char)223);
  lcd.print("C");

  lcd.setCursor(0, 1);
  lcd.print("Feuchte: ");
  lcd.print(humidity, 0);
  lcd.print("%");
}

// ------------------------------------------------------------
// HTML-Webseite
// ------------------------------------------------------------

String generateHtmlPage() {
  String html;
  html.reserve(7000);

  html += R"HTML(
<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8">
  <meta name="viewport"
        content="width=device-width, initial-scale=1.0">

  <meta http-equiv="refresh" content="5">

  <title>ESP32 Raumklima-Monitor</title>

  <style>
    * {
      box-sizing: border-box;
    }

    body {
      margin: 0;
      padding: 20px;
      font-family: Arial, Helvetica, sans-serif;
      background: #eef2f6;
      color: #20242a;
    }

    .container {
      width: 100%;
      max-width: 850px;
      margin: 0 auto;
    }

    h1 {
      margin-bottom: 8px;
      text-align: center;
    }

    .subtitle {
      margin-top: 0;
      margin-bottom: 25px;
      text-align: center;
      color: #5d6670;
    }

    .status {
      margin-bottom: 20px;
      padding: 24px;
      border-radius: 14px;
      text-align: center;
      color: white;
      box-shadow: 0 5px 18px rgba(0, 0, 0, 0.12);
    }

    .status.good {
      background: #238636;
    }

    .status.warning {
      background: #c47f00;
    }

    .status.bad {
      background: #c62828;
    }

    .status.error {
      background: #555b65;
    }

    .status-label {
      margin: 0;
      font-size: 16px;
      opacity: 0.9;
    }

    .status-value {
      margin: 8px 0 0;
      font-size: 32px;
      font-weight: bold;
    }

    .grid {
      display: grid;
      grid-template-columns: repeat(2, 1fr);
      gap: 18px;
    }

    .card {
      padding: 25px;
      border-radius: 14px;
      background: white;
      text-align: center;
      box-shadow: 0 5px 18px rgba(0, 0, 0, 0.08);
    }

    .card h2 {
      margin-top: 0;
      font-size: 19px;
      color: #4c5661;
    }

    .measurement {
      margin: 10px 0;
      font-size: 42px;
      font-weight: bold;
    }

    .range {
      color: #6b747e;
      font-size: 14px;
      line-height: 1.5;
    }

    .footer {
      margin-top: 20px;
      padding: 18px;
      border-radius: 12px;
      background: white;
      color: #69727c;
      text-align: center;
      font-size: 14px;
    }

    @media (max-width: 600px) {
      body {
        padding: 12px;
      }

      .grid {
        grid-template-columns: 1fr;
      }

      h1 {
        font-size: 26px;
      }

      .measurement {
        font-size: 38px;
      }
    }
  </style>
</head>

<body>
  <main class="container">
    <h1>ESP32 Raumklima-Monitor</h1>

    <p class="subtitle">
      Keyestudio Inventor Starter Kit
    </p>
)HTML";

  html += "<section class='status ";
  html += climateStatusCssClass(currentStatus);
  html += "'>";

  html += "<p class='status-label'>Aktueller Raumklimastatus</p>";
  html += "<p class='status-value'>";
  html += climateStatusText(currentStatus);
  html += "</p>";
  html += "</section>";

  html += "<section class='grid'>";

  html += "<article class='card'>";
  html += "<h2>Temperatur</h2>";

  if (sensorAvailable) {
    html += "<p class='measurement'>";
    html += String(temperature, 1);
    html += " &deg;C</p>";
  } else {
    html += "<p class='measurement'>--</p>";
  }

  html += "<p class='range'>";
  html += "Optimal: ";
  html += String(TEMP_GOOD_MIN, 0);
  html += " bis ";
  html += String(TEMP_GOOD_MAX, 0);
  html += " &deg;C";
  html += "</p>";
  html += "</article>";

  html += "<article class='card'>";
  html += "<h2>Relative Luftfeuchtigkeit</h2>";

  if (sensorAvailable) {
    html += "<p class='measurement'>";
    html += String(humidity, 1);
    html += " %</p>";
  } else {
    html += "<p class='measurement'>--</p>";
  }

  html += "<p class='range'>";
  html += "Optimal: ";
  html += String(HUMIDITY_GOOD_MIN, 0);
  html += " bis ";
  html += String(HUMIDITY_GOOD_MAX, 0);
  html += " %";
  html += "</p>";
  html += "</article>";

  html += "</section>";

  html += R"HTML(
    <footer class="footer">
      Die Werte werden automatisch alle fünf Sekunden aktualisiert.
    </footer>
  </main>
</body>
</html>
)HTML";

  return html;
}

// ------------------------------------------------------------
// Webserver-Routen
// ------------------------------------------------------------

void handleRoot() {
  server.send(
    200,
    "text/html; charset=utf-8",
    generateHtmlPage());
}

void handleJsonData() {
  String json = "{";

  json += "\"sensorAvailable\":";
  json += sensorAvailable ? "true" : "false";

  json += ",\"temperature\":";
  json += String(temperature, 1);

  json += ",\"humidity\":";
  json += String(humidity, 1);

  json += ",\"status\":\"";
  json += climateStatusText(currentStatus);
  json += "\"";

  json += "}";

  server.send(
    200,
    "application/json; charset=utf-8",
    json);
}

void handleNotFound() {
  server.send(
    404,
    "text/plain; charset=utf-8",
    "Seite nicht gefunden");
}

// ------------------------------------------------------------
// WLAN-Verbindung
// ------------------------------------------------------------

void connectToWifi() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("WLAN verbinden");

  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

  Serial.print("WLAN-Verbindung wird hergestellt");

  uint8_t dotPosition = 0;

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");

    lcd.setCursor(dotPosition, 1);
    lcd.print(".");

    dotPosition++;

    if (dotPosition >= 16) {
      dotPosition = 0;
      clearLcdLine(1);
    }
  }

  Serial.println();
  Serial.println("WLAN verbunden");
  Serial.print("IP-Adresse: ");
  Serial.println(WiFi.localIP());

  showIpAddress();
  delay(3000);
}

void showPixelColor(uint32_t color) {
  pixels.fill(color);
  pixels.show();
}

void updateStatusLeds() {
  pixels.clear();

  switch (currentStatus) {
    case ClimateStatus::GOOD:
      pixels.setPixelColor(0, pixels.Color(0, 255, 0));
      pixels.setPixelColor(1, pixels.Color(0, 255, 0));
      break;

    case ClimateStatus::WARNING:
      pixels.setPixelColor(2, pixels.Color(255, 100, 0));
      pixels.setPixelColor(3, pixels.Color(255, 100, 0));
      break;

    case ClimateStatus::BAD:
      pixels.setPixelColor(4, pixels.Color(255, 0, 0));
      pixels.setPixelColor(5, pixels.Color(255, 0, 0));
      break;

    case ClimateStatus::SENSOR_ERROR:
    default:
      pixels.fill(pixels.Color(180, 0, 180));
      break;
  }

  pixels.show();
}

// ------------------------------------------------------------
// Setup
// ------------------------------------------------------------

void setup() {
  Serial.begin(115200);

  pixels.begin();
  pixels.setBrightness(LED_BRIGHTNESS);
  pixels.clear();
  pixels.show();

  // I2C und LCD
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);

  lcd.init();
  lcd.backlight();

  // Punktmatrix
  matrix.shutdown(0, false);
  matrix.setIntensity(0, 5);
  matrix.clearDisplay(0);

  // Beim Start zunächst Warnsymbol anzeigen
  drawMatrixImage(ERROR_SYMBOL);

  // WLAN herstellen
  connectToWifi();

  // Ersten Sensorwert erfassen
  readSensor();
  updateLcd();

  lastSensorRead = millis();
  lastLcdChange = millis();

  // Webserver konfigurieren
  server.on("/", HTTP_GET, handleRoot);
  server.on("/data", HTTP_GET, handleJsonData);
  server.onNotFound(handleNotFound);

  server.begin();

  Serial.println("Webserver wurde gestartet.");
}

// ------------------------------------------------------------
// Loop
// ------------------------------------------------------------

void loop() {
  server.handleClient();

  const unsigned long currentMillis = millis();

  if (currentMillis - lastSensorRead >= SENSOR_INTERVAL_MS) {
    lastSensorRead = currentMillis;
    readSensor();
  }

  if (currentMillis - lastLcdChange >= LCD_INTERVAL_MS) {
    lastLcdChange = currentMillis;
    updateLcd();
  }

  if (currentMillis - lastWifiCheck >= WIFI_CHECK_INTERVAL_MS) {
    lastWifiCheck = currentMillis;

    if (WiFi.status() != WL_CONNECTED) {
      Serial.println("WLAN-Verbindung verloren – neuer Versuch");
      WiFi.disconnect();
      WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    }
  }
}

Vorteile und Nachteile im Überblick

Nach meinem Praxistest ergeben sich für das Keyestudio ESP32 Inventor Starter Kit folgende Stärken und Schwächen:

Fazit zum Keyestudio ESP32 Inventor Starter Kit

Das Keyestudio ESP32 Inventor Starter Kit bietet aus meiner Sicht alles, was benötigt wird, um abwechslungsreiche und durchaus anspruchsvolle Projekte mit dem ESP32 umzusetzen. Durch die bereits fest verbauten Sensoren, Anzeigen, LEDs und Bedienelemente lassen sich Ideen schnell ausprobieren, ohne zunächst eine komplette Schaltung auf einem Breadboard aufbauen zu müssen.

Dabei eignet sich das Board nicht nur für einfache Lernübungen oder kurze Funktionstests. Mit dem Raumklima-Monitor habe ich gezeigt, dass daraus auch ein Projekt mit echtem praktischem Nutzen entstehen kann. Temperatur und Luftfeuchtigkeit werden erfasst, auf mehreren Anzeigen ausgegeben und zusätzlich über einen Webserver im Browser bereitgestellt. So kann das Board dauerhaft auf dem Schreibtisch stehen und dort tatsächlich eine sinnvolle Aufgabe übernehmen.

Besonders gut gefällt mir die freie Wahl der GPIOs. Dadurch bleibt man bei der Umsetzung eigener Projekte flexibel und kann die vorhandenen Komponenten passend zum jeweiligen Sketch miteinander kombinieren. Etwas schade ist allerdings, dass die vorgesehene Nano-Kompatibilität bei meinem Testexemplar aufgrund der Abstände der Buchsenleisten nicht wie erwartet nutzbar war.

Insgesamt ist das Keyestudio Inventor Starter Kit dennoch eine interessante Plattform für Einsteiger, Maker und erfahrene Entwickler. Es verbindet den Komfort eines fertig aufgebauten Lernboards mit genügend Freiheit für eigene Ideen und eignet sich damit sowohl zum Experimentieren als auch für nützliche ESP32-Projekte.

Häufige Fragen zum Keyestudio ESP32 Inventor Starter Kit

Ist ein ESP32 im Keyestudio Inventor Starter Kit enthalten?

Ja, zum Lieferumfang des von mir getesteten Kits gehört ein passendes ESP32-Modul. Auch das USB-Kabel zur Programmierung und Stromversorgung ist bereits enthalten.

Eignet sich das Inventor Starter Kit für Einsteiger?

Ja. Viele Sensoren, LEDs, Taster und Anzeigen sind bereits fest auf dem Board montiert und mit Spannung versorgt. Für ein Projekt müssen hauptsächlich die benötigten Signalleitungen mit den passenden GPIOs des ESP32 verbunden werden.

Benötige ich für die Projekte ein zusätzliches Breadboard?

Für viele Projekte ist kein zusätzliches Breadboard erforderlich. Die wichtigsten Komponenten sind bereits auf dem Experimentierboard vorhanden. Die Verbindungen werden mit den mitgelieferten Buchse-zu-Buchse-Kabeln hergestellt.

Kann ich die GPIO-Pins frei auswählen?

Ja. Die Signalanschlüsse der Komponenten sind nicht dauerhaft mit bestimmten GPIOs verbunden. Dadurch kannst du die Pinbelegung passend zu deinem Projekt und dem verwendeten Sketch selbst festlegen.

Welche Projekte lassen sich mit dem Board umsetzen?

Mit dem Kit lassen sich unter anderem Projekte mit LEDs, Tastern, Sensoren, LCD, Punktmatrix, Servomotor, Ultraschallsensor und WLAN umsetzen. Durch den ESP32 sind außerdem Webserver-, Bluetooth- und IoT-Projekte möglich.

Was zeigt der Raumklima-Monitor an?

Der Raumklima-Monitor misst Temperatur und relative Luftfeuchtigkeit mit dem DHT11. Die Werte werden auf dem LCD und einer lokalen Webseite angezeigt. Eine Punktmatrix sowie sechs WS2812B-LEDs visualisieren zusätzlich den aktuellen Raumklimastatus.

Funktioniert der Raumklima-Monitor auch ohne Internetzugang?

Ja. Der ESP32 benötigt lediglich eine Verbindung zum lokalen WLAN. Die Webseite wird direkt vom ESP32 bereitgestellt und kann innerhalb des eigenen Netzwerks über seine lokale IP-Adresse geöffnet werden. Eine Internetverbindung ist dafür nicht erforderlich.

Wo finde ich den Arduino-Sketch für das Projekt?

Den vollständigen Sketch für den ESP32-Raumklima-Monitor stelle ich im Beitrag als ZIP-Datei zum Download bereit. Vor dem Hochladen müssen noch die eigenen WLAN-Zugangsdaten eingetragen werden.

Muss die LedControl-Bibliothek für den ESP32 angepasst werden?

Je nach verwendeter Version kann eine kleine Änderung in der Datei LedControl.h erforderlich sein. Dabei wird die feste Einbindung von avr/pgmspace.h durch eine Abfrage ersetzt, die für den ESP32 die passende Datei pgmspace.h lädt.

Kann ein klassischer Arduino Nano mit dem Board verwendet werden?

Das Board besitzt Buchsenleisten, die offenbar für Mikrocontroller im Arduino-Nano-Format vorgesehen sind. Bei meinem Testexemplar stimmte der Abstand der Leisten jedoch nicht mit meinem Arduino Nano überein. Deshalb ließ er sich nicht korrekt einsetzen. Ob dies alle Exemplare betrifft, kann ich nicht abschließend beurteilen.

Letzte Aktualisierung am: 05. August 2026