Earth Analyzer: Fortgeschrittenes IoT-Sensorkit für Umweltmonitoring & Landwirtschaft

Komponenten und Materialien

Bolt IoT WiFi-Modul	1
Arduino UNO	1
Arduino Nano R3	1
nRF24L01 Funkmodul (2,4 GHz)	2
DC-Motoren 12 V (Antrieb)	2
DFRobot Solar Power Manager (12 V Blei-Säure)	1
L298 Dual H-Brücke Motortreiber	1
Jumper-Kabel	1 Satz
LM35 Temperatursensor	1
DFRobot Gravity Kapazitiver Bodenfeuchtesensor	1
SG90 Mikro-Servo (z. B. für Sensor-Ausrichtung)	1
Joystick 10 kΩ (2× für Fernsteuerung)	2

Benötigte Werkzeuge

• Lötkolben, Lötzinn (bleifrei), Lötflussmittel
• Multitool / Schraubendreher

Apps & Cloud-Dienste

• Arduino IDE
• Bolt Cloud & Bolt Mobile Apps (Android/iOS)
• Integromat (Make) für Workflow-Automatisierung
• Twilio (SMS), Mailgun (E-Mail), Telegram (Bot)

Projektstruktur – Drei Module

Modul 1: Rover-Plattform & Sensorik (Bolt + Arduino UNO)

Zwei DC-Motoren werden über L298 H-Brücke angesteuert. Der Bolt WiFi-Modul übernimmt die Cloud-Anbindung (Sensorwerte, Steuerbefehle). Sensoren:

• Bodenfeuchte (digitaler Pin 4 am Bolt)
• Temperatur LM35 (analoger Pin A0 am Bolt)

Stromversorgung: Solar-Manager lädt 12 V-Bleiakku, versorgt Motoren und 5 V-Logik (Arduino, Bolt, Sensoren).

Modul 2: Funk-Fernsteuerung (nRF24L01 + Arduino Nano + Joysticks)

Zwei nRF24L01 Module (Transmitter/Receiver) für kurze Reichweite (ca. 50–100 m).

• Sender (Handgerät): Arduino Nano + 2 Joysticks (X/Y für Fahrtrichtung, X/Y für Servo).
• Empfänger (Rover): Arduino UNO + nRF24L01 → steuert L298 (Fahrt) und Servo (z. B. Kamera-Schwenk).

Modul 3: Cloud-Alarme & Fernabfrage (Bolt Cloud, Integromat, Telegram, Twilio, Mailgun)

Telegram-Bot für Schwellenwert-Alarme: Python-Skript auf Server (z. B. Replit) fragt periodisch Bolt Cloud ab (digitalRead Pin 4 = Bodenfeuchte). Überschreitet Wert Schwellwert → Telegram-Nachricht an Channel.

# main.py (Python auf Server)
import requests, json, time
from boltiot import Bolt
import conf

mybolt = Bolt(conf.bolt_api_key, conf.device_id)

def get_sensor_value(pin):
    try:
        resp = mybolt.digitalRead(pin)
        data = json.loads(resp)
        if data["success"] != 1: return -999
        return int(data["value"])
    except Exception as e:
        print(e); return -999

def send_telegram(msg):
    url = f"https://api.telegram.org/{conf.telegram_bot_id}/sendMessage"
    data = {"chat_id": conf.telegram_chat_id, "text": msg}
    try:
        r = requests.get(url, params=data)
        return json.loads(r.text)["ok"]
    except Exception as e:
        print(e); return False

while True:
    val = get_sensor_value("4")
    print("Sensor:", val)
    if val == -999: time.sleep(10); continue
    if val >= conf.threshold:
        send_telegram(f"Feuchtewert {val} über Schwellwert!")
    time.sleep(100)

conf.py: Enthält API-Keys, Device-ID, Telegram Bot/Chat IDs, Threshold.

Telegram einrichten (Kurzfassung)

1. Telegram App installieren, Account erstellen.
2. Channel erstellen (öffentlich, permanenter Link notieren).
3. BotFather kontaktieren → /newbot → Bot-Token notieren (Format: bot).
4. Bot als Administrator zum Channel hinzufügen (Recht: „Post Messages“).

SMS & E-Mail per Google Assistant (Integromat/Make)

Szenario in Integromat:

1. IFTTT Webhook (Trigger: Google Assistant Befehl „Sende Sensordaten“).
2. HTTP Request an Bolt Cloud: https://cloud.boltiot.com/remote//analogRead?pin=A0&deviceName=BOLT.
3. Router → zwei Pfade:
4. Mailgun: E-Mail mit Temperaturwert (Sensorwert / 10,24 = °C).
5. Twilio: SMS mit gleichem Wert.

IFTTT Applet: Google Assistant → Webhooks → Integromat-Webhook-URL.

Code: nRF24L01 Sender (Handgerät)

#include 
#include 
#include 
RF24 radio(7, 8); const byte address[6] = "00001";
int x_key=A1, y_key=A0, p_key=A3, q_key=A2;
int x_pos, y_pos, p_pos, q_pos, pos;

void setup() {
  radio.begin(); radio.openWritingPipe(address);
  radio.setPALevel(RF24_PA_MIN); radio.setChannel(87);
  radio.setDataRate(RF24_250KBPS); radio.stopListening();
  Serial.begin(9600);
  pinMode(x_key,INPUT); pinMode(y_key,INPUT);
  pinMode(p_key,INPUT); pinMode(q_key,INPUT);
}

void loop() {
  x_pos=analogRead(x_key); y_pos=analogRead(y_key);
  p_pos=analogRead(p_key); q_pos=analogRead(q_key);
  // Joystick 1 (Fahrt): Mitte ~500
  if (p_pos>400 && p_pos<600 && q_pos>400 && q_pos<600) {
    if (x_pos>400 && x_pos<600 && y_pos<400) pos=200; // vorwärts
    else if (x_pos>400 && x_pos<600 && y_pos>600) pos=300; // rückwärts
    else if (y_pos>400 && y_pos<600 && x_pos<400) pos=400; // links
    else if (y_pos>400 && y_pos<600 && x_pos>600) pos=500; // rechts
    else pos=100; // stop
    radio.write(&pos, sizeof(pos)); delay(100);
  }
  // Joystick 2 (Servo)
  else if (p_pos<400 || p_pos>600) {
    if (p_pos<400) pos=600; // Servo 90°
    else pos=700; // Servo 180°
    radio.write(&pos, sizeof(pos)); delay(100);
  }
}

Code: nRF24L01 Empfänger (Rover)

#include 
#include 
#include 
#include 
RF24 radio(7,8); const byte address[6]="00001";
Servo servo; int servo_pin=9;
void setup() {
  Serial.begin(9600); radio.begin();
  servo.attach(servo_pin);
  radio.openReadingPipe(0,address);
  radio.setPALevel(RF24_PA_MIN); radio.setChannel(87);
  radio.setDataRate(RF24_250KBPS); radio.startListening();
  pinMode(3,OUTPUT); pinMode(4,OUTPUT); pinMode(5,OUTPUT); pinMode(6,OUTPUT);
}
void loop() {
  if (radio.available()) {
    int pos; radio.read(&pos, sizeof(pos)); Serial.println(pos);
    switch(pos) {
      case 100: digitalWrite(3,LOW); digitalWrite(4,LOW); digitalWrite(5,LOW); digitalWrite(6,LOW); break; // Stop
      case 200: digitalWrite(3,HIGH); digitalWrite(4,LOW); digitalWrite(5,HIGH); digitalWrite(6,LOW); break; // Vorwärts
      case 300: digitalWrite(3,LOW); digitalWrite(4,HIGH); digitalWrite(5,LOW); digitalWrite(6,HIGH); break; // Rückwärts
      case 400: digitalWrite(3,LOW); digitalWrite(4,HIGH); digitalWrite(5,HIGH); digitalWrite(6,LOW); break; // Links
      case 500: digitalWrite(3,HIGH); digitalWrite(4,LOW); digitalWrite(5,LOW); digitalWrite(6,HIGH); break; // Rechts
      case 600: servo.write(90); break;
      case 700: servo.write(180); break;
      default: Serial.println("connection lost");
    }
  }
}

Schaltplan (Gesamt)

Zusammenfassung

Der Earth Analyzer vereint:

• Solar-betriebenen Rover mit Bodenfeuchte- & Temperatursensorik (Bolt Cloud).
• Lokale Funkfernsteuerung per nRF24L01 & Joystick.
• Cloud-basierte Alarme (Telegram) und Sprachsteuerung (Google Assistant → IFTTT → Integromat → Twilio/Mailgun).

Ideal für Precision Farming, Umweltmonitoring oder als Lernplattform für IoT, Funk & Cloud-Integration.