Der erste Pflanzensensor

Ein Bioelektrik-Sensor auf dem Steckbrett — miss die elektrischen Signale einer lebenden Pflanze. Grundlage für alle weiteren Pflanzen-Aktivitäten.

Worum es geht

In Kapitel 11 hast du gelesen, dass Pflanzen elektrische Signale tragen — ähnlich wie dein Herz oder deine Nerven, nur viel langsamer und viel schwächer. In dieser Aktivität baust du genau das Gerät, mit dem man diese Signale sichtbar macht. Es ist im Kern dieselbe Technik, die hinter der Biolingo-/GreenMind-Plattform und der Phänomena-Ausstellung „Stille Signale“ steckt — nur klein, günstig und selbst gebaut.

Am Ende hältst du ein Blatt an, schaltest das Licht aus oder näherst dich der Pflanze — und siehst, wie die Kurve auf dem Display darauf reagiert. Ob das schon „Wahrnehmung“ ist oder nur Physik, ist genau die Frage, die dieses Buch umtreibt. Miss zuerst, staune dann, und bleibe skeptisch.

Was du brauchst

Alle Teile gibt es als fertigen Bausatz oder einzeln im Elektronik-Versand. Die Preise sind grobe Richtwerte.

Dazu: ein Laptop mit der kostenlosen Arduino-IDE und eine kräftige Zimmerpflanze. Am besten geeignet ist eine Kalanchoe (dicke, wachsige Blätter) — mehr dazu weiter unten.

Ein bisschen Hintergrund

Was ist ein bioelektrisches Signal? Jede lebende Zelle hält an ihrer Hülle eine kleine elektrische Spannung. Wenn sich in einer Pflanze etwas ändert — sie wird berührt, das Licht wechselt, sie verliert Wasser —, laufen Spannungswellen durch das Gewebe, ähnlich den Nervenimpulsen bei uns. Genau diese Wellen fängst du ab.

Warum ist das so schwierig? Zwei Gründe. Erstens ist das Signal winzig — wir reden von Millionstel Volt (Mikrovolt). Deshalb der Verstärker (AD8232). Zweitens ist es sehr langsam: Pflanzensignale schwingen nur mit etwa 0,1 bis 10 Hz, also höchstens ein paar Mal pro Sekunde.

Warum brauchen wir einen Filter? Aus jeder Steckdose und jedem Kabel in der Wand strahlt das Stromnetz mit 50 Hz ab. Dieses „Netzbrummen“ ist viel stärker als das Pflanzensignal und würde es überdecken. Ein einfacher RC-Tiefpass — ein Widerstand und ein Kondensator — lässt die langsamen Pflanzensignale durch und dämpft alles Schnellere. Seine Grenzfrequenz berechnet sich so:

Alles unter 16 Hz (dein Pflanzensignal) kommt durch, das 50-Hz-Brummen wird gedämpft. Merke dir die Formel — sie ist der ganze Trick.

So funktioniert das Steckbrett

Wenn du noch nie ein Steckbrett benutzt hast, ist das hier das Wichtigste — sonst steckst du Bauteile in Löcher, die gar nicht verbunden sind.

Ein Bauteil „verbindet“ also zwei Punkte, indem beide Beinchen in dieselbe Fünferspalte gesteckt werden — oder man führt eine Steckbrücke von einer Spalte zur nächsten.

Bauteile erkennen

Der 10-kΩ-Widerstand trägt vier Farbringe: braun–schwarz–orange–gold. Widerstände haben keine Polung, du kannst sie beliebig herum einstecken.

Der 1-µF-Keramikkondensator ist eine kleine Scheibe, meist mit „105“ beschriftet. Wichtig: Nimm die Keramik-Variante — sie hat keine Polung. (Ein Elektrolyt-Kondensator hätte ein langes Plus- und ein kurzes Minus-Beinchen.)

Die drei Module erkennst du so: Der ESP32 ist die längliche Platine mit dem silbernen Metalldeckel und dem USB-Anschluss. Der AD8232 ist die kleine rote Platine mit aufgedrucktem Herz und den Beschriftungen GND, 3.3V, OUTPUT. Das OLED ist das kleine Glas-Display mit vier Pins: VCC, GND, SCL, SDA.

Der Schaltplan in Worten

Bevor du steckst, präg dir den Weg des Signals ein:

• Strom: Der ESP32 bekommt Strom über USB und gibt an seinem 3V3-Pin 3,3 Volt aus. Von dort versorgst du AD8232 und OLED. Es gibt keine zweite Stromquelle.
• Signalweg: Blatt → Gel-Elektrode → AD8232 (verstärkt) → OUTPUT → 10-kΩ-Widerstand → Knotenpunkt → GPIO34 (der misst). Am Knotenpunkt hängt zusätzlich der 1-µF-Kondensator gegen GND — das ist der Filter.
• Anzeige: Das OLED spricht per I²C mit dem ESP32 — zwei Datenleitungen: SCL an GPIO22, SDA an GPIO21.

Schritt für Schritt

Stecke das USB-Kabel jetzt noch NICHT ein. Erst bauen, dann prüfen, dann Strom.

1. ESP32 einsetzen. Setze den ESP32 mittig so ein, dass er den Graben überbrückt — die eine Pinreihe in der oberen Hälfte, die andere in der unteren. Nur so bekommt jeder Pin seine eigene Fünferspalte. (Sitzt er ganz auf einer Seite, sind seine Pins kurzgeschlossen — der häufigste Anfängerfehler.)
2. Strom-Schienen anlegen. Führe mit zwei kurzen Brücken den 3V3-Pin des ESP32 auf die rote (+)-Schiene und einen GND-Pin auf die blaue (−)-Schiene. Von diesen Schienen versorgst du gleich beide Module.
3. Den RC-Filter bauen. Stecke den 10-kΩ-Widerstand mit einem Beinchen in eine freie Spalte (das wird der Knotenpunkt). Vom Knotenpunkt steckst du den 1-µF-Kondensator zur GND-Schiene. Der Knotenpunkt ist das Herz des Filters.
4. AD8232 anschliessen. 3.3V des AD8232 an die (+)-Schiene, GND an die (−)-Schiene, OUTPUT mit einer Brücke an das freie Beinchen des Widerstands (also in den Signalweg vor dem Knotenpunkt).
5. Filter an den Messeingang. Verbinde den Knotenpunkt (Widerstand-Ausgang / Kondensator) mit GPIO34 des ESP32. An diesem Pin misst der ESP32 gleich die Spannung.
6. OLED anschliessen. VCC an (+), GND an (−). Dann die zwei Datenleitungen: SCL an GPIO22, SDA an GPIO21. Fertig verkabelt.
7. USB einstecken. Prüfe alles noch einmal anhand der Tabelle unten, dann stecke das Micro-USB-Kabel ein. Der ESP32 leuchtet auf und versorgt alles mit Strom.

Verkabelung auf einen Blick

Das sind 7 Steckbrücken plus Widerstand, Kondensator und Elektrodenkabel — mehr nicht.

Die Software: Arduino-IDE einrichten

Damit der ESP32 weiss, was er tun soll, spielst du ihm ein kleines Programm auf (den „Sketch“). Das machst du mit der kostenlosen Arduino-IDE.

1. Arduino-IDE installieren. Lade sie von arduino.cc herunter und installiere sie.
2. ESP32-Unterstützung hinzufügen. Öffne Datei ▸ Voreinstellungen und trage bei „Zusätzliche Boardverwalter-URLs“ ein: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
3. Board installieren. Öffne Werkzeuge ▸ Board ▸ Boardverwalter, suche nach „esp32“ und installiere das Paket von Espressif.
4. Board auswählen. Wähle unter Werkzeuge ▸ Board den Eintrag „DOIT ESP32 DEVKIT V1“.
5. Bibliotheken installieren. Öffne Werkzeuge ▸ Bibliotheken verwalten und installiere „Adafruit SSD1306“ und „Adafruit GFX Library“.
6. Port wählen. Stecke den ESP32 ein und wähle unter Werkzeuge ▸ Port den neu erschienenen COM-/USB-Port. (Erscheint keiner, fehlt evtl. der USB-Treiber CP210x oder CH340 — kurz nachinstallieren.)
7. Hochladen. Öffne den Sketch (unten auf dieser Seite oder auf GitHub) und klicke auf „Hochladen“. Klemmt es beim Start, halte die BOOT-Taste am ESP32 gedrückt, bis der Upload beginnt.

Die Elektrode ans Blatt

Jetzt kommt der schönste Moment: die Verbindung zur Pflanze. Du brauchst nur eine einzige Gel-Elektrode auf einem einzigen Blatt.

Welche Pflanze?

• Kalanchoe (empfohlen): dicke, wachsige Blätter halten die Elektrode gut — am gutmütigsten für den Anfang.
• Primel: weichere, dünnhäutige Blätter, oft schönes Signal; drücke die Elektrode sanft an.
• Tradescantia: glatte, saftige Blätter, gute Leitfähigkeit.

Was du sehen solltest

Auf dem OLED läuft von rechts nach links eine Linie durch — dein Pflanzensignal in Echtzeit. Am Anfang wandert sie oft langsam auf und ab, während sich der Kontakt „einpendelt“ (ein bis zwei Minuten). Eine völlig flache oder wild zappelnde Linie deutet auf ein Kontakt- oder Verkabelungsproblem hin — siehe unten.

Jetzt experimentieren

Sobald die Kurve läuft, probier aus, worauf die Pflanze reagiert:

• Berühre ein Blatt sanft — beobachte, ob die Kurve kurz ausschlägt.
• Schalte das Zimmerlicht aus und wieder an — Pflanzen registrieren Lichtwechsel.
• Halte deine Hand oder dein Gesicht nah an die Pflanze, ruhig, dann aufgeregt. Verändert sich etwas? (Das ist die grosse offene Frage des Buches.)
• Spiele Musik in der Nähe und suche nach zusammenhängenden Mustern.
• Vergleiche dieselben Versuche an Kalanchoe, Primel und Tradescantia.

Wenn’s klemmt

Zum Nachdenken

Bevor du aus einem Ausschlag „die Pflanze hat mich gespürt“ machst, denk wie eine Forscherin:

• Woher weisst du, dass die Kurve auf die Pflanze reagiert und nicht auf deine Bewegung, deine statische Aufladung oder einen Wackelkontakt? Wie könntest du das ausschliessen?
• Was wäre eine gute Kontrolle? (Tipp: dieselbe Messung an einem abgeschnittenen Blatt oder mit der Elektrode in der Luft.)
• Wenn mehrere Gruppen dasselbe messen — bekommt ihr dasselbe Ergebnis? Erst dann wird aus einem Zufall ein Befund.

Genau dieses Zusammenspiel aus Staunen und Skepsis ist der rote Faden des ganzen Buches. Du hast jetzt das Werkzeug, um selbst zu prüfen.

Anhang: Der Arduino-Sketch

Dieser Code liest den Messwert an GPIO34, zeichnet die Kurve aufs OLED und schickt die Werte an den Seriellen Plotter. Die getestete Fassung liegt auch auf GitHub.

/*
  Pflanzensensor - Verborgene Signale, Aktivitaet 1
  ----------------------------------------------------------------
  Liest das bioelektrische Signal einer lebenden Pflanze ueber das
  AD8232-Modul, zeigt die Kurve live auf dem OLED-Display und sendet
  die Messwerte zusaetzlich an den Seriellen Plotter der Arduino-IDE.

  Board: DOIT ESP32 DEVKIT V1
  Bibliotheken: Adafruit SSD1306 + Adafruit GFX
  Verkabelung: Signal an GPIO34, OLED an SDA=GPIO21 / SCL=GPIO22
*/
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

const int BREITE = 128;         // OLED-Breite in Pixeln
const int HOEHE  = 64;          // OLED-Hoehe in Pixeln
const int OLED_ADRESSE = 0x3C;  // meist 0x3C, selten 0x3D
const int SIGNAL_PIN = 34;      // GPIO34 = Analog-Eingang (ADC)

Adafruit_SSD1306 display(BREITE, HOEHE, &Wire, -1);
int kurve[BREITE];              // Speicher fuer die angezeigte Kurve

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);           // SDA = GPIO21, SCL = GPIO22
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADRESSE)) {
    Serial.println("OLED nicht gefunden - Adresse pruefen (0x3C oder 0x3D)!");
    while (true) { delay(100); }  // hier bleiben, bis das Display laeuft
  }
  analogReadResolution(12);     // Messwerte von 0 bis 4095
  for (int i = 0; i < BREITE; i++) kurve[i] = HOEHE / 2;
  display.clearDisplay();
  display.display();
}

void loop() {
  int wert = analogRead(SIGNAL_PIN);   // 0 .. 4095 einlesen
  Serial.println(wert);                // fuer den Seriellen Plotter

  // Kurve um ein Pixel nach links schieben und neuen Wert anhaengen
  for (int i = 0; i < BREITE - 1; i++) kurve[i] = kurve[i + 1];
  kurve[BREITE - 1] = map(wert, 0, 4095, HOEHE - 1, 0);

  // Display neu zeichnen
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.print("Pflanzensignal");
  for (int i = 0; i < BREITE - 1; i++)
    display.drawLine(i, kurve[i], i + 1, kurve[i + 1], SSD1306_WHITE);
  display.display();
  delay(20);                    // ca. 50 Messungen pro Sekunde
}