Ein neues Kapitel für Arduino

Mit der geplanten Übernahme durch Qualcomm (vorbehaltlich behördlicher Genehmigung) beginnt für Arduino ein neues Kapitel.

Das Unternehmen bleibt als eigenständige Tochtergesellschaft erhalten, behält Marke, Mission und den Open-Source-Ansatz bei – bekommt aber Zugang zu Qualcomms KI- und Connectivity-Technologien.

Ziel der Partnerschaft: Die Arduino-Community mit moderner Edge-AI-Leistung, leistungsfähigen SoCs und integrierter Konnektivität ausstatten – ohne den offenen, zugänglichen Charakter der Plattform zu verlieren.

Der neue Arduino UNO Q

Das neue Board erweitert die bekannte UNO-Familie und schlägt eine Brücke zwischen klassischem Mikrocontroller und KI-fähigem Mini-Computer.

Herzstück ist eine Dual-Prozessor-Architektur aus:

• einem Qualcomm Dragonwing QRB2210 (Quad-Core-CPU, Adreno-GPU, AI-Beschleuniger, Linux-fähig)
• und einem STM32U585-Mikrocontroller für Echtzeitaufgaben.

Damit eignet sich der UNO Q für moderne Anwendungen rund um Bildverarbeitung, Audioanalyse und intelligente IoT-Projekte.

Neues App Lab – KI trifft auf Einfachheit

Parallel dazu wurde das neue Arduino App Lab vorgestellt – eine vereinheitlichte Entwicklungsumgebung, in der sich Linux, Python, Echtzeitsteuerung und KI-Modelle gemeinsam nutzen lassen.

So können Maker, Schüler und Entwickler komplexe KI-Projekte umsetzen, ohne sich mit komplizierten Toolchains oder zusätzlicher Hardware beschäftigen zu müssen.

Der UNO Q kann wahlweise per PC programmiert oder im Standalone-Modus als Mini-Computer betrieben werden – inklusive Tastatur, Maus und Monitor über USB-C mit Videoausgabe.

Ausstattung & Varianten

Das Board bietet u. a.:

• WLAN 5, Bluetooth 5.1
• Qwiic-Anschluss für I²C-Module
• blaue LED-Matrix
• UNO-Shield-Kompatibilität
• 2 GB RAM / 16 GB eMMC (39 €) oder 4 GB / 32 GB (53 €)

Die kleinere Version ist ab sofort bestellbar und wird ab 25. Oktober ausgeliefert, die größere folgt im November.

Alle Designs, Beispiele und Tools bleiben Open Source.

Fazit

Mit dem UNO Q wagt Arduino den vielleicht größten Schritt seit dem Original UNO: Ein Board, das Künstliche Intelligenz, Echtzeitsteuerung und Linux vereint – zugänglich, offen und im vertrauten Formfaktor.

Die Partnerschaft mit Qualcomm öffnet dafür die technischen Türen. Bleibt zu hoffen, dass die Marke Arduino ihrem Credo treu bleibt: Technologie für alle zugänglich zu machen.

Sobald das Board verfügbar ist, werde ich es hier auf makerblog.at im Detail vorstellen – inklusive Praxistest und ersten Projekten.

Flappy Bird ist dabei ein sehr simples Spiel. Gesteuert wird die Spielfigur am Smartphone durch Tippen auf eine beliebige Stelle des Touchscreens. Das eignet sich ideal zur Umsetzung am Arduino, da neben dem Display nur ein Pushbutton benötigt wird.

Meine einfache Implementierung entspricht vom Verhalten her sicher nicht 1:1 dem Original, aber der Programmcode ist einfach zu verstehen und kann leicht an eigene Bedürfnisse (Schwierigkeitsgrad, Erweiterung um Buzzer für Soundeffekte) angepasst werden.

Hardware-Anforderungen

Das Das Projekt stellt minimale Anforderungen an die Hardware, mit einem Arduino Uno R3 (oder kompatiblem Klon), einem kleinen OLED Display mit SSD1306-Controller und einem Pushbutton ist man schon dabei.

Für den Nachbau werden folgende Komponenten benötigt:

• OLED I2C Display 128×64 mit SSD1306 (separat erhältlich, z.B. hier im 3er Pack bei Amazon)

und die folgende Teile, die in jedem Arduino Starter Kit enthalten sind:

• Arduino UNO R3 (oder kompatibel) mit Breadboard
• Push-Buttonsfür die Steuerung
• Ein paar Kabel zur Verbindung der Komponenten

Verkabelung am Breadboard

Der Arduino Sketch und ein paar Anmerkungen

Den kompletten Quellcode findest du gut dokumentiert hier auf Github https://github.com/adidax/oled-flappy-bird-arduino/tree/main

Mit einem Arduino Uno R3 (oder kompatibel) und bei korrektem Aufbau der Schaltung am Breadboard sollte der Sketch ohne Änderungen funktionieren. Solltest du ein anderes Arduino Modell oder eine andere Belegung der Pins verwenden, dann sind eventuell kleine Anpassungen notwendig.

Der Sketch ist zwar gut dokumentiert, hier aber trotzdem ein paar kurze Anmerkungen zur Struktur.

Gleitkommafrei durch Skalierung

Wie schon beim ähnlichen Projekt Retro Racer werden auch hier alle Koordinaten am Spielfeld um den Faktor 10 hochskaliert und mit dem Datentyp int gespeichert. Damit können aufwändige Gleitkomma-Berechnungen vermieden werden, aber Spielmechaniken wie eine Änderung der Spielposition um 0,5 Pixel pro Frame sind trotzdem möglich. Das Display hat im Programmcode also nicht 128×64, sondern 1280×640 Pixel. Vor der Darstellung auf dem Display werden die Werte dann durch 10 geteilt, um diese auf die Koordinaten des OLED umzurechnen.

Fixe Framerate für gleichmäßigen Spielablauf

Damit das Spiel auf dem Arduino gleichmäßig läuft, wird versucht mit einer festen Bildwiederholrate von 25 FPS zu arbeiten. Das heißt: Die loop()-Funktion berechnet und zeichnet nur dann ein neues Frame, wenn mindestens 40 Millisekunden seit dem letzten vergangen sind:

const int FRAME_TIME = 40; // 40 ms per frame = 25 FPS
if (millis() - lastFrameTime < FRAME_TIME) return;
lastFrameTime = millis();

Das verhindert Timing-Probleme und sorgt dafür, dass Bewegung und Spielgeschwindigkeit stets konstant bleiben, unabhängig davon, wie schnell der Mikrocontroller gerade rechnet. Sollte die Berechnung und Ausgabe eines Frames länger als 40ms dauern, dann kommt es aber natürlich trotzdem zu Unregelmäßigkeiten im Ablauf. Das dürfte hier aber nicht der Fall sein.

Spielfigur fliegt bei Knopfdruck

Die Steuerung ist einfach. Pro Frame erhöht sich die Sinkgeschwindigkeit der Spielfigur um den Wert von GRAVITY und der Vogel bewegt sich nach unten. Wird der Pushbutton gedrückt, dann steigt der Vogel um den Wert von JUMP_STRENGTH und bewegt sich nach oben.

        // Wenn Button gedrückt, negative Beschleunigung (nach oben) addieren
        if (digitalRead(BUTTON_PIN) == LOW) {
            velocity = JUMP_STRENGTH;
        }
        velocity += GRAVITY; // Schwerkraft anwenden (positiver Wert = nach unten)
        velocity = constrain(velocity, -50, 50); // Begrenzung, damit Spielfigur nicht zu schnell fällt oder steigt

        // Position des Spielers berechnen
        birdY += velocity;

So entsteht das typische “Flap”-Gefühl mit steigender und fallender Bewegung.

Gnädige Kollisionsabfrage: 

Die Spielfigur ist rund, die Hitbox zur Kollisionsabfrage aber rechteckig. Daher habe ich bei der Berechnung der möglichen Kollision einen kleinen Spielraum von 2px berücksichtig.

if ((birdY - 2 * SCALE_FACTOR) < pipes[i].height || 
    (birdY + 2 * SCALE_FACTOR) > pipes[i].height + PIPE_GAP)

Damit fühlt sich das Spiel deutlich fairer an, die Spielfigur kann auch an einem Rohr „anstreifen“, ohne sofort eine Kollision zu melden.

Vorbereitung der Spielgrafik

Da das OLED-Display nur Schwarz-Weiß-Grafiken unterstützt, müssen Bilder in ein passendes Bitmap-Format umgewandelt und im Programmcode eingebunden werden. Dafür habe ich das kostenlose Online-Tool Image2CPP verwendet.

Schritt-für-Schritt-Anleitung für eigene Grafiken:

1. Lade das gewünschte PNG-Bild hoch.
2. Stelle die Bildgröße passend zur benötigten Pixelgröße ein (z. B. 10×8 Pixel für ein Auto).
3. Wähle als Ausgabeformat → Arduino Code.
4. Kopiere den generierten PROGMEM-Code in das Arduino-Projekt.
5. Nutze display.drawBitmap(x, y, bitmap, width, height, SSD1306_WHITE); zur Anzeige des Bildes.

Diese Methode ermöglicht es, eigene Icons oder Sprites für das Spiel zu erstellen und ins Flash-Speicher (PROGMEM) des Arduino zu laden. Dabei muss man aber immer beachten, dass der Speicherplatz des Arduino sehr begrenzt ist :)

Spielprinzip und Steuerung

• Die Spielfigur (ein Vogel) fliegt von links nach rechts durch das Bild. Die Flughöhe des Vogels verringert sich laufend durch die Schwerkraft, der Spieler kann über den Drucktaster einen Flügelschlag auslösen, welcher die Flughöhe wieder erhöht.
• Gleichzeitig bewegen sich die Rohre als Hindernisse auf den Vogel zu. Die Spielfigur muss durch die Lücken in den Rohren gesteuert werden.
• Kollidiert der Spieler mit einem Hindernis, ist das Spiel vorbei.
• 3 Sekunden nach Game over wird die Highscore-Liste angezeigt.
• Ein Druck auf eine beliebige Taste startet das Spiel neu.

Was mir am Projekt gefällt

Wie schon beim Retro Racer sieht man auch bei dieser Flappy Bird Variante, wie man klassische Spielideen mit einfachster Hardware und etwas Programmcode nachbauen kann und damit ein vollständiges, unterhaltsames Spiel entsteht. Die Kombination aus Spielphysik, Animation und einfachster Steuerung macht Flappy Bird zum perfekten Arduino-Projekt, egal ob zum Lernen, Lehren oder einfach zum Spaß.

Den kompletten Quellcode findest du gut dokumentiert hier auf Github https://github.com/adidax/oled-flappy-bird-arduino/tree/main

Trotz des einfachen Aufbaus des Projekts zu geringen Kosten ist das Ergebnis recht spannend und eignet sich auch gut für Gruppenprojekte, z.B. in der Schule.

Hardware-Anforderungen

Neben dem Arduino samt Breadboard, das in vielen Starter Kits enthalten ist, benötigt man lediglich ein zusätzliches OLED-Display mit SSD1306-Controller sowie zwei Push-Buttons für die Steuerung. Ein optionaler Buzzer sorgt für Soundeffekte.

Für den Nachbau werden folgende Komponenten benötigt:

• OLED I2C Display 128×64 mit SSD1306 (separat erhältlich, z.B. hier im 3er Pack bei Amazon)

und die folgende Teile, die in jedem Arduino Starter Kit enthalten sind:

• Arduino UNO R3 (oder kompatibel) mit Breadboard
• Zwei Push-Buttons für die Steuerung (links/rechts)
• Optionaler Buzzer für Soundeffekte
• Ein paar Kabel zur Verbindung der Komponenten

Verkabelung:

Der Buzzer an D6 kann auch einfach weggelassen werden, im Programmcode sind dazu keine Änderungen notwendig.

Arduino Programmcode und technische Besonderheiten

Der komplette Quellcode ist gut dokumentiert auf GitHub (oled_racer_de.ino) verfügbar. Am einfachsten beim grünen Button rechts oben „Download ZIP“ wählen und entpacken – oder den Sketch einfach über die Zwischenablage in ein neues Arduino Programmfenster kopieren.

Einige wichtige Aspekte zum Verständnis des Codes:

Optimierung durch Integer-Skalierung: 

Rechenoperationen mit Gleitkommazahlen sind aufwändig und das wollte ich vermeiden. An manchen Stellen, zum Beispiel bei der Geschwindigkeit des Spielerautos, braucht man aber die Möglichkeit, diese in feineren Schritten zu erhöhen. Deswegen habe ich Koordinaten von Objekten am Display und Geschwindigkeiten um den Faktor 10 hochskaliert und als int gespeichert. Das Display hat also im Programmcode nicht 128×64, sondern 1280×640 Pixel. So sind präzisere Berechnungen ohne Performance-Einbußen durch Float-Operationen möglich. Vor der Darstellung auf dem Display werden die Werte dann durch 10 geteilt.
Beispiel:
playerSpeed = 25 bedeutet eine Bewegung von 2.5 Pixeln pro Frame.
Ein Hindernis mit x = 150 befindet sich an Position x = 15.0 auf dem Display.

Spielzustände verwalten: 

Der Code nutzt eine enum GameState, um zwischen den verschiedenen Zuständen zu wechseln:
STARTSCREEN: Intro-Animation mit Titel.
PLAYING: Das eigentliche Spiel läuft (oder zeigt „Game over an“)
HIGHSCORE: Nach Game Over wird eine Highscore-Liste angezeigt.
Dadurch bleibt der Code sauber strukturiert und einfach erweiterbar.

Flüssige Animationen mit Timer-Steuerung: 

Das Spiel nutzt millis(), um eine konstante Framerate von 25 FPS zu halten. Statt delay() wird der Zeitunterschied zum letzten Frame berechnet, sodass die Spiellogik immer genau zur richtigen Zeit aktualisiert wird.

Adaptive Gegner-Spawns: 

Die Gegner (Hindernisse) erscheinen mit steigender Spielzeit immer häufiger. Zu Beginn gibt es nur einen Gegner gleichzeitig, später bis zu zehn, je nach zurückgelegter Distanz.

Blinkende Highscore-Anzeige: 

Falls der aktuelle Score in die Top-10 kommt, wird dieser blinkend hervorgehoben.

Vorbereitung der Spielgrafik

Da das OLED-Display nur Schwarz-Weiß-Grafiken unterstützt, müssen Bilder in ein passendes Bitmap-Format umgewandelt und im Programmcode eingebunden werden. Dafür habe ich das kostenlose Online-Tool Image2CPP verwendet.

Schritt-für-Schritt-Anleitung für eigene Grafiken:

1. Lade das gewünschte PNG-Bild hoch.
2. Stelle die Bildgröße passend zur benötigten Pixelgröße ein (z. B. 10×8 Pixel für ein Auto).
3. Wähle als Ausgabeformat → Arduino Code.
4. Kopiere den generierten PROGMEM-Code in das Arduino-Projekt.
5. Nutze display.drawBitmap(x, y, bitmap, width, height, SSD1306_WHITE); zur Anzeige des Bildes.

Diese Methode ermöglicht es, eigene Icons oder Sprites für das Spiel zu erstellen und ins Flash-Speicher (PROGMEM) des Arduino zu laden. Dabei muss man aber immer beachten, dass der Speicherplatz des Arduino sehr begrenzt ist :)

Spielprinzip und Steuerung

• Der Spieler kann sich mit den beiden Buttons nach links und rechts bewegen.
• Gegner erscheinen zufällig auf den Spuren und bewegen sich auf den Spieler zu.
• Kollidiert der Spieler mit einem Hindernis, ist das Spiel vorbei.
• 3 Sekunden nach Game over wird die Highscore-Liste angezeigt.
• Ein Druck auf eine beliebige Taste startet das Spiel neu.

Was mir am Projekt gefällt

Dieses kleine Projekt zeigt, dass auch mit begrenzten Ressourcen spannende Retro-Spiele auf dem Arduino möglich sind. Der Code ist modular und halbwegs verständlich – auf Objektklassen oder komplexere Konstrukte habe ich bewusst verzichtet – und kann leicht verändert oder erweitert werden – beispielsweise mit mehr Soundeffekten oder zusätzlichen Hindernissen.

Der komplette Quellcode ist auf GitHub verfügbar. Viel Spaß beim Nachbauen!

Benötigte Bauteile

• Arduino Uno oder vergleichbares Modell
• BME280 Sensor
• OLED-Display (128×32 oder 128×64, SSD1306-Treiber)
• Jumper-Kabel
• Breadboard oder kleines Starter Kit (optional, aber hilfreich)

Vorschau	Produkt	Bewertung	Preis
	ELEGOO UNO R3 Mikrocontroller Board Hauptplatine mit USB-Kabel Kompatibel mit Arduino…	Aktuell keine Bewertungen		Bei Amazon kaufen
	APKLVSR 3PCS 0.91″ I2C Display Modul,IIC I2C Display OLED Anzeigemodul 128×32 3.3V/5V für Arduino…	Aktuell keine Bewertungen		Bei Amazon kaufen
	AZDelivery GY-BME280 Barometrischer Sensor für Temperatur, Luftfeuchtigkeit und Luftdruck…	Aktuell keine Bewertungen		Bei Amazon kaufen

OLED-Displays und ihre Eigenschaften

OLED-Displays (Organic Light Emitting Diode) benötigen keine Hintergrundbeleuchtung, da jedes Pixel selbst leuchtet. Sie bieten hohe Kontraste und sind energieeffizient. Das von mir verwendete 0,91-Zoll-Display hat 128×32 Pixel und nutzt den SSD1306-Treiber. Die Header-Pins müssen oft selbst angelötet werden.

I2C-Schnittstelle

I2C ist eine serielle Schnittstelle, die mit nur zwei Leitungen auskommt, SDA (Serial Data) für die Datenübertragung und SCL (Serial Clock) für das Taktsignal. Am Arduino UNO R3 sind die Pins A4 und A5 für diese Schnittstelle zuständig. Mehrere Geräte können an denselben Bus angeschlossen werden, da jedes eine eindeutige Adresse besitzt.

Schaltplan und Verkabelung

Vom OLED-Display zum Arduino:

• GND → GND
• VCC → 5V (oder 3,3V, falls das Modul keine 5V kann)
• SDA → A4
• SCL → A5

Vom BME280 Sensor zum Arduino:

• GND → GND
• VCC → 5V
• SDA → A4
• SCL → A5

Am einfachsten ist die Verkabelung, wenn man A4 und A5 vom Arduino zuerst aufs Breadboard zu den Pins des Displays und von dort weiter zum Sensor führt.

I2C-Adresse der Module ermitteln

Zum Test des Aufbaus kann der I2CScanner Sketch verwendet werden. Der überprüft an allen möglichen Adressen, ob sich ein I2C Gerät zurückmeldet. Der Sketch findet sich in der Arduino IDE unter

• Arduino IDE → Beispiele → Wire → i2cscanner

Typische Adressen für OLED Display sind 0x3C oder 0x3D, für den BME280 Sensor 0x76 oder 0x77. Falls ein Modul nicht angezeigt wird, sollte die Verkabelung überprüft werden.

Bibliotheken installieren

Damit mit der nachfolgende Sketch funktioniert, müssen folgenden Bibliotheken in der Arduino IDE installiert werden:

• Adafruit SSD1306
• Adafruit BME280

Arduino-Code zur Anzeige der Messwerte

/***************************************************************************
 BMP280 und OLED Display 128x32
 https://www.makerblog.at

 - Arduino UNO R3 (oder vergleichbar)
 - BMP280 Klimasensor für Temperatur und Luftfeuchtigkeit
 - OLED I2C Display 128x32 (oder größer)

 Verkabelung:

 BME280 -> Arduino UNO R3
 SDA -> A4
 SVL -> A5
 GND -> GND
 VIN -> 5V

 OLED -> Arduino UNO R3
 SDA -> A4
 SVL -> A5
 GND -> GND
 VIN -> 5V

 Folgende Libraries müssen installiert sein, bei Fehlermeldung bitte mit dem Library Manager 
 kontrollieren

 - Adafruit SSD1306
 - Adafruit BME280
 ***************************************************************************/

#include <Adafruit_BME280.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128  // Horizontale Auflösung des Displays in Pixel
#define SCREEN_HEIGHT 32  // Vertikale Auflösung des Displays in Pixel
#define OLED_RESET -1     // Reset pin # (oder -1 wenn kein Reset Pin am Display)

#define SCREEN_ADDRESS 0x3C  // I2C Adresse des Displays, siehe Datenblatt, meist 0x3D für 128x64, 0x3C für 128x32
#define BME_ADDRESS 0x76     // I2C Adresse des Sensors

#define DELAY_TIME 500  // Wartezeit zwischen Messungen

// display Objekt mit Parametern erstellen
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

Adafruit_BME280 bme;  // bme Objekt für den Temperatursensor

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

  while (!Serial)
    ;  // Warten bis serielle Kommunikation funktioniert
  Serial.println(F("OLED mit BME280 Projekt"));

  if (!bme.begin(BME_ADDRESS)) {
    Serial.println("Kein BME280 Sensor an der Adresse gefunden.");
    while (1) {
      delay(100);
    }
  }

  // SSD1306_SWITCHCAPVCC = 3.3V Spannung wird intern erzeugt
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("Keinen SSD1306 Verbindung gefunden"));
    while (1) {
      delay(100);
    }
  }

  display.clearDisplay(); // Displayinhalt leeren
  display.setTextSize(1); // Schriftgrösse 1
  display.setTextColor(SSD1306_WHITE); // Pixel leuchtet
  display.cp437(true); // Use full 256 char 'Code Page 437' font
  display.display(); // Displayinhalt anzeigen

  Serial.println("Setup finished");
}


void loop() {

  display.clearDisplay(); // Display leeren
  display.drawRect(0, 0, 128, 32, SSD1306_WHITE); // Rahmen zeichnen

  display.setCursor(2, 2); //Cursorposition x, y
  display.print("Temp: ");
  display.setCursor(50, 2);
  display.print(bme.readTemperature());
  display.print(" ");
  display.write(248); // Hochgestellter Kreis für °C
  display.println("C");

  display.setCursor(2, 12);
  display.print("Luftf: ");
  display.setCursor(50, 12);
  display.print(bme.readHumidity());
  display.println(" %");

  display.setCursor(2, 22);
  display.print("LDruck: ");
  display.setCursor(50, 22);
  display.print(bme.readPressure() / 100.0F);
  display.println(" hPa");  

  display.display();
  delay(DELAY_TIME);
}

Fazit und Erweiterungsmöglichkeiten

Geschafft. Das OLED-Display zeigt die Messwerte des BME280-Sensors an. Mögliche Erweiterungen sind:

• Anzeige von Symbolen oder größeren Schriftarten
• Einbau in ein Gehäuse
• Übertragung der Werte per Bluetooth oder WLAN an eine IoT-Plattform mit einem geeigneten Arduino, z.B. dem neuen Arduino UNO R4

Besonders das 1602 Display mit 2 Zeilen à 16 Zeichen ist in fast jedem Arduino Starter Kit zu finden. Diese Displays sind praktisch und kostengünstig, haben jedoch einen Nachteil: Sie werden standardmäßig parallel angesteuert und benötigen dadurch mindestens 6 Digitalpins am Arduino und eventuell auch noch eine Potentiometer am Breadboard.

Das kann problematisch werden, wenn weitere Sensoren oder Module angeschlossen werden sollen. Hinzu kommt der Kabelsalat auf dem Breadboard, der bei komplexeren Projekten schnell unübersichtlich wird.

Die Lösung: Die I²C-Schnittstelle für LCD Displays

Die I²C-Schnittstelle (Inter Integrated Circuit) bietet eine einfache Lösung für dieses Problem. I²C ist ein Protokoll zur seriellen Kommunikation zwischen elektronischen Bauteilen. Es benötigt nur zwei Leitungen und damit nur 2 Digitalpins am Arduino:

• SDA (Serial Data Line) für die Datenübertragung
• SCL (Serial Clock Line) für den Takt

Jedes I²C-Gerät hat eine eindeutige Adresse. Dadurch können über dieselben zwei Pins mehrere Module wie Sensoren oder Displays angesprochen werden.

Für Standard-LCDs gibt es kleine I²C-Adapterplatinen, die einfach an die 16 Anschlusspins des Displays gelötet werden. Diese verwenden meist den PCF8574, einen I/O Expander, der serielle Daten in parallele Signale für das LCD umwandelt. Diese Adapter stellen dann die 4 I²C-Anschlüsse (VCC, GND, SDA, SCL) zur Verfügung. Ein Potentiometer zur Helligkeitssteuerung der Anzeige ist oft noch zusätzlich auf der Platine integriert.

Diese Erweiterungen sind praktisch, machen das Modul jedoch etwas unhandlicher. Aus diesem Grund gibt es inzwischen auch LCD Displays mit integrierter I²C-Schnittstelle, die direkt auf dem Modul verbaut ist und so den gewohnten Formfaktor beibehält.

Bestseller Nr. 1

FREENOVE I2C IIC LCD 1602 Module (2 Pack), New...

Bei Amazon kaufen

Bestseller Nr. 2

ARCELI 20x4 2004 LCD Display Modul, DC 5V...

Bei Amazon kaufen

Bestseller Nr. 3

FREENOVE I2C IIC LCD 2004 Module, TWI Serial 20x...

Bei Amazon kaufen

Anschluss eines I²C-LCD Displays an den Arduino

Der Anschluss eines I²C-LCD Displays an den Arduino UNO ist denkbar einfach:

1. VCC an 5V
2. GND an GND
3. SDA an A4 (Arduino UNO)
4. SCL an A5 (Arduino UNO)

Hinweis: Bei anderen Mikrocontrollern können die I²C-Pins variieren.

• Arduino UNO/Nano: SDA an A4, SCL an A5.
• Arduino Micro: SDA an D2, SCL an D3.
• Arduino Mega 2560: SDA an D20, SCL an D21.
• ESP8266 (NodeMCU): SDA an GPIO4 (D2), SCL an GPIO5 (D1).
• ESP32: SDA an GPIO21, SCL an GPIO22.
• Raspberry Pi (Model 3 & 4): SDA an GPIO2 (Pin 3), SCL an GPIO3 (Pin 5).
• STM32 (Blue Pill): SDA an PB7, SCL an PB6.
• Teensy 4.x: SDA an Pin 18, SCL an Pin 19.

LCD Display, Zeichensatz und Sonderzeichen

LCD-Displays wie das 1602 oder 2004 verwenden oft einen HD44780-kompatiblen Controller, der einen festgelegten Zeichensatz (Character Generator ROM, CGROM) integriert hat. Dieser Zeichensatz basiert auf dem erweiterten ASCII-Code und enthält neben den englischen Buchstaben, Zahlen und Symbolen auch einige Sonderzeichen wie Pfeile oder mathematische Symbole. Allerdings fehlen häufig länderspezifische Sonderzeichen, etwa deutsche Umlaute (ä, ö, ü) oder das „ß“.

Für individuelle Anpassungen bietet der Controller einen benutzerdefinierten Zeichensatz (CGRAM), in dem bis zu acht eigene Zeichen definiert werden können. Diese Zeichen werden als 8×5-Pixel-Matrix erstellt und können zur Darstellung von Sonderzeichen oder Symbolen genutzt werden. Wenn jedoch mehr als acht Sonderzeichen benötigt werden, müssen diese dynamisch neu definiert werden, was bei häufiger Nutzung den Code komplexer macht.

Eine sehr gute Library zur Anzeige deutscher Umlaute samt umfangreicher Erklärung:
https://werner.rothschopf.net/202003_arduino_liquid_crystal_umlaute.htm

Einfacher Sekundenzähler auf einem LCD Display

#include <LCDI2C_Multilingual_MCD.h>

LCDI2C_Latin lcd(0x27, 16, 2); // I2C Adresse: 0x27; Display: 16x2

void setup() {
  lcd.init(); // Display initialisieren
  lcd.backlight(); // Hintergrundbeleuchtung einschalten
  lcd.setCursor(0, 0); // Cursor auf erstes Zeichen in erster Zeile
  lcd.print("Sekunden:"); // Text in erster Zeile ausgeben
}

void loop() {
    unsigned long seconds = millis() / 1000;
 
    lcd.setCursor(0, 1); // Cursor auf erstes Zeichen in zweiter Zeile
    lcd.print(seconds); // Zeit seit Start in Sekunden ausgeben
    lcd.print("s   "); // s für Sekunden und ein paar Leerzeichen zum Überschreiben alter Werte
    delay(500); // Leichte Verzögerung, damit nicht dauernd geschrieben wird
}

I²C-Adressen verstehen und ändern

Da alle über I²C angesteuerten Geräte über einen gemeinsamen Datenbus angesprochen werden, benötigt jedes Gerät eine eindeutige Adresse. Die Standardadresse für viele LCD-I²C-Module ist 0x27 (hexadezimal).

Wenn mehrere Displays verwendet werden sollen oder es einen Adresskonflikt mit anderen Geräten gibt, dann müssen unterschiedliche Adressen vergeben werden. Auf der Rückseite des I²C-Moduls befinden sich dazu drei Pins: A0, A1 und A2. Diese Pins steuern die letzten 3 Bits der I²C-Adresse.

• Offen (HIGH): Das Bit ist auf 1 gesetzt.
• Kurzgeschlossen (LOW): Das Bit wird auf 0 gesetzt.

Beispiel (I²C Adressen in 7 Bit)

• A0 geschlossen: Ändert die Adresse von 0x27 (0b0100111) auf 0x26 (0b0100110).
• A1 geschlossen: Ändert die Adresse von 0x27 (0b0100111) auf 0x25 (0b0100101).
• Alle geschlossen: Adresse ändert sich von 0x27 (0b0100111) auf 0x20 (0b0100000).

So lassen sich mehrere Displays mit unterschiedlichen Adressen am selben I²C-Bus betreiben.

Drei Displays gleichzeitig ansteuern

In diesem Beispiel werden drei Displays über den I²C-Bus gleichzeitig angesteuert. Die Displays zeigen unterschiedliche Informationen an.

#include <LCDI2C_Multilingual_MCD.h>

LCDI2C_Latin lcd1(0x25, 16, 2); // I2C Adresse: 0x25; Display: 16x2
LCDI2C_Latin lcd2(0x26, 16, 2); // I2C Adresse: 0x26; Display: 16x2
LCDI2C_Latin lcd3(0x27, 20, 4); // I2C Adresse: 0x27; Display: 20x4

unsigned long lastSecond = 0; // Zwischenspeicher für Fortschrittsbalken
int progressBar = 0; // Aktuelle Länge des Fortschrittbalkens

void setup() {
  lcd1.init(); // Display1 initialisieren
  lcd1.backlight(); // Hintergrundbeleuchtung einschalten
  lcd1.setCursor(0, 0); // Cursor auf erstes Zeichen in erster Zeile
  lcd1.print("Sekunden:"); // Text in erster Zeile ausgeben

  lcd2.init(); // Display 2 initialisieren
  lcd2.backlight(); 
  lcd2.setCursor(0, 0); 
  lcd2.print("Millisekunden:"); 

  lcd3.init(); // Display 3 initialisieren
  lcd3.backlight(); 
  lcd3.setCursor(0, 0); 
  lcd3.print("Fortschrittsbalken:"); 
}

void loop() {

    unsigned long currentMillis = millis();
    unsigned long currentSeconds = currentMillis / 1000;

    // Display 1 - aktuelle Zeit in Sekunden
    lcd1.setCursor(0, 1); // Cursor auf erstes Zeichen in zweiter Zeile
    lcd1.print(currentSeconds); // Zeit seit Start in Sekunden ausgeben
    lcd1.print("s"); // sec für Sekunden

    // Display 2 - Zeit in Millisekunden
    lcd2.setCursor(0, 1);
    lcd2.print(currentMillis); // Zeit seit Start in Millisekunden ausgeben
    lcd2.print("ms");


    // Display 3: Fortschrittsbalken aktualisieren (60 Zeichen pro Minute)
    if (lastSecond != currentSeconds) { // Nur aktualisieren, wenn sich der Inhalt geändert hat
        progressBar = currentSeconds % 60; // Fortschritt von 0 bis 59
        lastSecond = currentSeconds;
        
        // Fortschrittsbalken leeren bei Neuanfang
        if (progressBar == 0) {
          for (int row = 1; row <= 3; row++) {
            lcd3.setCursor(0, row);
            lcd3.print("                    ");
          }
        }

        // Fortschrittsbalken zeichnen
        int row = 1;
        int col = 0;
        for (int i = 0; i < progressBar; i++) {
            lcd3.setCursor(col, row);
            lcd3.print("#");
            col++;
            if (col >= 20) { // Nächste Zeile nach 20 Zeichen
                col = 0;
                row++;
            }
        }
    }

}

Mit einer I²C-Schnittstelle kann man LCD Displays einfach ansteuern und in jedes Projekt integrieren. Anstatt für jedes Display mehrere Pins zu belegen, genügen zwei Pins (SDA und SCL), um mehrere Displays oder Sensoren zu betreiben. Das ermöglicht komplexe Projekte, ohne sich Gedanken über fehlende GPIO-Pins machen zu müssen.

Dank der verfügbaren Libraries und einfacher Adressänderungen ist die Einrichtung von I²C-LCDs schnell erledigt. Ob ein einzelnes Display oder mehrere Module gleichzeitig – mit I²C sind die Möglichkeiten nahezu unbegrenzt.

Bestseller Nr. 1

ELEGOO UNO R3 Ultimate Starter Kit, Kompatibel mit Arduino IDE Vollständigster Elektronik Projekt Baukasten mit deutschem Tutorial, UNO R3 Mikrocontroller Board und Zubehör (mehr als 200 Teile)

Achtung: Das ist die aktualisierte Version des alten Blogbeitrags zum DHT11 vom August 2014(!). Mittlerweile gibt es bessere Libraries, als dies im alten Beitrag der Fall ist und eine davon wird hier benutzt.

Der DHT11-Sensor ist eine einfache und kostengünstige Möglichkeit, um Temperatur und Luftfeuchtigkeit zu messen. Er eignet sich hervorragend für Einsteigerprojekte, da er leicht zu verwenden ist und keine komplizierte Einrichtung benötigt.

AZDelivery 3 x KY-015 DHT 11 Temperatursensor...

Bei Amazon kaufen

AZDelivery DHT22 AM2302 Temperatursensor und...

9,49 EUR

Bei Amazon kaufen

ELEGOO UNO R3 Ultimate Starter Kit, Kompatibel mit...

Bei Amazon kaufen

In diesem Beitrag zeige ich, wie der Sensor funktioniert, wie man ihn an einen Arduino anschließt und wie die gemessenen Werte ausgelesen werden. In der zweiten Hälfte des Videos erweitern wir den Aufbau um einen einfache Ampel aus 2 LEDs, die abhängig von der Temperatur geschaltet werde.

DHT11 und DHT22 Sensor im Vergleich

Der DHT11 ist ein günstiger Sensor mit eher bescheidener Genauigkeit. Er misst Temperaturen im Bereich von 0 bis 50 °C laut Datzenblatt mit einer Genauigkeit von ±2 °C, die Luftfeuchtigkeit im Bereich von 20 bis 80 mit einer Genauigkeit von ±5 %. Das ist ausreichend für viele einfache Projekte und meiner Erfahrung nach ist er im oft benötigten Bereich rund um die Zimmertemperatur ziemlich genau.

Für Anwendungen, bei denen größere Messbereiche oder eine höhere Präzision benötigt werden, ist der DHT22 die bessere Wahl. Dieser Sensor kann Temperaturen von -40 bis +80 °C mit einer Genauigkeit von ±0,5 °C und Luftfeuchtigkeiten von 0 bis 100 % messen. Dadurch eignet er sich für anspruchsvollere Projekte, ist jedoch etwas teurer. Der Programmcode zur Ansteuerung ist fast identisch.

Aufbau und Funktion des DHT11

Im Inneren des DHT11 befinden sich ein Thermistor, also ein temperaturempfindlicher Widerstand, und ein feuchtigkeitsempfindlicher Kondensator. Diese beiden Komponenten messen die Umgebungstemperatur und die Luftfeuchtigkeit. Allerdings liefern sie zunächst nur analoge Spannungswerte. Damit der Sensor direkt mit einem Mikrocontroller wie dem Arduino kommunizieren und digitale Werte liefern kann, ist im DHT11 ein Mikrocontroller integriert. Dieser wandelt die analogen Spannungswerte in digitale Daten um und stellt sie über ein einzelnes Datenpin bereit. Die einfache Datenübertragung macht den DHT11 besonders für Einsteigerprojekte geeignet.

Die Pinbelegung des DHT11

Das Gehäuse des DHT11 hat vier Pins, aber nur drei davon werden verwendet: Pin 1 ganz links ist VCC, Pin 4 ganz rechts GND und Pin 2 ist das DATA-Pin. VCC ist der Pluspol für die Versorgungsspannung und nimmt Spannungen von 3 bis 5 V auf. GND ist der Masseanschluss. Pin 3 wird nicht verwendet. Falls du eine Version des Sensors auf einem Breakout-Modul verwendest, kann die Pin-Belegung anders sein. Bitte da auf die Beschriftung oder das Datenblatt achten!

Anschluss des DHT11 an den Arduino

Für den Anschluss benötigst du ein Arduino-Board (z. B. den UNO R3), den DHT11-Sensor und, falls du den nackten Sensor ohne Breakout-Board verwendest, einen Widerstand im Bereich von 5-10kΩ. Dieser Widerstand wird als Pull-up-Widerstand zwischen dem Datenpin und VCC geschaltet, um den Datenpin im Ruhezustand auf einen definierten Pegel (HIGH) zu setzen.

Der Anschluss ist einfach: Pin 1 (VCC) wird mit dem 5V-Pin des Arduino verbunden, Pin 4 (GND) mit GND und Pin 2 (DATA) mit einem digitalen Pin des Arduino, zum Beispiel Digitalpin 2. Das reicht bereits, um die Daten des Sensors auslesen zu können.

Messung und Ausgabe der Werte

Der DHT11 kommuniziert über ein einfaches serielles Protokoll. Dabei werden die Daten über eine Abfolge von HIGH- und LOW-Signalen (5 V bzw. 0 V) übertragen. Für den Datenaustausch mit dem DHT11 (oder DHZ22) gibt es die sehr gute Bibliothek namens „DHT sensor library“ von Adafruit. Diese Bibliothek stellt alle nötigen Funktionen zum Auslesen von Temperatur und Luftfeuchtigkeit bereit.

Die Bibliothek kann über den Bibliotheksmanager in der Arduino IDE installiert werden (Werkzeuge -> Bibliotheken verwalten). Suche einfach nach „DHT sensor library“ und wähle die Version von Adafruit aus. Zusätzlich wird die „Unified Sensor Library“ von Adafruit benötigt. In neueren Arduino-Versionen erfolgt die Installation automatisch, ansonsten kannst du die Bibliothek ebenfalls manuell hinzufügen.

Der Arduino Sketch (wird im Video genauer erklärt)

#include <DHT.h>

#define DHTPIN 2       // Datenpin des DHT11-Sensors
#define DHTTYPE DHT11  // Sensor-Typ DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);  // Serielle Kommunikation starten
  dht.begin();         // DHT-Sensor initialisieren
  delay(1000);         // Sensor ist eher langsam, eine Sekunde warten
  Serial.println("DHT11 Temperatur- und Luftfeuchtigkeitsmessung gestartet.");
}

void loop() {
  // Temperatur und Luftfeuchtigkeit auslesen
  float temperature = dht.readTemperature();  // Temperatur in Celsius
  float humidity = dht.readHumidity();        // Luftfeuchtigkeit in %

  // Überprüfen, ob der Sensor gültige Daten liefert
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("Fehler beim Auslesen des Sensors!");
    delay(2000);  // 2 Sekunden warten und erneut versuchen
    return;
  }

  // Temperatur im seriellen Monitor ausgeben
  Serial.print("Temperatur: ");
  Serial.print(temperature);
  Serial.println(" °C");
  // Luftfeuchtigkeit im seriellen Monitor ausgeben
  Serial.print("Luftfeuchtigkeit: ");
  Serial.print(humidity);
  Serial.println(" %");

  Serial.println("-----------------------------");
  delay(2000);  // 2 Sekunden warten, bevor die Werte erneut ausgelesen werden
}

LED-Ampel zur Temperaturanzeige

Für eine visuelle Temperaturüberwachung kann das Projekt um eine Ampel-Anzeige aus zwei LEDs erweitert werden. Dabei zeigt eine grüne LED an, dass die Temperatur im gewünschten Bereich liegt (z. B. unter 30 °C). Eine rote LED signalisiert, wenn der eingestellte Temperaturwert überschritten wird.

Die LEDs werden über Vorwiderstände (z.B. 220Ω) mit dem Arduino verbunden. Die rote LED kommt an Digitalpin 10, die grüne LED an Digitalpin 11. Im Arduino Sketch wird die Temperatur mit dem festgelegten Grenzwert (30 °C) verglichen, und die entsprechende LED wird aktiviert.

#include <DHT.h>

#define DHTPIN 2       // Datenpin des DHT11-Sensors
#define DHTTYPE DHT11  // Sensor-Typ DHT11

#define LED_HOT 10   // Pin für die rote LED bei Temperaturen > 30 Grad
#define LED_OK 11  // Pin für die grüne LED bei Temperaturen <= 30 Grad

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);  // Serielle Kommunikation starten
  dht.begin();         // DHT-Sensor initialisieren
  delay(1000);         // Sensor ist eher langsam, eine Sekunde warten

  pinMode(LED_HOT, OUTPUT);   // Pin für LED_HOT als Ausgang festlegen
  pinMode(LED_OK, OUTPUT);  // Pin für LED_OK als Ausgang festlegen

  // LEDs ausschalten
  digitalWrite(LED_HOT, LOW);
  digitalWrite(LED_OK, LOW);

  Serial.println("DHT11 Temperatur- und Luftfeuchtigkeitsmessung gestartet.");
}

void loop() {
  // Temperatur und Luftfeuchtigkeit auslesen
  float temperature = dht.readTemperature();  // Temperatur in Celsius
  float humidity = dht.readHumidity();        // Luftfeuchtigkeit in %

  // Überprüfen, ob der Sensor gültige Daten liefert
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("Fehler beim Auslesen des Sensors!");
    delay(2000);  // 2 Sekunden warten und erneut versuchen
    return;
  }

  // Temperatur im seriellen Monitor anzeigen
  Serial.print("Temperatur: ");
  Serial.print(temperature);
  Serial.println(" °C");
  // Luftfeuchtigkeit im seriellen Monitor ausgeben
  Serial.print("Luftfeuchtigkeit: ");
  Serial.print(humidity);
  Serial.println(" %");

  // LEDs steuern basierend auf der Temperatur
  if (temperature > 30.0) {
    digitalWrite(LED_HOT, HIGH);  // LED für hohe Temperatur einschalten
    digitalWrite(LED_OK, LOW);  // LED für normale Temperatur ausschalten
    Serial.println("Temperatur > 30°C: LED_HOT eingeschaltet.");
  } else {
    digitalWrite(LED_HOT, LOW);    // LED für hohe Temperatur ausschalten
    digitalWrite(LED_OK, HIGH);  // LED für normale Temperatur einschalten
    Serial.println("Temperatur <= 30°C: LED_OK eingeschaltet.");
  }

  Serial.println("-----------------------------");
  delay(2000);  // 2 Sekunden warten, bevor die Werte erneut ausgelesen werden
}

Der DHT11-Sensor ist ein guter Einstieg, um Temperatur und Luftfeuchtigkeit mit einem Arduino zu messen. Wenn du aber präzisere Daten benötigst, dann ist der DHT22 oder komplexere Sensoren wie der BME280 vielleicht die bessere Wahl.

Fragen oder Anregungen? Bitte in den Kommentare!

Bestseller Nr. 1

ELEGOO UNO R3 Ultimate Starter Kit, Kompatibel mit Arduino IDE Vollständigster Elektronik Projekt Baukasten mit deutschem Tutorial, UNO R3 Mikrocontroller Board und Zubehör (mehr als 200 Teile)

• Umfangreichster ELEGOO UNO R3 Starter Kit mit 63 verschiedenen Komponenten: UNO R3 Entwicklungsboard, USB-Kabel, Widerstände, LEDs, Netzteil, Relais, Steckplatine u.a. Zubehör.
• Unsere Projekte wie z.B. das mit dem LCD Modul erfordern kein Löten. Es ist aber ein "Expansion Modul" dabei, mit dem auch weiterführende Projekte machbar sind, bei denen gelötet werden muss.
• Auf der mitgelieferten CD steht das deutsche Tutorial (PDF) mit über 30 Lektionen, die die benötigten Programmen und einfache Erklärungen enthalten. Ein aktuelles Tutorial können Sie auch über unsere Website herunterladen.
• Das UNO R3 Set ist für Erwachsene und Jugendliche geeignet und Sie können damit eigene Elektronik-Projekte realisieren. Vorkenntnisse über Elektronik und Programmierung sind nicht unbedingt erforderlich, aber hilfreich.
• Unser Starter Kit schafft einen leichten Einstieg in die Arduino Programmierung und ermöglicht Ihnen einen gut gangbaren Weg zur fortgeschrittenen Programmierung, wenn Sie sich zusätzliche Lehrbücher aneignen.

Bei Amazon kaufen

Bestseller Nr. 2

ELEGOO MEGA-R3 Starter Kit für Arduino Projekt Ultimate Starter Kit mit Deutschem Tutorial, MEGA-R3 Mikrocontroller und viel Elektronik Zubehöre

• Das komplette Starterkit mit mehr als 200 Komponenten und 100% kompatibel mit Arduino IDE.
• PDF-Tutorial auf der CD (mehr als 35 Lektionen). GY-61-Sensormodul mit Stiftleiste (kein Selbstlöten erforderlich). Sie können dieselben Tutorials auch online von unserer offiziellen Website herunterladen.
• Schönes Paket mit klarer Auflistung und Überraschung, einschließlich einer schönen kleinen Box, um das Widget wie LED, IC, Tasten, Dioden usw.
• Warnhinweis: Die Eingangsspannung des ELEGOO Netzteilmoduls beträgt 6,5 V - 9 V (DC) über einen 5,5 mm x 2,1 mm Stecker. Bitte überladen Sie es NICHT, da sonst Ihr Board und Ihre Chips verbrennen.
• Hinweis: Die Verwendung von ELEGOO Starterkits erfordert grundlegende elektronische Kenntnisse. Wenn der Benutzer keine Erfahrung hat, wäre es besser, ihn während des Studiums von jemandem führen und unterrichten zu lassen.

Bei Amazon kaufen

Widerstände auf einen Blick an ihren Farbcodes zu erkennen erfordert schon etwas Übung und auch nach vielen Jahren Elektronikbastelei muss ich immer noch bei manchen Farben nachdenken, welcher Multiplikator das nun ist.

Mit der mobile App Resistor Color Code Quiz – Widerstände erkennen (derzeit leider nur für Android) kann man den Zusammenhang zwischen den einzelnen Farben und den zugehörigen Grundwerten und Multiplikatoren jederzeit üben. Die App unterstützt alle Widerstände mit 3, 4 und 5 Bändern aus den Wertereihen E6 bis E192.

Bei der Entwicklung der App habe ich selbst einiges dazugelernt, vor allem über die Idee hinter den Wertebereichen der einzelnen E-Serien, warum genau diese Werte verwendet werden und E-Serie und Toleranz zusammenhängen. Mehr Infos dazu gibt es im zugehörigen Wikipedia-Artikel.

Durch ein Potentiometer kann die Empfindlichkeit des Sensors eingestellt werden, da dieser sonst auch auf kurze Impulse von TV-Fernbedienungen oder andere IR-Lichtquellen reagiert.

Für das Projekt benötigen wir

• Arduino Uno R3 – https://amzn.to/2VH1fHE
• KY-026 Flame Sensor – https://amzn.to/2Ii3uht
• passiver Piezo Buzzer – https://amzn.to/3gg5N18
• ein paar Jumperkabel

AZDelivery 3 x KY-006 Passives Piezo Buzzer Alarm...

Bei Amazon kaufen

AZDelivery 3 x Flammensensor KY-026 Modul...

Bei Amazon kaufen

Im Video zeige ich den Aufbau des Projektes, den Test der einzelnen Komponenten und das Endergebnis. Die verwendeten Arduino Sketches findet ihr hier im Anschluss.

Der Aufbau:

Funktionstest des Buzzers:

/********************************
 * makerblog.at - Tutorial
 * Fire Started Xmas Jukebox
 * 
 * Buzzer Test
 * 
 * Passiver Buzzer (die ohne weissen Aufkleber!)
 * Arduino GND -> - (GND)
 * Arduino 5V -> + (5V, meist mittleres Pin)
 * Arduino D11 -> S (Signal)
 * 
 * Funktionstest des Buzzers. 
 * Spielt wiederholt einen Ton ab.
 * 
 *********************************/

#define BUZZER_PIN 11

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  
  tone(BUZZER_PIN, 262, 250);
  delay(400);

  tone(BUZZER_PIN, 294, 250);
  delay(400);

  tone(BUZZER_PIN, 330, 250);
  delay(400);

  tone(BUZZER_PIN, 349, 250);
  delay(400);

  tone(BUZZER_PIN, 392, 250);
  delay(400);

  tone(BUZZER_PIN, 440, 250);
  delay(400);

  tone(BUZZER_PIN, 494, 250);
  delay(400);

  tone(BUZZER_PIN, 523, 400);
  delay(1000);

}

Funktionstest und Kalibrierung des Flammensensors:

/********************************
 * makerblog.at - Tutorial
 * Elegoo 37 Sensor Kit v2.0 - https://amzn.to/2JpJPgd
 * 
 * FLAME SENSOR TEST (z.B. aus Elegoo 37 Sensor Kit)
 * Arduino A0 -> AO (Analog Output)
 * Arduino 5V -> +
 * Arduino GND -> -
 * Arduino D7 -> DO (Digital Output)
 * 
 * Funktionstest des Flammensensors zur
 * Kalibrierung mit dem Potentiometer. 
 * 
 * Ziel: 
 * - LED1 am Sensor leuchtet immer
 * - LED2 am Sensor leuchtet erst, wenn Kerzenflamme nahe kommt (dann geht DO auf HIGH)
 * 
 *********************************/

#define SENSOR_PIN_A A0
#define SENSOR_PIN_D 7

void setup() {
  Serial.begin(9600);
  pinMode(SENSOR_PIN_D, INPUT);

  // Erste Messungen vom Sensor ignorieren, liefert manchmal Müll beim Start

  for (int x=0; x<10; x++) {
    int v = analogRead(SENSOR_PIN_A);
    delay(20);
  }
  
}

void loop() {

  // -----------------------------------------------------------
  // Ausgabe am besten über den [Serial Plotter] im Menu [Tools]
  // -----------------------------------------------------------
  
  // Fixe Obergrenze des Diagramms auf 1024 (autom. Skalierung verhindern)
  Serial.print(1024);
  Serial.print(",");
  // Digitalwert * 100 für bessere Sichtbarkeit, aus 1 wird 100
  Serial.print(digitalRead(SENSOR_PIN_D)*100); 
  Serial.print(",");
  // Analogwert zwischen 0 und 1024
  Serial.println(analogRead(SENSOR_PIN_A));
  delay(20);
}

Und der finale Sketch:

#include <NonBlockingRtttl.h>

#define BUZZER_PIN 11
#define SENSOR_PIN 7

/*
const char* song1 = "Rudolph the Red Nosed Raindeer:d=8,o=5,b=250:g,4a,g,4e,4c6,4a,2g.,g,a,g,a,4g,4c6,2b.,4p,f,4g,f,4d,4b,4a,2g.,g,a,g,a,4g,4a,2e.,4p,g,4a,a,4e,4c6,4a,2g.,g,a,g,a,4g,4c6,2b.,4p,f,4g,f,4d,4b,4a,2g.,g,a,g,a,4g,4d6,2c.6,4p,4a,4a,4c6,4a,4g,4e,2g,4d,4e,4g,4a,4b,4b,2b,4c6,4c6,4b,4a,4g,4f,2d,g,4a,g,4e,4c6,4a,2g.,g,a,g,a,4g,4c6,2b.,4p,f,4g,f,4d,4b,4a,2g.,4g,4a,4g,4a,2g,2d6,1c.6.";
const char* song2 = "Jingle Bells:d=4,o=5,b=170:b,b,b,p,b,b,b,p,b,d6,g.,8a,2b.,8p,c6,c6,c6.,8c6,c6,b,b,8b,8b,b,a,a,b,2a,2d6";
const char* song3 = "We Wish you a Merry Christmas:d=8,o=5,b=140:4d,4g,g,a,g,f#,4e,4c,4e,4a,a,b,a,g,4f#,4d,4f#,4b,b,c6,b,a,4g,4e,4d,4e,4a,4f#,2g";
*/

// Kurzversionen zum Testen
const char* song1 = "Rudolph:d=8,o=5,b=150:g,4a,g,4e,4c6,4a,2g.,g,a,g,a,4g,4c6,2b.";
const char* song2 = "Jingle:d=4,o=5,b=170:b,b,b,p,b,b,b,p,b,d6,g.,8a,2b.";
const char* song3 = "We Wish:d=8,o=5,b=140:4d,4g,g,a,g,f#,4e,4c,4e,4a,a,b,a,g,4f#,4d";

long randomIndex = 0; // zufälligen Song auswählen
byte playIt = 0; // 0 = gestoppt, 1=spielend

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(SENSOR_PIN, INPUT);

  randomSeed(analogRead(0)); // Zufallsgenerator seeden

 // Anfangs spielt kein Song, auf 1 setzen, falls beim Einschalten 
 // gleich losgepielt werden soll
  playIt = 0; 
  
}

void loop() {

  if (playIt) {
    if (!rtttl::isPlaying()) {
      if (randomIndex == 0) {
        rtttl::begin(BUZZER_PIN, song1);
      } else if (randomIndex == 1) {
        rtttl::begin(BUZZER_PIN, song2);
      } else if (randomIndex == 2) {
        rtttl::begin(BUZZER_PIN, song3);
      }
    }
    else {
      rtttl::play();
    }

    if (rtttl::done()) {
      playIt = 0;
    }
  } else {
    if (digitalRead(SENSOR_PIN)) {
      randomIndex = random(3);
      playIt = 1;
    }
    delay(100);
  }

}

Viele weitere Melodien im RTTTL Format gibt es hier:

http://mines.lumpylumpy.com/Electronics/Computers/Software/Cpp/MFC/RingTones.RTTTL

Nachdem das ursprüngliche Sensor Kit des Hersteller schon einige Jahre auf dem Markt war, wurde es kürzlich generalüberholt und führt jetzt je nach Shop ein Aufgerüsteter Bausatz oder einfach das V2.0 im Namen.

ELEGOO Aufgerüsteter 37 in 1 Sensormodul Bausatz Kompatibel mit Arduino IDE mit Anleitung für Elektronik Projekte, Mikrocontrollerboards Nicht im Lieferumfang Enthalten

• √ Der sinnvollste und leistungsstärkste Sensoren Module Bausatz Kit kompatibel mit Arduino IDE für Elektronik Projekte.
• √ Die Deutsche Anleitungen und Datenblättern für UNO R3, NANO sowie das Widerstands-Set auf CD oder auf Elegoo Webseite verfügbar.
• √ Das Sensormodul-Set ist voll kompatibel mit Standard-Mikrocontroller-Boards. Hinweis: Dieses Set wird nicht mit einem Mikrocontroller-Board geliefert.
• √ Umfassender Beschreibung nebst Tutorial und Beispiel-Skripten (auf englisch) für jedes Modul auf beiliegender CD oder via Download von der Elegoo-Homepage.
• √ Alle Komponenten sind in Europa zulässig und alle Sensoren in einer Plastikbox mit separatem Abteil.

29,99 EUR

Bei Amazon kaufen

Im ersten Review-Video schaue ich mir die ersten 12 Module aus diesem Kit an. Da die Sketches in der offiziellen Dokumentation von Elegoo ziemlich planlos aus verschiedensten Quellen zusammenkopiert sind, habe ich für die Sensoren jeweils eigene kurze Testsketches geschrieben.

Diese könnt ihr hier auf Github downloaden (einfach auf das grüne Code klicken): https://github.com/adidax/Elegoo37SensorKit

Review Video – Teil 1 von 3

Im ersten Teil teste und erkläre ich die folgenden 12 Sensoren:

• Lichtschranke / Photo Interrupter – https://amzn.to/36lMjET
• Klopf Sensor Modul KY-031 / Tap Module – https://amzn.to/37na66L
• RGB LED – https://amzn.to/3qfSaUs
• SMD RGB LED – https://amzn.to/3fTvBjx
• Two Color LED / 2-färbige LED – https://amzn.to/3qf8eFT
• DS18B20 Temperatursensor – https://amzn.to/2KU9huJ
• IR Hinderniserkennung KY-032 – https://amzn.to/3fQJChT
• Big Sound / Schallsensor – https://amzn.to/2VjWNyr
• Small Sound / Schallsensor
• Tracking / Line Follower – https://amzn.to/3qcIp9j
• IR Emitter LED / IR Sender – https://amzn.to/3msAceQ
• IR Receiver / IR Empfänger – https://amzn.to/37kdwHv

2.9inch E-Paper Module 296x128 Resolution 3.3V/5V Two-Color E-Ink Display Module epaper Screen SPI Interface for Raspberry Pi/Arduino/Nucleo Support Partial Refresh

• SPI interface, for connecting with controller boards like Raspberry Pi/Arduino/Nucleo, etc.
• Ultra low power consumption, basically power is only required for refreshing
• Onboard voltage translator, compatible with 3.3V/5V MCUs
• Comes with development resources and manual (examples for Raspberry Pi/Jetson Nano/Arduino/STM32)
• No backlight, keeps displaying last content for a long time even when power down

Bei Amazon kaufen

Ihr kennt dieses Art Displays vielleicht aus dem Supermarkt von den digitalen Preisschildern oder von E-Book-Readern wie dem Amazon Kindle.

E-Paper oder E-Ink-Displays bestehen aus vielen mikroskopisch kleinen Kapseln mit elektrisch geladenen, eingefärbten Partikeln, die durch Anlegen einer Spannung ihre Position innerhalb dieser Kapsel verändern können.

Weitere Infos gibts im Wikipedia-Eintrag https://de.wikipedia.org/wiki/Elektronisches_Papier. Wenn ein Partikel seine Position eingenommen hat, behält es diese über einen längeren Zeitraum ohne weiteren Stromverbrauch.

Die Displays haben dadurch den großen Vorteil, dass sie nur bei der Änderung des Bildschirminhaltes einen höheren Stromverbrauch haben, zur Anzeige des Inhaltes dann aber fast keine Energie mehr benötigen. 

Ein Nachteil ist, dass die Änderung des Bildschirminhaltes relativ lange dauert, da die Farbpartikel ja wirklich bewegt werden müssen. Am besten geeignet sind die Displays also zur Anzeige von Inhalten, die sich nicht allzu oft ändern – Buchseiten eben oder Produktpreise im Supermarktregal oder – wie in meinem Fall, die Anzeige eines Sensorwertes, der nur alle paar Sekunden aktualisiert werden muss.

Ich habe mir das 2,9" Display Modul mit 128x296 Pixel bestellt, jedoch anfangs nicht zum Laufen gebracht. Den Beispielsketch von Waveshare konnte ich zwar kompilieren und auf den Arduino uploaden, die Reaktion des Displays war aber gleich Null.

Erst mit der alternativen GxEPD2 Library, die sehr komfortabel eine Vielzahl von e-Paper Displays der Hersteller Waveshare und Good Display auf verschiedenen Mikrocontrollern unterstützt, hatte ich dann Erfolg.

Der Anschluss des Displays an einen Arduino UNO R3 und die Verwendung der Library bis zum funktionsfähigen Demo-Sketch habe ich in diesem Video dokumentiert:

Nach der Installation der GxEPD2 Library, die übrigens auf der Adafruit GFX Library aufbaut, muss man zuerst im Example Sketch die passende Zeile suchen, mit der das richtige display Objekt für die Kombination aus eigenem Mikrocontroller und Display erzeugt wird. Diese Zeile benötigt man dann auch für die weiteren Beispielsketches!

Der Arduino UNO hat ja eigentlich viel zu wenig SRAM für Variablen, um den Bildschirminhalt für dieses Display überhaupt zwischenspeichern zu können. Die Library arbeitet deswegen auf den kleinen Arduinos mit einer Methode namens „Paged drawing“ und erzeugt den Bildschirminhalt in kleinen Teilen in einer Picture Loop, also einer Schleife im Programmcode, die mehrmals durchlaufen wird, bis alle Teile des Gesamtbildes aufgebaut und ans Display übertragen wurden.

Als nächstes Projekt steht jetzt die Temperaturmessung über ein BME280 Sennsor Modul samt Ausgabe auf dem e-Paper Display am Plan. Dazu aber mehr, sobald es soweit ist.