• Weiterführende Inhalte

    • Ist der Einstieg geschafft, der Open Roberta Connector und die Arduino IDE installiert, können die 13 Lektionen bearbeitet werden. Wahlweise kann jede Station einmal mit Open Robert und im Anschluss mit der Arduino IDE erarbeitet werden oder alternativ erst alle Stationen mit Open Roberta (2 Stationen können damit nicht bearbeitet werden) und dann alle in der Arduino IDE.

      Die Erarbeitung kann paarweise mit Hilfe des Buches oder mit den Anleitungen auf der Herstellerseite: Die 13 Lektionen sind jeweils für die Programmierung in Open Roberta und Arduino IDE dokumentiert. Weiterhin gibt es Tutorials zu jeder Lektion auf Youtube:

      L01: Leuchtdiode; 

      L02:  Taster;  

      L03:  Bewegungsmelder;  

      L04: Lautsprecher

      L05: Ultraschallsensor

      L06: LED Ring (nur Adruino)

      L07: Servomotor

      L08:Infrarotsensor und Fernbedienung

      L09: Fotowiderstand

      L10: Potentiometer

      L11: OLED

      L12: Gyroskop (MPU6050)

      L13: Temperatur und Luftfeuchtigkeit (DHT11)

    • Externe Anschlüsse

      Folgende externe Anschlüsse stehen zur Verfügung:

      • Extern1:
          • GND
          • 5V
          • SDA (A4)
          • SCL (A5)

      • Extern2:
          • GND
          • 5V
          • RX (D1)
          • TX (D0)

      • Extern3:
          • GND
          • 5V
          • A1
          • A2

    • 🚦Unterrichtsprojekt Ampel:

      KI-generierter Codingvorschlag:

      🔧 Benötigte Materialien:

      • 1x Funduino (kompatibel mit Arduino Uno)

      • 3x LEDs (Rot, Gelb, Grün)

      • 3x passende Vorwiderstände (z. B. 220 Ohm)

      • Jumper-Kabel

      • Breadboard

      • Arduino IDE

      ⚡ Schaltplan (Textbeschreibung):

      • Rote LED: An Pin 8 mit 220 Ohm Widerstand gegen GND

      • Gelbe LED: An Pin 9 mit 220 Ohm Widerstand gegen GND

      • Grüne LED: An Pin 10 mit 220 Ohm Widerstand gegen GND

      💡 Ziel:

      Simuliere eine einfache Verkehrsampel mit folgenden Zuständen:

      1. Rot – 5 Sekunden

      2. Rot-Gelb – 2 Sekunden

      3. Grün – 5 Sekunden

      4. Gelb – 2 Sekunden
        Dann beginnt der Zyklus erneut.

      🧠 Lernziele:

      • Digitalausgänge ansteuern

      • Zeitsteuerung mit delay()

      • Strukturierung von Code (Setup und Loop)

      • Einführung in Ampellogik

      📜 Arduino Code:

      Zunächst werden die Pins für die LEDs deklariert:

      Zunächst werden die Pins für die LEDs deklariert:

      const int rot = 8;
      const int gelb = 9;
      const int gruen = 10;

      Im setup()-Block werden die Pins als Ausgänge definiert:

      void setup() {
        pinMode(rot, OUTPUT);
        pinMode(gelb, OUTPUT);
        pinMode(gruen, OUTPUT);
      }

      Der eigentliche Ampelzyklus läuft im loop()-Block und wiederholt sich ständig. Die Zustände lauten:

      1. Rotphase:

      digitalWrite(rot, HIGH);
      digitalWrite(gelb, LOW);
      digitalWrite(gruen, LOW);
      delay(5000); // 5 Sekunden

      2. Rot-Gelb-Phase:

      digitalWrite(rot, HIGH);
      digitalWrite(gelb, HIGH);
      digitalWrite(gruen, LOW);
      delay(2000); // 2 Sekunden

      3. Grünphase:

      digitalWrite(rot, LOW);
      digitalWrite(gelb, LOW);
      digitalWrite(gruen, HIGH);
      delay(5000); // 5 Sekunden

      4. Gelbphase:

      digitalWrite(rot, LOW);
      digitalWrite(gelb, HIGH);
      digitalWrite(gruen, LOW);
      delay(2000); // 2 Sekunden

      Dieser Ablauf wird durch die loop()-Funktion dauerhaft wiederholt, sodass die Ampel endlos zwischen den vier Zuständen wechselt.

      📘 Erweiterungsideen:

      • Fußgängerampel mit Taster und zweitem Ampelsystem

      • Soundmodul für akustisches Signal (z. B. für Sehbehinderte)

      • Simulation von Ampelstörungen (z. B. nur blinkendes Gelb)

      • Verkehrskreuzung mit zwei synchronisierten Ampeln

    • 🌱 Unterrichtsprojekt: Automatisierte Pflanzenbewässerung mit dem Funduino Cube

      🔧 Benötigte Materialien:

      • 1× Funduino (Arduino Uno-kompatibel)

      • 1× Bodenfeuchtigkeitssensor (z. B. kapazitiver Sensor oder YL-69)

      • 1× Relaismodul oder Transistorschaltung (für Pumpensteuerung)

      • 1× kleine Wasserpumpe (z. B. 5–12 V)

      • Externe Stromquelle für die Pumpe (z. B. 9 V Netzteil oder Akku)

      • Jumper-Kabel, Breadboard

      ⚙️ Schaltplan – Textbeschreibung:

      Sensor:

      • A0 → Signal des Feuchtesensors

      • VCC → 5 V

      • GND → GND

      Relais:

      • IN → Pin D7

      • VCC → 5 V

      • GND → GND

      • Die Pumpe wird über die Schaltseite des Relais verbunden, sodass sie bei HIGH aktiviert wird.

      🎯 Ziel:

      Der Arduino misst regelmäßig die Bodenfeuchtigkeit.
      Ist sie zu niedrig (also der Boden trocken), aktiviert er automatisch die Pumpe für eine kurze Zeit. Danach wartet das System einige Minuten, bevor es erneut misst.

      🧠 Lernziele:

      • Arbeiten mit analogen Sensorwerten (analogRead)

      • Festlegen und Anpassen von Schwellenwerten

      • Steuerung eines Relaismoduls als Aktor

      • Förderung des Umweltbewusstseins durch Technik

      • Einstieg in automatisierte Systeme

      📜 Arduino-Beispielcode:

      // Automatische Pflanzenbewässerung mit Funduino

      const int sensorPin = A0;     // Bodenfeuchtigkeitssensor
      const int relaisPin = 7;      // Steuerung des Relaismoduls
      const int trockenWert = 600;  // Schwellenwert: je höher, desto trockener

      void setup() {
        pinMode(relaisPin, OUTPUT);
        digitalWrite(relaisPin, LOW); // Relais aus
        Serial.begin(9600);
      }

      void loop() {
        int feuchtigkeit = analogRead(sensorPin);
        Serial.print("Feuchtigkeitswert: ");
        Serial.println(feuchtigkeit);

        if (feuchtigkeit > trockenWert) {
          Serial.println("-> Zu trocken! Pumpe wird eingeschaltet.");
          digitalWrite(relaisPin, HIGH);  // Pumpe an
          delay(5000);                     // 5 Sekunden bewässern
          digitalWrite(relaisPin, LOW);   // Pumpe aus
        } else {
          Serial.println("-> Boden ist feucht genug.");
          digitalWrite(relaisPin, LOW);   // Sicherstellen, dass Pumpe aus ist
        }

        delay(60000);  // 1 Minute warten bis zur nächsten Messung
      }

      🧪 Kalibrierungstipp:

      • Lass dir mit analogRead() die Sensorwerte bei trockenem und nassem Boden im seriellen Monitor anzeigen.

      • Passe den Wert trockenWert im Code so an, dass die Pumpe zuverlässig erst bei echter Trockenheit schaltet.

      🛠️ Erweiterungsideen:

      • 🖥️ Anzeige des Feuchtigkeitswerts auf einem OLED-Display

      • 🌍 Integration ins Internet of Things (IoT) via MQTT

      • 🕓 Tageslicht-/Uhrzeitsteuerung, z. B. nur tagsüber bewässern

      • ☀️ Solarpanel für nachhaltige Stromversorgung

    • 🧪 Unterrichtsprojekt: CO₂-Messung mit Funduino Cube

      🎯 Ziel:

      Messung der CO₂-Konzentration in der Luft mit Visualisierung über serielle Schnittstelle und/oder LED-Ampel zur Anzeige der Luftqualität im Raum.

      🔧 Benötigte Materialien:

      Bauteil Menge Beschreibung
      Funduino Cube 1 Arduino Uno kompatibel
      MH-Z19B CO₂-Sensor 1 0–5000 ppm, seriell
      LEDs (Grün, Gelb, Rot) je 1 Ampelanzeige mit 220 Ω Vorwiderstand
      Jumperkabel mehrere Zur Verbindung
      Breadboard 1 Für Aufbau ohne Löten

      ⚙️ Anschlüsse:

      MH-Z19B → Funduino:

      • VCC → 5V

      • GND → GND

      • TX → D8

      • RX → D9

      LED-Ampel:

      • Grün → D2

      • Gelb → D3

      • Rot → D4

      📜 Arduino Code:

      #include <SoftwareSerial.h>

      SoftwareSerial co2Serial(8, 9);  // RX, TX für CO₂-Sensor

      const int gruenLED = 2;
      const int gelbLED = 3;
      const int rotLED = 4;

      byte cmd_getppm[] = {0xFF, 0x01, 0x86, 0, 0, 0, 0, 0, 0x79};
      unsigned long lastRequest = 0;
      int co2ppm = 0;

      void setup() {
        Serial.begin(9600);
        co2Serial.begin(9600);
        Serial.println("Starte CO2-Messung mit MH-Z19B...");

        pinMode(gruenLED, OUTPUT);
        pinMode(gelbLED, OUTPUT);
        pinMode(rotLED, OUTPUT);
      }

      void loop() {
        // Alle 5 Sekunden neue Messung
        if (millis() - lastRequest > 5000) {
          requestCO2();
          lastRequest = millis();
        }
      }

      void requestCO2() {
        co2Serial.write(cmd_getppm, 9);
        delay(10);
        if (co2Serial.available()) {
          byte response[9];
          co2Serial.readBytes(response, 9);

          if (response[0] == 0xFF && response[1] == 0x86) {
            co2ppm = response[2] * 256 + response[3];
            Serial.print("CO2 Konzentration: ");
            Serial.print(co2ppm);
            Serial.println(" ppm");
            updateLEDs(co2ppm);
          } else {
            Serial.println("Ungültige Antwort vom Sensor.");
          }
        }
      }

      void updateLEDs(int ppm) {
        if (ppm < 800) {
          digitalWrite(gruenLED, HIGH);
          digitalWrite(gelbLED, LOW);
          digitalWrite(rotLED, LOW);
        } else if (ppm >= 800 && ppm <= 1200) {
          digitalWrite(gruenLED, LOW);
          digitalWrite(gelbLED, HIGH);
          digitalWrite(rotLED, LOW);
        } else {
          digitalWrite(gruenLED, LOW);
          digitalWrite(gelbLED, LOW);
          digitalWrite(rotLED, HIGH);
        }
      }

      📘 Lernziele:

      • CO₂-Messung mit Sensoren und serieller Kommunikation

      • Umweltbewusstsein durch visuelle Luftqualitätsanzeige

      • Verwendung von SoftwareSerial für parallele Kommunikation

      • Interpretation von Messwerten in ppm (parts per million)

      • Anwendung von Kontrollstrukturen (if-Bedingungen) und millis()

      🛠 Erweiterungsideen:

      • Anzeige der Werte auf einem OLED-Display

      • Alarmfunktion bei >1500 ppm (Buzzer, Notification)

      • Speicherung auf SD-Karte

      • Upload der Werte an eine IoT-Plattform (MQTT)

      • Visualisierung als Zeitdiagramm mit Processing/Python

      🚦 Ampelbewertung:

      • Grün (< 800 ppm): gute Luft

      • Gelb (800–1200 ppm): akzeptabel, lüften empfohlen

      • Rot (> 1200 ppm): schlechte Luft, dringend lüften

    • Weitere Unterrichtsideen:

      1. I²C-CO2-Sensor anschließen (Extern1: SDA/SCL)

      Ziel: CO2 messen und anzeigen
      Anschluss:

      • SDA (A4) und SCL (A5) für I²C-Kommunikation

      • 5V und GND zur Stromversorgung
        Bauteil: z. B. BMP280 oder DS18B20 mit I²C-Modul
        Praxisbezug: Wetterstation, Raumklimakontrolle
        Kompetenz: Schüler*innen verstehen serielle Bus-Kommunikation (I²C) und lernen Sensorintegration.

      2. OLED-Display für Datenanzeige (Extern1: SDA/SCL)

      Ziel: Sensordaten oder Texte auf einem Mini-Bildschirm darstellen
      Anschluss:

      • SDA (A4), SCL (A5), 5V, GND
        Bauteil: OLED-Display (z. B. 0,96" I²C SSD1306)
        Praxisbezug: Ausgabe von Temperatur, Uhrzeit, Messwerten
        Kompetenz: Nutzung von Ausgabemedien zur Visualisierung von Daten

      3. Serielles Bluetooth-Modul (Extern2: RX/TX)

      Ziel: Kommunikation zwischen Funduino Cube und Smartphone oder PC
      Anschluss:

      • RX (D1), TX (D0), 5V, GND
        Bauteil: HC-05 Bluetooth-Modul
        Praxisbezug: Fernsteuerung von Projekten via App oder serieller Monitor
        Kompetenz: Verständnis für serielle Datenübertragung und kabellose Kommunikation

      4. Lichtsensor mit analogem Ausgang (Extern3: A1 oder A2)

      Ziel: Helligkeit messen und nutzen (z. B. zur Lichtsteuerung)
      Anschluss:

      • A1 oder A2, 5V, GND
        Bauteil: LDR mit Spannungsteiler oder fertiger analoger Sensor
        Praxisbezug: Automatische Nachtlichter oder Messungen im Umweltunterricht
        Kompetenz: Nutzung analoger Eingangssignale zur Steuerung

      5. Potentiometer als Eingaberegler (Extern3: A1 oder A2)

      Ziel: Werte manuell regeln (z. B. LED-Helligkeit, Geschwindigkeit eines Motors)
      Anschluss:

      • A1 oder A2, 5V, GND
        Bauteil: Potentiometer
        Praxisbezug: Benutzerinteraktion im System, z. B. Lautstärkeregler oder Dimmer
        Kompetenz: Manuelle Steuerung über analoge Eingabe erfahrbar machen