Einfache IoT-Projekte mit Arduino UNO, ESP-01, ThingSpeak & MIT App Inventor

Komponenten und Zubehör

Arduino UNO	×	1
Espressif ESP8266 ESP-01	×	1
DHT22 Temperatursensor (Luftfeuchte & Temperatur)	×	1
DS18B20 1-Wire Bodentemperatursensor	×	1
LDR (Lichtabhängiger Widerstand)	×	1
2-Kanal 5V Relais-Modul	×	1

Apps & Online-Dienste

• Arduino IDE
• ThingSpeak API (IoT-Plattform)
• MIT App Inventor (Android-App-Entwicklung)

Über dieses Projekt

Ziel: Sensordaten lokal erfassen, an die Cloud (ThingSpeak) senden, weltweit einsehbar machen und per Android-App Aktoren (Pumpe, Lampe) fernsteuern. Klassischer IoT-Datenfluss:

Lokale Einheit (UNO + ESP-01) → Sensoren lesen → WRITE an ThingSpeak Status-Channel → READ aus ThingSpeak Aktor-Channels → Aktoren steuern.

Android-App → READ Status-Channel (Anzeige) → WRITE Aktor-Channels (Befehle).

Schritt 1: Einführung

Erfasste Sensordaten:

• Lufttemperatur & relative Feuchte (DHT22)
• Bodentemperatur (DS18B20)
• Bodenfeuchte (YL-69 + LM393)
• Helligkeit (LDR)

Aktoren:

• Elektrische Pumpe (Relais 1)
• Elektrische Lampe (Relais 2)

Entscheidungslogik (manuell per App):

• Pumpe EIN bei zu niedriger Bodenfeuchte
• Lampe EIN bei zu niedriger Bodentemperatur

Schritt 2: Stückliste (BoM)

Arduino UNO (~10$), ESP-01 (~3,50$), DHT22 (~9$), DS18B20 (~6$), Bodenfeuchtesensor (~2$), LDR (~0,20$), 2 LEDs, 2-Kanal Relais-Modul mit Optokoppler Low-Level Trigger (~7$), 5V Pumpe (~3$), 220V Lampe, Widerstände (2×330Ω, 2×10kΩ, 1×4,7kΩ), Steckbrett, Jumper, externes 5V Netzteil für Relais.

Schritt 3: Hardware-Aufbau (schrittweise)

1. Alle Sensoren lokal installieren & testen
2. ESP-01 initial konfigurieren (BareMinimum)
3. ESP-01 final verdrahten & testen
4. ThingSpeak Status-Channel anlegen
5. Arduino-Code für Sensoren → Cloud testen
6. Android-App v1 (Status-Anzeige) entwickeln
7. Aktoren (LEDs, Relais) installieren
8. ThingSpeak Aktor-Channels anlegen
9. Arduino-Code mit Aktoren testen
10. Finale Android-App entwickeln

Schritt 4: Sensoren anschließen & testen

Bibliotheken: OneWire, DallasTemperature, DHT.

// DS18B20
#define ONE_WIRE_BUS 5
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
int soilTemp = 0;

// DHT22
#define pinoDHT 11
#define tipoDHT DHT22
DHT dht(pinoDHT, tipoDHT);
int airTemp=0, airHum=0;

// LDR
#define ldrPIN A1
int light=0;

// Bodenfeuchte
#define soilHumPIN A0
int soilHum=0;

void setup() {
  Serial.begin(9600);
  DS18B20.begin(); dht.begin();
}
void loop() {
  readSensors(); displaySensors(); delay(10000);
}
void readSensors() {
  airTemp = dht.readTemperature();
  airHum  = dht.readHumidity();
  DS18B20.requestTemperatures();
  soilTemp = DS18B20.getTempCByIndex(0);
  soilHum = map(analogRead(soilHumPIN), 1023, 0, 0, 100);
  light   = map(analogRead(ldrPIN), 1023, 0, 0, 100);
}
void displaySensors() {
  Serial.print("airTemp (C): "); Serial.println(airTemp);
  Serial.print("airHum (%): ");  Serial.println(airHum);
  Serial.print("soilTemp (C): "); Serial.println(soilTemp);
  Serial.print("soilHum (%): ");  Serial.println(soilHum);
  Serial.print("light (%): ");    Serial.println(light);
  Serial.println();
}

Schritt 5: ESP-01 Initialkonfiguration (AT-Befehle)

1. ESP-01 mit Arduino als USB-Seriell-Wandler verbinden (RX↔RX, TX↔TX, CH_PD→3,3V, RST→D8, VCC→3,3V, GND→GND).
2. Arduino mit BareMinimum Sketch flashen (keine serielle Kollision).
3. Serieller Monitor: 115200 Baud → AT → OK.
4. Baudrate auf 9600 setzen: AT+UART_DEF=9600,8,1,0,0.
5. Monitor auf 9600 Baud umstellen, AT testen.
6. Station Mode (Client): AT+CWMODE=1.
7. WLAN verbinden: AT+CWJAP="SSID","PASSWORT" → WIFI CONNECTED / WIFI GOT IP.
8. IP prüfen: AT+CIFSR.

Schritt 6: ESP-01 Test (finale Verdrahtung)

Neue Verkabelung: ESP-RX→D7, ESP-TX→D6, CH_PD→3,3V, RST→D8, VCC→3,3V, GND→GND.

#include 
SoftwareSerial esp8266(6,7); // RX=D6, TX=D7
#define speed8266 9600
void setup() {
  esp8266.begin(speed8266);
  Serial.begin(speed8266);
  Serial.println("ESP8266 Test - AT Befehle");
}
void loop() {
  while(esp8266.available()) Serial.write(esp8266.read());
  while(Serial.available()) esp8266.write(Serial.read());
}

AT-Befehle testen: AT, AT+RST, AT+GMR, AT+CWMODE?, AT+CWLAP, AT+CIFSR.

Automatischer WLAN-Reconnect beim Reset: Funktion connectWiFi() im setup() aufrufen.

Schritt 7: Sensoren + ESP-01 zusammenführen

Alle Sensoren und ESP-01 final verdrahten.

Schritt 8: ThingSpeak einrichten

Account erstellen → Neuen Channel anlegen mit 8 Feldern:

Feld	Inhalt
Field 1	Aktor 1 (Pumpe)
Field 2	Aktor 2 (Lampe)
Field 3	Lufttemperatur (°C)
Field 4	Luftfeuchte (%)
Field 5	Bodentemperatur (°C)
Field 6	Bodenfeuchte (%)
Field 7	Helligkeit (%)
Field 8	Reserve (z.B. Fehlerzähler)

Write API Key notieren.

Schritt 9: Status an Cloud senden (WRITE)

HTTP GET an api.thingspeak.com/update per AT-Befehle:

AT+CIPSTART="TCP","184.106.153.149",80
AT+CIPSEND=116
GET /update?api_key=DEIN_WRITE_KEY&field1=pump&field2=lamp&field3=airTemp&field4=airHum&field5=soilTemp&field6=soilHum&field7=light&field8=spare

Arduino-Code nutzt Timer (17s Intervall), Fehlerwiederholung (goto start) und Hardware-Reset des ESP-01 bei Problemen.

Schritt 10: Android-App Teil 1 – Status überwachen (MIT App Inventor)

• UI: Labels für alle Sensoren/Aktoren, Clock-Timer (2s).
• Blöcke: Alle 2s readArduino Prozedur → GET auf ThingSpeak Status-Channel → JSON parsen → Labels aktualisieren.
• 0/1 → "AUS"/"EIN" umwandeln.
• Alarm: Bei Bodentemp < 10°C oder Bodenfeuchte < 60% blinkende Warnung (Clock2 toggelt Farbe).

Schritt 11: Aktoren installieren (LEDs & Relais)

Relais-Modul mit Optokoppler (Low-Level Trigger), separate 5V-Versorgung, Relais-GND nicht mit Arduino-GND verbinden (Entkopplung).

Schritt 12: ThingSpeak Aktor-Channels konfigurieren

Zwei neue Channels (je einer pro Aktor), nur Field 1 nutzen:

• Channel 375598 → Rote LED (Pumpe): 0=AUS, 1=EIN
• Channel 375599 → Grüne LED (Lampe): 0=AUS, 1=EIN

Read/Write API Keys notieren.

Schritt 13: Arduino-Code mit Aktoren (READ von ThingSpeak)

Alle 10s GET auf /channels/CHANNEL_ID/fields/1/last → Wert an Position 5 der Antwort prüfen (ASCII '0'=48, '1'=49).

int readThingSpeak(String channelID) {
  // ... AT+CIPSTART, AT+CIPSEND, GET /channels/ID/fields/1/last
  // Antwort parsen: messageDown[5] == 49 ? command = messageDown[7]-48 : command = 9 (Fehler)
  return command;
}

Relais sind Low-Active: digitalWrite(RELAIS, LOW) = EIN.

Schritt 14: Aktor-Befehle per Browser testen

Direkte URLs:

https://api.thingspeak.com/update?api_key=ACT1_WRITE_KEY&field1=1  // Pumpe EIN
https://api.thingspeak.com/update?api_key=ACT1_WRITE_KEY&field1=0  // Pumpe AUS
https://api.thingspeak.com/update?api_key=ACT2_WRITE_KEY&field1=1  // Lampe EIN
https://api.thingspeak.com/update?api_key=ACT2_WRITE_KEY&field1=0  // Lampe AUS

Schritt 15: Android-App vervollständigen (Aktor-Steuerung)

Zwei Button-Paare (EIN/AUS) pro Aktor. Button-Drücken → Farbe ändern (Blau/Rot) → HTTP GET auf jeweiligen Aktor-Channel Write-Key senden.

Schritt 16: Alles zusammenfügen (Finaler Code)

Kombiniert: Sensoren lesen → Status WRITE → Aktor-Befehle READ → Aktionen ausführen → ESP-01 Gesundheitsprüfung (AT vor jeder Kommunikation) → Hardware-Reset bei Fehler.

Vollständiger Code: ArduFarmBot_Light_EXT.ino (GitHub).

Schritt 17: Fazit

Arduino UNO + ESP-01 sind nach wie vor hervorragende Einstiegsgeräte für IoT. Weitere Tutorials folgen. Viel Spaß beim Nachbauen!

GitHub: ArduFarmBot_Light | Blog: MJRoBot.org

Code-Schnipsel (Referenz)

Alle vollständigen Sketche im GitHub-Repository.

Schaltplan

Fritzing-Datei: ArduFarmBot_Light.fzz (GitHub).