#arduinoprogrammierung

Reaktionsspiele kennt jeder: Ein Signal erscheint – und man muss so schnell wie möglich reagieren. Genau dieses einfache Prinzip greifen wir in diesem Projekt auf und machen daraus ein kleines Arduino-Spiel:

„Zieh ab, wenn’s leuchtet!“

Dabei steht nicht das Gewinnen im Vordergrund, sondern das spielerische Lernen. Anhand eines einfachen Spiels lernst du, wie ein Arduino auf Sensordaten reagiert, wie sich Zeitspannen messen lassen und wie Ausgaben wie LEDs oder ein Piezo-Buzzer angesteuert werden.

Im Mittelpunkt steht eine Gabellichtschranke, deren Signal ausgewertet wird, um eine Reaktion exakt zu erfassen. Ohne komplizierte Schaltungen entsteht so ein Projekt, das sofort verständlich ist und gleichzeitig wichtige Grundlagen vermittelt.

https://youtu.be/deVJiPudjW0

Statt eines trockenen Beispiels entsteht ein kleines Spiel, das direkt Feedback liefert – sichtbar, hörbar und messbar. Ideal für Einsteiger, Workshops oder als kleines Projekt für zwischendurch.

Spielidee & Ablauf

Das Spielprinzip von „Zieh ab, wenn’s leuchtet!“ ist bewusst einfach gehalten, damit der Fokus nicht auf komplizierter Technik liegt, sondern auf dem Zusammenspiel von Sensor, Signal und Reaktion.

Die Grundidee

Ein kleiner Steg steckt in einer Gabellichtschranke und unterbricht dort den Lichtstrahl. Solange der Steg steckt, weiß der Arduino: Das Spiel ist bereit. Sobald der Lichtstrahl wieder frei ist, erkennt der Arduino sofort die Bewegung – ganz ohne mechanischen Kontakt.

Der Clou: Der Spieler darf den Steg erst dann herausziehen, wenn das Startsignal erscheint.

So läuft eine Spielrunde ab - Vorbereitung Der Steg wird in die Gabellichtschranke gesteckt und blockiert den Lichtstrahl. Das Spiel wartet auf den Start. - Spielstart Nach dem Drücken des Starttasters beginnt eine zufällige Wartezeit. Diese Zufälligkeit verhindert, dass man „auf Verdacht“ reagiert. - Startsignal Die LED leuchtet auf (optional zusätzlich ein Piezo-Ton). Ab diesem Moment zählt jede Millisekunde. - Reaktion Der Spieler zieht den Steg so schnell wie möglich aus der Gabellichtschranke. Der Lichtstrahl ist wieder frei – das Signal ändert sich. - Zeitmessung Der Arduino misst die Zeit zwischen Startsignal und dem Moment, in dem der Steg gezogen wurde. - Ergebnis Die gemessene Reaktionszeit wird ausgegeben und kann mit vorherigen Runden verglichen werden.

Was lernst du bei diesem Projekt?

Auch wenn „Zieh ab, wenn’s leuchtet!“ auf den ersten Blick wie ein simples Spiel wirkt, stecken darin mehrere grundlegende Arduino-Konzepte, die in vielen Projekten immer wieder gebraucht werden.

Digitale Signale verstehen und auswerten

Du lernst, wie ein digitales Sensorsignal funktioniert und wie der Arduino erkennt, ob der Lichtstrahl der Gabellichtschranke unterbrochen ist oder nicht. Dabei wird klar, was HIGH und LOW bedeuten und warum Pull-up-Widerstände in der Praxis so wichtig sind.

Sensoren sinnvoll einsetzen

Die Gabellichtschranke dient hier nicht nur als „An/Aus-Schalter“, sondern als präziser Sensor, mit dem sich Bewegungen zuverlässig erfassen lassen – ganz ohne mechanischen Kontakt oder Prellen.

Zeit messen am Arduino

Ein zentraler Bestandteil des Spiels ist die Zeitmessung. Du lernst, wie der Arduino Zeitpunkte speichert und daraus Reaktionszeiten im Millisekunden- oder Mikrosekundenbereich berechnet.

LEDs und Piezo-Buzzer ansteuern

Das Projekt zeigt, wie Ausgaben richtig eingesetzt werden: Eine LED signalisiert den Startzeitpunkt, ein Piezo-Buzzer kann diesen zusätzlich akustisch untermalen. So entsteht ein klares, für den Spieler verständliches Feedback.

Programmabläufe logisch strukturieren

Du baust eine einfache, aber saubere Spiellogik auf:

- Warten auf ein Startsignal - Zufällige Verzögerung - Start der Zeitmessung - Auswertung des Sensors - Ausgabe des Ergebnisses

Diese Struktur lässt sich später auf viele andere Arduino-Projekte übertragen.

Benötigte Bauteile

Für das Reaktionsspiel „Zieh ab, wenn’s leuchtet!“ werden nur wenige, gut verfügbare Komponenten benötigt. Viele davon hast du vielleicht bereits in deiner Bastelkiste.

- Arduino UNO* (alternativ Arduino Nano oder andere AVR-basierte Mikrocontroller) - Gabellichtschranke* (optischer Sensor zur Erkennung des herausgezogenen Stegs) - Drei LEDs mit Vorwiderständen* (rot, gelb, grün – z. B. jeweils 220 Ω) - Piezo-Buzzer* (für akustisches Feedback beim Startsignal) - I2C OLED Display* (z. B. 0,96" mit SSD1306-Controller zur Anzeige der Reaktionszeit) - 400-Pin Breadboard* - Diverse Breadboardkabel* (Dupont-Kabel)

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Alternative Mikrocontroller

Statt dem klassischen Arduino UNO kannst du auch den Arduino Nano, oder einen UNO R4 Minima/WiFi/Nano verwenden. Alle diese Mikrocontroller sind kompatibel mit diesem Beitrag.

v.l.n.r. - Arduino UNO R4 Minima - Arduino Nano ESP32 - Arduino Nano V3 - Arduino Nano R4

Die Gabellichtschranke verstehen – warum wir Interrupts nutzen

Die Gabellichtschranke liefert ein digitales Signal: Ist der Lichtstrahl unterbrochen, ändert sich der Zustand am Ausgang (HIGH/LOW).

Man könnte dieses Signal grundsätzlich an einem normalen digitalen Pin abfragen. Für ein Reaktionsspiel ist das jedoch nicht zuverlässig genug. Der Grund: Der Arduino fragt solche Pins nur in bestimmten Programmabschnitten ab. Währenddessen können andere Aufgaben laufen – kurze Signaländerungen gehen verloren oder werden zeitlich ungenau erfasst.

Da es in diesem Projekt auf Millisekunden ankommt, nutzen wir einen Interrupt.

Interrupts sorgen dafür, dass der Arduino sofort reagiert, sobald sich das Signal der Gabellichtschranke ändert – unabhängig davon, was das Hauptprogramm gerade macht.

Beim Arduino UNO stehen dafür die Interrupt-Pins 2 und 3 zur Verfügung. Nur diese Pins können Signaländerungen hardwareseitig direkt erfassen.

Für das Spiel bedeutet das:

- Der Moment, in dem der Steg gezogen wird, wird exakt erkannt - Die Zeitmessung ist präzise und reproduzierbar - Keine Reaktion geht verloren

Merksatz: Zeitkritische Sensorsignale gehören an Interrupt-Pins.

Welche Interrupt-Pins stehen zur Verfügung?

Nicht jeder Arduino stellt die gleichen Pins für Interrupts bereit. Welche Pins genutzt werden können, hängt vom jeweiligen Mikrocontroller ab.

In diesem Projekt verwenden wir bewusst einen klassischen Arduino UNO, bei dem die Interrupt-Pins klar definiert sind. Wenn du jedoch ein anderes Board einsetzt, solltest du wissen, welche Pins Interrupts unterstützen.

Übersicht: Interrupt-fähige Pins nach Board BoardBenutzbare Digitalpins für InterruptsUNO, Nano, Mini (ATmega328-basierte Boards)2, 3Mega, Mega 2560, Mega ADK2, 3, 18, 19, 20, 21Micro, Leonardo (ATmega32u4)0, 1, 2, 3, 7

Weitere Informationen findest du in der offiziellen Dokumentation unter https://docs.arduino.cc/language-reference/de/funktionen/external-interrupts/attachInterrupt/

LEDs und Piezo-Buzzer ansteuern - einfache digitale Ausgänge

Nachdem wir uns mit der Gabellichtschranke und den Interrupts beschäftigt haben, kümmern wir uns nun um die Ausgabeseite des Spiels. Dazu gehören in diesem Projekt drei LEDs und ein Piezo-Buzzer.

Im Gegensatz zur Lichtschranke sind diese Bauteile unkritisch: Sie werden ganz normal an digitale Pins des Arduino angeschlossen und per Software ein- und ausgeschaltet.

LEDs als visuelles Feedback

Die LEDs dienen im Spiel als klare visuelle Signale:

- Rot → Warten / Sperre - Gelb → Vorbereitung - Grün → Startsignal („Zieh ab!“)

Jede LED wird über einen Vorwiderstand (z. B. 220 Ω) an einen eigenen digitalen Pin angeschlossen. Der Arduino schaltet die LEDs anschließend einfach mit HIGH oder LOW.

Technisch betrachtet passiert hier nichts Besonderes – und genau das ist der Vorteil: Der Fokus liegt nicht auf der Schaltung, sondern auf der logischen Bedeutung der Signale im Spielablauf.

Piezo-Buzzer ansteuern – tone() und noTone()

Auch der Buzzer wird an einen normalen digitalen Pin angeschlossen. Zur Ansteuerung stellt die Arduino-Umgebung die Funktion tone() zur Verfügung.

Piezo Buzzer

Dabei gibt es zwei gängige Varianten, die man kennen sollte:

tone(pin, frequenz, dauer)

Wird zusätzlich eine Dauer angegeben, erzeugt der Arduino einen Ton mit der gewünschten Frequenz für genau diesen Zeitraum.

tone(buzzerPin, 1000, 200);

In diesem Beispiel wird ein Ton mit 1000 Hz für 200 Millisekunden ausgegeben. Nach Ablauf der Zeit stoppt der Ton automatisch – ein zusätzlicher Funktionsaufruf ist nicht notwendig.

Diese Variante eignet sich besonders für:

- kurze Signal- oder Bestätigungstöne - Countdown- oder Startsignale - einfache Soundeffekte tone(pin, frequenz) + noTone(pin)

Wird die Funktion tone() ohne Dauer aufgerufen, läuft der Ton endlos, bis er explizit gestoppt wird.

tone(buzzerPin, 800); // ... noTone(buzzerPin);

Hier beginnt der Ton mit 800 Hz und bleibt aktiv, bis noTone() aufgerufen wird.

Diese Variante ist sinnvoll, wenn:

- der Ton von einer Bedingung abhängt - ein Signal aktiv bleiben soll, bis ein Ereignis eintritt - der Ton manuell beendet werden soll Warum wir D0 und D1 bewusst nicht verwenden

Beim Arduino UNO (und kompatiblen Boards) sind die Pins D0 und D1 etwas Besonderes:

- D0 → RX (Serielle Kommunikation) - D1 → TX (Serielle Kommunikation)

Diese Pins werden unter anderem:

- beim Upload eines Programms - für den seriellen Monitor

verwendet.

RX & TX Pins am Arduino UNO

Würden wir LEDs oder den Buzzer an diese Pins anschließen, könnte es:

- zu Problemen beim Upload kommen - zu unerwartetem Flackern oder Tönen - zu gestörter serieller Ausgabe führen

Daher gilt als Faustregel: D0 und D1 bleiben für die serielle Kommunikation reserviert.

Für LEDs und Buzzer stehen mehr als genug andere digitale Pins zur Verfügung.

OLED-Display am Arduino – Ansteuerung über I2C

Für die Anzeige der Reaktionszeit verwenden wir ein OLED-Display mit I2C-Schnittstelle. Der große Vorteil von I2C: Mit nur vier Anschlüssen lässt sich das Display vollständig betreiben.

Benötigte Anschlüsse

Ein I2C-OLED-Display benötigt lediglich:

- VCC → Versorgungsspannung (5 V oder 3,3 V, je nach Modul) - GND → Masse - SDA → Datenleitung - SCL → Taktleitung

Damit ist das Display schnell angeschlossen und spart wertvolle Pins am Arduino.

I2C-Pins am Arduino UNO

Beim Arduino UNO sind die I2C-Pins besonders komfortabel herausgeführt: zum einen als separate, eindeutig beschriftete Buchsen neben AREF (oben links), zum anderen bei den analogen Pins A4 → SDA und A5 → SCL.

Arduino UNO SCL & SDA Pins

Das bedeutet:

- Du kannst entweder die dedizierten SDA/SCL-Pins verwenden - oder alternativ A4 und A5, falls das besser zu deinem Aufbau passt

Beide Varianten funktionieren gleichwertig.

Schaltung & Verdrahtung – alles zusammengeführt

Nachdem wir alle verwendeten Komponenten einzeln betrachtet haben, setzen wir sie nun zu einer vollständigen Schaltung zusammen. Der Aufbau erfolgt bewusst auf einem Breadboard, sodass keine Lötarbeiten notwendig sind und Änderungen jederzeit möglich bleiben.

BauteilFunktionArduino-PinGabellichtschrankeDOD2 (Interrupt-Pin)VCC5 VGNDGNDLED rotStatus „Warten / Sperre“D10LED gelbStatus „Vorbereitung“D9LED grünStartsignalD8Piezo-BuzzerSignalD11GNDGNDStart-TasterSignalD12GNDGNDOLED-Display (I2C)VCC5 VGNDGNDSDASDA / A4SCLSCL / A5

3D-Druck: Halter für die Gabellichtschranke

Für das Reaktionsspiel „Zieh ab, wenn’s leuchtet!“ habe ich einen kleinen 3D-gedruckten Halter für die Gabellichtschranke entworfen. Der Halter nimmt die Lichtschranke passgenau auf und stellt den herausziehbaren Steg bereit, der den Lichtstrahl zuverlässig unterbricht.

Die STL-Dateien kannst du kostenlos auf Thingiverse herunterladen:

Download auf Thingiverse: https://www.thingiverse.com/thing:7269572

Der Halter ist bewusst minimal gehalten und eignet sich ideal für:

- Steckbrett-Aufbauten - Tests und Prototypen - Workshops und Demonstrationen

Programmierung – Schritt für Schritt zum fertigen Spiel

Eine Eieruhr mit Arduino? Warum nicht! In diesem Projekt baue ich eine digitale Countdown-Uhr, die die verbleibende Zeit auf einer 4-stelligen 7-Segment-Anzeige darstellt und nach Ablauf ein akustisches Signal über einen Piezo-Buzzer ausgibt. https://youtu.be/Sn4FxH1B3s4 Ein besonderer Vorteil dieser Anzeige ist, dass sie einen Doppelpunkt besitzt. Dadurch kann die Zeitdarstellung automatisch angepasst werden: - Bis 59 Sekunden wird der Countdown klassisch in Sekunden angezeigt. - Ab 60 Sekunden wechselt die Anzeige in das MM:SS-Format (Minuten:Sekunden). Dadurch ist eine maximale Countdown-Zeit von 99 Minuten und 59 Sekunden möglich – perfekt für das Frühstücksei, aber auch ideal für längere Koch- oder Backvorgänge. Die Steuerung erfolgt über zwei Taster: 🔴 Roter Taster – Stoppt den Timer jederzeit. 🟢 Grüner Taster – Startet den Timer mit der voreingestellten Zeit. Das Ganze läuft auf einem Arduino Nano V3, der genauso leistungsfähig wie ein Arduino UNO ist, aber deutlich kompakter. Im folgenden Abschnitt zeige ich dir, wie du diese digitale Eieruhr mit flexibler Zeitdarstellung und akustischem Countdown-Signal ganz einfach selbst nachbauen kannst!

Schaltung - Arduino Eieruhr Hinweis: Idee aus der Community - Die Idee zu diesem Beitrag stammt von einem Leser meines Blogs, der sich zum Beitrag „Flexibler Timer für Arduino: Wie du die Zeit per Poti regulierst“ gemeldet hat. Dort habe ich gezeigt, wie man mit einem Drehpotentiometer die Timersteuerung am Arduino flexibel anpassen kann.

Schaltung - Arduino UNO R4 Minima - Drehpotentiometer und LEDs

Schaltung - Arduino UNO R4 Minima mit Servomotor SG90 und Drehpotentiometer Zunächst habe ich versucht, die Zeitsteuerung mit einem Rotary Encoder zu realisieren. Allerdings führte das Aktualisieren der 4-stelligen 7-Segmentanzeige dazu, dass Impulse des Encoders nicht zuverlässig erkannt wurden. Deshalb bin ich auf eine einfache und robuste Lösung mit drei Tastern umgestiegen: - „+“ erhöht den Timer-Wert. - „-“ verringert den Timer-Wert. - „Select“ wechselt zwischen Minuten- und Sekunden-Einstellung. Diese Lösung ist nicht nur stabiler, sondern auch intuitiv in der Bedienung. Ich freue mich immer über Input aus der Community und helfe gerne weiter, wenn es um spannende Projekte geht. Falls du also eigene Ideen oder Fragen hast, hinterlasse einfach einen Kommentar – vielleicht wird daraus ja der nächste Blogbeitrag! 😊

Aufbau der Schaltung - Eieruhr mit Segmentanzeige und Taster am Arduino Nano

Bevor wir die Schaltung auf eine Platine übertragen, bauen wir sie zunächst auf einem Breadboard auf. Dafür benötigen wir folgende Komponenten: - Arduino Nano V3* (inkl. Datenkabel) - Piezo-Buzzer* für das akustische Signal - fünf Taster mit Tasterkappen* (Start/Stopp) - 4-stellige 7-Segmentanzeige Typ TM1637* - 830-Pin Breadboard* für den Hauptaufbau - 170-Pin Breadboard* für die Segmentanzeige - diverse Breadboardkabel* zur Verkabelung Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Falls du keinen Arduino Nano V3 zur Hand hast, kannst du alternativ auch ein Arduino UNO oder Arduino Mega verwenden. Ich habe mich für den Nano entschieden, da er genauso leistungsfähig wie der UNO ist, aber deutlich kompakter – was später für die endgültige Schaltung von Vorteil ist.

Schaltung - Arduino mit Taster - Segmentdisplay und Piezo Buzzer Wenn du es aber noch kompakter als den schon kleinen Arduino Nano V3 haben möchtest, dann kannst du den Super Mini Arduino Nano Clone verwenden welchen ich im Beitrag Arduino Nano Clone von Aliexpress: Günstig, aber oft mit Mängeln vorgestellt habe. Dieser bietet trotz seiner Größe genügend Pins & Power für dieses Projekt.

Alternativer Aufbau am Arduino UNO R3/R4 mit Prototyp-Board

Die Schaltung ist kompakt genug um auch auf einem Prototyp-Board für den Arduino UNO gebaut zu werden.

Da der neue Arduino UNO R4 das selbe Pinout hat wie der Vorgänger UBO R3 kannst du hier auch auf den neuen Mikrocontroller der Arduino Familie setzen.

Programmieren der Arduino Eieruhr in der Arduino IDE

Wie du einen Taster, Drehpotentiometer, Piezo Buzzer und auch die 4fach 7 Segmentanzeige am Arduino programmierst habe ich dir bereits in separaten Beiträgen gezeigt. - Arduino Lektion 87: Taster entprellen - Arduino UNO R3 – Gabellichtschranke& Piezo Buzzer - Arduino Lektion 26: TM1637 – 4 Digit 7 Segment Display Nachfolgend, die Schritt-für-Schritt-Anleitung zur erstellung des Sketches für die Eieruhr. Schritt 1 - einbinden der benötigten Module Für die Ansteuerung der 4fach 7 Segmentanzeige vom Typ TM1637 und zum entprellen der Taster benötigen wir jeweils eine Bibliothek. Diese können wir über den Bibliotheksverwalter installieren.

Sobald beide Bibliotheken installiert sind, können wir sie mit dem folgenden Befehl in unser Projekt einbinden. #include // Bibliothek für die 7-Segment-Anzeige (TM1637) #include // Bibliothek zur Tasten-Entprellung Schritt 2 - definieren der verwendeten Pins & Objekte initialisieren Im nächsten Schritt definieren wir die Pins für die verbauten Komponenten und initalisieren die entsprechenden Objekte. // Pins für die 7-Segment-Anzeige #define segmentanzeige_CLK 6 #define segmentanzeige_DIO 5 TM1637Display display(segmentanzeige_CLK, segmentanzeige_DIO); // Anzeige-Objekt erstellen // Tasten-Pins definieren #define tasterStopp 3 #define tasterStart 4 #define tasterPlus 7 #define tasterMinus 8 #define tasterSelect 9 // Bounce-Objekte für die Tasten-Entprellung Bounce bceTasterStopp = Bounce(); Bounce bceTasterStart = Bounce(); Bounce bceTasterPlus = Bounce(); Bounce bceTasterMinus = Bounce(); Bounce bceTasterSelect = Bounce(); // Pin für den Piezo-Buzzer #define buzzer 10 Schritt 3 - Felder zum speichern der Zustände Für unseren Code benötigen wir einpaar Felder in welche wir zbsp. speichern ob der Countdown gerade läuft und wie hoch der Countdown ist. // Variable für den Countdown in Sekunden unsigned int seconds = 0; // Timer-Zustand (läuft oder gestoppt) bool clockStarted = false; // Auswahl der Zeiteinheit: // 0 = Sekunden, 1 = Minuten unsigned int timeAuswahl = 0; // Wartezeit zwischen Sekundenverringerungen const unsigned int PAUSE = 1000; unsigned long lastAction = 1L; // Alarmzustand (true = abgelaufen) bool alarm = false; Schritt 4 - Funktion Setup Die setup()-Funktion wird einmalig beim Start des Mikrocontrollers aufgerufen – sowie nach einem Neustart über den RESET-Taster. In dieser Funktion legen wir die Helligkeit der 7-Segment-Anzeige fest und verknüpfen die Taster-Pins mit den Bounce-Objekten, um eine zuverlässige Tastenentprellung zu gewährleisten. void setup() { Serial.begin(9600); Serial.println("Initialized"); // Debug-Ausgabe // Helligkeit der 7-Segment-Anzeige setzen (maximale Helligkeit: 7) display.setBrightness(7); // Anzeige initial mit "--:--" belegen uint8_t data = { 0xff, 0xff, 0xff, 0xff }; display.setSegments(data); // Taster als Eingänge mit Pull-Up-Widerständen definieren und entprellen bceTasterStopp.attach(tasterStopp, INPUT_PULLUP); bceTasterStopp.interval(5); bceTasterStart.attach(tasterStart, INPUT_PULLUP); bceTasterStart.interval(5); bceTasterPlus.attach(tasterPlus, INPUT_PULLUP); bceTasterPlus.interval(5); bceTasterMinus.attach(tasterMinus, INPUT_PULLUP); bceTasterMinus.interval(5); bceTasterSelect.attach(tasterSelect, INPUT_PULLUP); bceTasterSelect.interval(5); pinMode(buzzer, OUTPUT); // Buzzer als Ausgang setzen displayTime(); // Anfangszeit auf dem Display aktualisieren } Schritt 5 - Funktion loop Die loop()-Funktion wird kontinuierlich ausgeführt und enthält den Code für die Steuerung der Eieruhr. Bevor wir die Taster auswerten können, müssen wir sie mit der Funktion update() aktualisieren. Anschließend können wir mit fell() überprüfen, ob ein Taster losgelassen wurde, um entsprechende Aktionen auszuführen. // Tasten aktualisieren (Entprellung) bceTasterStopp.update(); bceTasterStart.update(); // Taster "Stopp" beendet den Timer und setzt den Alarm zurück if (bceTasterStopp.fell()) { clockStarted = false; alarm = false; } // Taster "Start" beginnt den Countdown if (bceTasterStart.fell()) { clockStarted = true; alarm = false; } Der Countdown wird durch das Drücken der Start-Taste aktiviert, wodurch die Variable clockStarted auf true und alarm auf false gesetzt wird. Dadurch beginnt der Timer zu laufen und zählt in der loop()-Funktion in Schritten von einer Sekunde herunter. // Wenn der Timer läuft und noch nicht abgelaufen ist else if (clockStarted && !alarm) { unsigned long currentMillis = millis(); // Jede Sekunde die Zeit verringern if ((lastAction + PAUSE) lastAction = currentMillis; if (seconds > 0) { seconds--; // Eine Sekunde abziehen } else { alarm = true; // Timer abgelaufen } } displayTime(); Solange der Countdown nicht gestartet ist, also die Variable clockStarted auf false steht, kann die Zeit eingestellt werden. Über die Select-Taste lässt sich zwischen den beiden Einstellfeldern Minuten und Sekunden wechseln. - In der Sekunden-Einstellung wird der Wert sekundengenau um eins erhöht oder verringert. - Ist die Minuten-Einstellung aktiv, werden 60 Sekunden zur Variable seconds hinzugefügt oder abgezogen. if (!clockStarted) { bool buttonPressed = false; // Taster "Select" wechselt zwischen Minuten- und Sekundenmodus if (bceTasterSelect.fell()) { timeAuswahl = (timeAuswahl == 0) ? 1 : 0; } // Taster "+" erhöht die Sekunden oder Minuten if (bceTasterPlus.fell()) { buttonPressed = true; if (timeAuswahl == 0) { seconds++; } else { seconds += 60; } } // Taster "-" verringert die Sekunden oder Minuten if (bceTasterMinus.fell() && seconds > 0) { buttonPressed = true; if (timeAuswahl == 0) { seconds--; } else { seconds -= 60; } } // Nach einer Änderung die neue Zeit anzeigen if (buttonPressed) { displayTime(); } }

fertiger Quellcode - Arduino Eieruhr mit flexiblem Timer

Manchmal entstehen die besten Ideen für neue Blogbeiträge aus der Community – und genau das ist hier der Fall! In einem Kommentar zu meinem Beitrag „Intervall-Ausführung leicht gemacht: Timer für Arduino“ fragte ein Leser, wie sich der Timer flexibel gestalten lässt, indem die Zeit über einen Analogwert, beispielsweise von einem Potentiometer, eingestellt wird. https://youtu.be/K9Ce1ht7W34 Diese Idee fand ich spannend, denn sie zeigt, wie einfach und praktisch sich Arduino-Projekte anpassen lassen. In diesem Beitrag zeige ich dir, wie du mit wenigen Zeilen Code den Timer-Wert dynamisch mit einem Potentiometer steuern kannst – eine einfache und effektive Lösung! Braucht du Hilfe oder hast Fragen? Falls du Unterstützung benötigst oder weitere Fragen hast, kannst du mir gerne einen Kommentar unter diesem Beitrag hinterlassen oder mich direkt per E-Mail unter [email protected] kontaktieren. Ich freue mich immer über Feedback und Austausch mit der Community!

Timerschaltung mit einem Drehpotentiometer am Arduino

Nachfolgend die kleine Schaltung am Arduino, du kannst diese mit jedem Mikrocontroller der Arduino Familie nachbauen (Micro, Nano, Leonard und auch Mega). Für die Schaltung habe ich verwendet: - einen Mikrocontroller der Arduino Familie - einen 50 kOhm Drehpotentiometer* - fünf LEDs* - einen 220 Ohm Vorwiderstand* - diverse Breadboardkabel*, 10 cm - ein 400 Pin Breadboard*

Schaltung - Arduino UNO R3 - Drehpotentiometer - LEDs Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Schaltung - Arduino UNO R4 Minima - Drehpotentiometer und LEDs

Arduino-Code: Flexibler Timer mit Potentiometer steuern – ohne delay()!

Auf Instagram bin ich auf das interessante Projekt „Color Memory“ von Sunflower gestoßen. Dieses kleine Spiel überzeugt durch seinen einfachen Aufbau und eignet sich hervorragend für Einsteiger, die grundlegende Programmierkonzepte und den Umgang mit dem Arduino kennenlernen möchten. Es bietet eine praktische Möglichkeit, Abläufe im Code zu verstehen und eine Schaltung mit LEDs und einem Piezo-Buzzer zu erstellen. Dabei lernst du, wie du if-Bedingungen verwendest, Arrays einsetzt und die Steuerung von Hardwarekomponenten wie LEDs und Buzzern programmierst. Zusätzlich ermöglicht das Projekt, erste Erfahrungen in der Strukturierung und Erweiterung von Code zu sammeln – perfekt, um die Grundlagen der Mikrocontroller-Programmierung zu vertiefen. https://youtu.be/SV_pxPFMMFA Disclaimer: Die Idee für das Projekt „Color Memory“ stammt vom Instagram-Account Sunflower. Ich habe mich von diesem Beitrag inspirieren lassen und das Spiel für meinen Technikblog aufgegriffen. Die Umsetzung und Beschreibung basieren auf meinen eigenen Anpassungen und Interpretationen des ursprünglichen Konzepts. Ein herzliches Dankeschön an Sunflower für die kreative Idee und die Inspiration!

Ablauf des Spieles - Color Memory

Das Spiel beginnt mit dem zufälligen Aufleuchten einer Sequenz von LEDs, die vom Mikrocontroller vorgegeben wird. Sobald die Sequenz beendet ist, ertönt ein Signalton vom Piezo-Buzzer, der den Spieler auffordert, die Reihenfolge der LEDs korrekt nachzubilden. Der Spieler gibt die Sequenz ein, indem er beispielsweise Tasten drückt, die den jeweiligen LEDs zugeordnet sind. Wird die Reihenfolge korrekt wiederholt, erhält der Spieler einen Punkt, und die Sequenz wird in der nächsten Runde um eine LED erweitert. Mit jedem Level steigt die Schwierigkeit, da die Reihenfolge länger und komplexer wird. Ein Fehler in der Eingabe beendet das Spiel. Ziel ist es, so viele Runden wie möglich zu meistern!

Was lernt man bei der Programmierung?

Du lernst, wie du Zufallszahlen erzeugst, um die Reihenfolge der LEDs zu bestimmen, Arrays anlegst und dynamisch befüllst, um die Sequenz zu speichern, sowie digitale Pins programmierst, um LEDs und einen Piezo-Buzzer anzusteuern. Dieses Projekt kombiniert spielerischen Spaß mit praktischen Lernerfahrungen in der Mikrocontroller-Programmierung und eignet sich hervorragend, um deine Fähigkeiten gezielt auszubauen.

Was wird für den Aufbau der Schaltung benötigt?

In meinem Fall verwende ich für die Schaltung: - einen Arduino UNO R3*, oder - einen Arduino Nano V3 - vier, 5 mm LEDs* inkl. 220 Ohm Vorwiderstand* - vier Taster mit farbigen Tastknöpfen* - eine I2C, 4fach 14 Segmentanzeige* - diverse Breadboardkabel* - ein 830 Pin Breadboard*

Statt einem Arduino UNO R3 kannst du ebenso ein Arduino Nano oder ESP32 verwenden. Der UNO R3 hat sich in diesen Schaltungen etabliert, da dieser bei diversen Kits enthalten ist. Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Aufbau der Schaltung

Wie erwähnt kannst du die Schaltung am Arduino UNO und Nano aufbauen (selbstverständlich auch am Leonardo sowie Mega 2560 R3).

Schaltung - Color Memory am Arduino UNO R3

Programmieren des Spieles - Color Memory in der Arduino IDE

Wie eingangs erwähnt, bietet dir die Programmierung dieses Spiels eine wertvolle Grundlage für viele weitere Spiele und Projekte. Im Laufe der Entwicklung wirst du wichtige Techniken und Konzepte kennenlernen, die dir auch bei zukünftigen Vorhaben nützlich sein werden. In den folgenden Abschnitten zeige ich dir Schritt für Schritt, wie du dieses kleine, aber spannende Spiel selbst programmieren kannst. Schritt 1 - Abfragen von Taster & aufleuchten von LEDs Im ersten Schritt fragen wir die Taster ab und lassen die LEDs aufleuchten. Die Taster müssen entprellt werden, dazu kannst du entweder nach jedem Tastendruck eine Zeit x warten (Funktion delay) oder du nutzt die Bibliothek Bounce2. Der Weg über die Bibliothek ist deutlich komfortabler, da du hier zusätzlich abfragen kannst, ob der Taster gedrückt gehalten wird oder losgelassen wurde. #include #define tasterBlauPin 3 #define tasterGruenPin 5 #define tasterGelbPin 7 #define tasterRotPin 9 Bounce tasterBlau = Bounce(); Bounce tasterGruen = Bounce(); Bounce tasterGelb = Bounce(); Bounce tasterRot = Bounce(); const int BOUNCE_INTERVAL = 5; void setup() { Serial.begin(9600); tasterBlau.attach(tasterBlauPin, INPUT_PULLUP); tasterBlau.interval(BOUNCE_INTERVAL); tasterGruen.attach(tasterGruenPin, INPUT_PULLUP); tasterGruen.interval(BOUNCE_INTERVAL); tasterGelb.attach(tasterGelbPin, INPUT_PULLUP); tasterGelb.interval(BOUNCE_INTERVAL); tasterRot.attach(tasterRotPin, INPUT_PULLUP); tasterRot.interval(BOUNCE_INTERVAL); } void loop() { tasterBlau.update(); tasterGruen.update(); tasterGelb.update(); tasterRot.update(); if (tasterBlau.rose()) { Serial.println("Taster BLAU betätigt!"); } if (tasterGruen.rose()) { Serial.println("Taster GRUEN betätigt!"); } if (tasterGelb.rose()) { Serial.println("Taster GELB betätigt!"); } if (tasterRot.rose()) { Serial.println("Taster ROT betätigt!"); } } Auf der seriellen Schnittstelle wird beim betätigen eines der Taster jeweils der entsprechende Text "Taster betätigt!" ausgegeben.

Die LEDs sollen jeweils nur kurz aufleuchten, dazu erstellen wir eine Funktion, welcher wir den Pin der LED übergeben und dort einfach diese aktiviert, eine Pause eingelegt und anschließend deaktiviert wird. #include #define ledBlau 2 #define ledGruen 4 #define ledGelb 6 #define ledRot 8 void setup() { Serial.begin(9600); pinMode(ledBlau, OUTPUT); pinMode(ledGruen, OUTPUT); pinMode(ledGelb, OUTPUT); pinMode(ledRot, OUTPUT); } void blinkLed(int ledPin) { digitalWrite(ledPin, HIGH); delay(500); digitalWrite(ledPin, LOW); } void loop() { blinkLed(ledBlau); blinkLed(ledGruen); blinkLed(ledGelb); blinkLed(ledRot); } Schritt 2 - Erzeugen von Zufallszahlen Die Erzeugung echter Zufallszahlen ist für Computer eine komplexe Aufgabe, da sie dazu neigen, wiederkehrende Muster zu erzeugen oder Werte auf Basis mathematischer Funktionen zu berechnen. Diese Werte sind somit oft vorhersagbar und nicht wirklich zufällig. Mikrocontroller wie der Arduino bieten jedoch eine clevere Lösung für dieses Problem: Durch das Abgreifen eines Startwertes (Seed) von einem ungenutzten analogen Pin – zum Beispiel A0 – können wir eine unvorhersehbare Datenquelle nutzen. Der analoge Pin liefert durch elektrische Rauscheffekte stets leicht variierende Werte, die wir als Grundlage für echte Zufallszahlen in einer definierten Range (Bereich) verwenden können. Auf diese Weise wird das Verhalten des Spiels jedes Mal einzigartig und authentisch zufällig. Da wir in diesem Spiel lediglich eine Range von 0 bis 4 verwenden (entsprechend der Farben Blau, Grün, Gelb und Rot), besteht die Möglichkeit, dass eine Zahl mehrfach hintereinander generiert wird. Um dies zu verhindern, habe ich die Funktion generateUniqueRandomNumber erstellt. Diese überprüft, ob die neu generierte Zahl bereits zuvor verwendet wurde. Falls dies der Fall ist, ruft sich die Funktion selbst erneut auf, bis eine eindeutige, noch nicht genutzte Zahl gefunden wird. So bleibt die Sequenz abwechslungsreich und die Herausforderung für den Spieler erhalten. int lastRandomNumber = -1; void setup() { Serial.begin(9600); randomSeed(analogRead(0)); } int generateUniqueRandomNumber() { int randNumber = random(0, 4); if (randNumber != lastRandomNumber) { lastRandomNumber = randNumber; return randNumber; } return generateUniqueRandomNumber(); } void loop() { Serial.println(generateUniqueRandomNumber()); delay(500); } Die ermittelten Zufallszahlen werden in diesem kleinen Sketch im seriellen Monitor der Arduino IDE ausgegeben.

Schritt 3 - Abspeichern von Zufallszahlen in Arrays In Arrays kannst du gleichartige Daten speichern, die Größe des Arrays ist am Mikrocontroller nur durch den vorhandenen Speicher begrenzt. In meinem Fall lege ich eine größe von 10 fest. Damit kann der Spieler bist maximal Level 10 spielen. Derzeit belegt das gesamte Spiel auf einem Arduino UNO R3 31% des Speicherplatzes für Globale Variablen du kannst also diesen Wert von 10 auf 60 erhöhen! (Angenommen der Benutzer schafft es dann auch 60 folgen von LEDs sich zu merken :) ) Der Sketch verwendet 9382 Bytes (29%) des Programmspeicherplatzes. Das Maximum sind 32256 Bytes. Globale Variablen verwenden 640 Bytes (31%) des dynamischen Speichers, 1408 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes. Das derzeitige Level wird über eine 4fach 14 Segmentanzeige visualisiert. Für diese Anzeige verwende ich die Bibliothek Adafruit LED Backpack welche ich bereits im Beitrag Arduino Lektion #108: 14 Segmentanzeige verwendet habe. #include #include "Adafruit_LEDBackpack.h" #define ledBlau 2 #define ledGruen 4 #define ledGelb 6 #define ledRot 8 int lastRandomNumber = -1; int leds = { ledBlau, ledGruen, ledGelb, ledRot }; int level = 1; int sequenz = {}; Adafruit_AlphaNum4 alpha4 = Adafruit_AlphaNum4(); void setup() { Serial.begin(9600); randomSeed(analogRead(0)); pinMode(ledBlau, OUTPUT); pinMode(ledGruen, OUTPUT); pinMode(ledGelb, OUTPUT); pinMode(ledRot, OUTPUT); alpha4.begin(0x70); alpha4.setBrightness(15); } void generateSequenz() { Serial.println("generateSequenz"); for (int index = 0; index sequenz = leds; } } void playSequenz() { Serial.println("playSequenz"); for (int index = 0; index int ledPin = sequenz; blinkLed(ledPin); } } void blinkLed(int ledPin) { digitalWrite(ledPin, HIGH); delay(150); digitalWrite(ledPin, LOW); } int generateUniqueRandomNumber() { int randNumber = random(0, 4); if (randNumber != lastRandomNumber) { lastRandomNumber = randNumber; return randNumber; } return generateUniqueRandomNumber(); } void displayLevel() { String msg = (level alpha4.writeDigitAscii(0, msg.charAt(0)); alpha4.writeDigitAscii(1, msg.charAt(1)); alpha4.writeDigitAscii(2, msg.charAt(2)); alpha4.writeDigitAscii(3, msg.charAt(3)); alpha4.writeDisplay(); } void loop() { displayLevel(); generateSequenz(); playSequenz(); delay(150); level++; if (level > 10) { level = 1; } } Schritt 4 - Erzeugen von Tönen mit einem Piezo Buzzer Über den Piezo Buzzer kannst du nicht nur einfache Töne sondern auch kleine Lieder abspielen (siehe Weihnachtsevent 2019 im JFZ Schöningen – “Löten eines Weihnachtsbaums mit Sound”). In diesem Spiel nutzen wir diesen als Startsignal für den Spieler damit dieser die zuvor abgespielte Sequenz wiederholt. #define piezoBuzzerPin 13 void setup() { pinMode(piezoBuzzerPin, OUTPUT); } void loop() { tone(piezoBuzzerPin, 1400, 75); delay(500); tone(piezoBuzzerPin, 500, 75); delay(500); } Das kleine Beispiel spielt auf dem Piezo Buzzer zwei Töne ab, einer mit der Frequenz von 1400 Herz und ein anderer mit 500 Herz. (Je höher die Herz desto höher ist der Ton.) Zwischen diesen beiden Tönen wird eine Pause von 500 Millisekunden eingelegt. Das fertige Spiel Nachfolgend findest du das fertige kleine Spiel als ZIP-Datei zum download. Spiel: Color Memory am Arduino UNOHerunterladen Hier der komplette Quellcode #include #include #include "Adafruit_LEDBackpack.h" #define ledBlau 2 #define tasterBlauPin 3 #define ledGruen 4 #define tasterGruenPin 5 #define ledGelb 6 #define tasterGelbPin 7 #define ledRot 8 #define tasterRotPin 9 #define piezoBuzzerPin 13 Bounce tasterBlau = Bounce(); Bounce tasterGruen = Bounce(); Bounce tasterGelb = Bounce(); Bounce tasterRot = Bounce(); const int BOUNCE_INTERVAL = 5; int leds = { ledBlau, ledGruen, ledGelb, ledRot }; int level = 1; bool generateRandomSequenz = false; int sequenz = {}; int userValues = {}; int btnCounter = 0; Adafruit_AlphaNum4 alpha4 = Adafruit_AlphaNum4(); void setup() { Serial.begin(9600); pinMode(ledBlau, OUTPUT); pinMode(ledGruen, OUTPUT); pinMode(ledGelb, OUTPUT); pinMode(ledRot, OUTPUT); tasterBlau.attach(tasterBlauPin, INPUT_PULLUP); tasterBlau.interval(BOUNCE_INTERVAL); tasterGruen.attach(tasterGruenPin, INPUT_PULLUP); tasterGruen.interval(BOUNCE_INTERVAL); tasterGelb.attach(tasterGelbPin, INPUT_PULLUP); tasterGelb.interval(BOUNCE_INTERVAL); tasterRot.attach(tasterRotPin, INPUT_PULLUP); tasterRot.interval(BOUNCE_INTERVAL); pinMode(piezoBuzzerPin, OUTPUT); randomSeed(analogRead(0)); alpha4.begin(0x70); alpha4.setBrightness(15); generateRandomSequenz = true; } int lastRandomNumber = -1; int generateUnqueRandomNumber() { int randNumber = random(0, 4); if (randNumber != lastRandomNumber) { lastRandomNumber = randNumber; return randNumber; } return generateUnqueRandomNumber(); } void generateSequenz() { Serial.println("generateSequenz"); for (int index = 0; index sequenz = leds; } } void playSequenz() { Serial.println("playSequenz"); for (int index = 0; index int ledPin = sequenz; blinkLed(ledPin); tone(piezoBuzzerPin, 1400, 75); } } void blinkLed(int ledPin) { digitalWrite(ledPin, HIGH); delay(500); digitalWrite(ledPin, LOW); } void recordUserSequenz() { tasterBlau.update(); tasterGruen.update(); tasterGelb.update(); tasterRot.update(); if (tasterBlau.rose()) { blinkLed(ledBlau); userValues = ledBlau; btnCounter++; } if (tasterGruen.rose()) { blinkLed(ledGruen); userValues = ledGruen; btnCounter++; } if (tasterGelb.rose()) { blinkLed(ledGelb); userValues = ledGelb; btnCounter++; } if (tasterRot.rose()) { blinkLed(ledRot); userValues = ledRot; btnCounter++; } } void blinkAll() { for (int index = 0; index digitalWrite(ledBlau, HIGH); digitalWrite(ledGruen, HIGH); digitalWrite(ledGelb, HIGH); digitalWrite(ledRot, HIGH); delay(175); digitalWrite(ledBlau, LOW); digitalWrite(ledGruen, LOW); digitalWrite(ledGelb, LOW); digitalWrite(ledRot, LOW); delay(175); } } void displayLevel() { String msg = "000" + String(level, DEC); alpha4.writeDigitAscii(0, msg.charAt(0)); alpha4.writeDigitAscii(1, msg.charAt(1)); alpha4.writeDigitAscii(2, msg.charAt(2)); alpha4.writeDigitAscii(3, msg.charAt(3)); alpha4.writeDisplay(); } void loop() { displayLevel(); if (generateRandomSequenz) { if (level == 10) { level = 0; } generateSequenz(); playSequenz(); generateRandomSequenz = false; } else { recordUserSequenz(); } if (btnCounter == level) { btnCounter = 0; generateRandomSequenz = true; for (int index = 0; index int seqValue = sequenz; int userValue = userValues; if (seqValue != userValue) { level = 1; blinkAll(); tone(piezoBuzzerPin, 500, 125); Serial.println("Verloren!"); return; } } Serial.println("Gewonnen!"); level++; } }

Abschluss & Fazit

Beim Stöbern auf aliexpress.com bin ich auf ein kleines Board mit dem Schieberegister 74HC164D gestoßen und musste es einfach haben. Das kompakte Modul ermöglicht es, auf einfache Weise die Anzahl der digitalen Ausgänge von besonders kleinen Mikrocontrollern zu erweitern. https://youtu.be/OAiC-GjX6jo Es gibt dieses Schieberegister auch als einfachen Baustein wie das Model 74HC959 jedoch finde ich die Variante auf einer Platine etwas besser, weil man dort gleich die Pinbeschriftungen vorliegen hat.

Das kleine Board findest du auch über die Bezeichnung CJMCU-164 auf diversen Plattformen, dazu jedoch später mehr.

Bezug eines Schieberegisters 74HC164D

Das kleine Modul bekommst du neben wie erwähnt auf aliexpress.com auch auf ebay.de* dort jedoch zu einem deutlich höheren Preis. ebay.dealiexpress.comandroegg.de4,87 €*0,96 € (3,62 €)2,87 € (1,64 €) Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Lieferumfang Zum Lieferumfang des Boards gehört neben der kleinen fertig bestückten Platine noch zwei Stiftleisten, welche wir links und rechts anlöten müssen.

Aufbau des Boards CJMCU-164

Das Board verfügt über 8 Ausgänge, an welche wir zum Beispiel digitale Anzeigen oder LEDs anschließen können. Für die Verbindung mit dem Mikrocontroller benötigen wir lediglich vier Pins. (kein SPI oder I2C!)

CJMCU-164 / Schieberegister 74HC164D Da dieses Board nicht über I2C oder SPI angeschlossen wird, haben wir diese Pins weiterhin für andere Sensoren / Aktoren zur Verfügung (was bei I2C nicht so schlimm wäre). Features Vom Hersteller habe ich nachfolgende Features entnommen: - 8-Bit Seriell-Eingang, Parallel-Out Shift - 2,54 mm Rastermaß-Anschluss - Breiter Betriebsspannungsbereich von 2 V bis 6 V - Niedriger Stromverbrauch: maximal 80 μA ICC - Geringer Eingangsstrom: maximal 1 μA Dank des weiten Spannungsbereichs von 2 bis 6 V lässt sich das Bauteil sowohl mit 3,3 V als auch mit 5 V betreiben. Dadurch kann es problemlos mit Mikrocontrollern wie dem ESP8266 und ESP32 verwendet werden, die in der Regel nur 3,3 V bieten.

Anschluss des Boards an den Arduino Nano V3

Das Board inkl. Schieberegister wird mit vier Breadboardkabel mit dem Mikrocontroller verbunden. Nachfolgend siehst du eine kleine Schaltung, in welche ich zusätzlich noch eine 7 Segmentanzeige integriert habe.

PinArduino Nano V3VCC5VGNDGNDAdigitaler Pin D2B5VCLKdigitaler Pin D3CLR5V Die 7 Segmentanzeige wird wie folgt mit dem Board CJMCU-164 verbunden:

7Segmentanzeige Pinout PinFarbeCJMCU-1647LilaQ06HellblauQ14BraunQ22RotQ31GrünQ49DunkelblauQ510TürkisQ6DPdunkles LilaQ78Schwarz220 Ohm Widerstand > GND

Programmieren des Schieberegisters 74HC164D in der Arduino IDE am Arduino Nano V3

Der Arduino Nano V3 ist schon etwas in die Jahre gekommen, aber trotzdem finde ich, dass dieser für kleine Projekte immer noch gut zu verwenden ist. Du kannst die nachfolgende Schaltung aber auch mit anderen Mikrocontrollern wie dem Arduino UNO, Arduino Mega usw. nachstellen, da hier lediglich die normalen digitalen Pins verwendet werden. Für die Anzeige eine Zahl muss eine LED in der 7 Segmentanzeige aktiviert werden. Dazu wurde ein 8-stelliges Array angelegt, in welchem eine 1 eine aktive LED und eine 0 eine entsprechend deaktivierte LED repräsentiert. { 1, 1, 1, 1, 1, 1, 0, 0 }, //Zahl 0 Du kannst aber nicht nur Zahlen, sondern auch begrenzt Buchstaben mit dieser Matrix erstellen. { 1, 1, 1, 0, 1, 1, 1, 0 }, //Buchstabe A

Das Keyestudio Max Board ist schon einige Zeit auf dem Markt erhältlich. In diesem Beitrag möchte ich dir diesen Mikrocontroller vorstellen und zeigen wie du das kleine Spiel "Fang den Regentropfen" auf diesen programmierst. https://youtu.be/P-QlaSB29pI Der Preis mit knapp 25 € für diesen Mikrocontroller hat mich bisher eher abgeschreckt, da dieser zwar ein paar nette Features hat, aber wie ich finde dieses nun nichts Besonderes mehr sind. Auf aliexpress.com habe diesen jetzt für weit unter 20 € gefunden und das hat mich doch verleitet diesen zu kaufen.

Features des Keyestudio Max Board

Der Mikrocontroller im Format des normalen Arduino UNO R3 verfügt über nachfolgende Features: - USB-Typ-C Buchse, - DC / Batterie Anschluss (PH2.0), - zwei Taster, - zwei RGB LEDs, - drei farbige SMD LEDs (gelb, grün, rot), - einen Piezo Buzzer, - ein Mikrofon, - einen Fotowiderstand - eine 8x16 rote LED Matrix

Pinout des Mikrocontrollers

Die vorhandenen Komponenten auf dem Board schränken jedoch die Verwendung der digitalen Pins ein. Daher werfen wir gleich mal einen Blick auf das Pinout, sodass wir die freien Pins im Blick haben.

KomponentePin8x16 LED MatrixI2C, A4 & A5MikrofonA7FotowiderstandA6Taster RECHTSD2Taster LINKSD3RGB LED LINKSD4RGB LED RECHTSD9SMD LED RotD8SMD LED GrünD10SMD LED GelbD13 Über den 4fach DIP Schalter kann man sich zumindest vier der belegten digitalen Pins wieder "freischalten" und somit wie gewohnt über die Buchsenleisten abgreifen. Pin1D32D43A54A4 Technische Daten des ATmega328P-PU Auf dem Mikrocontroller arbeitet ein ATmega328P-PU welcher nachfolgende technische Daten hat: MikrocontrollerATmega328P-PUTaktgeschwindigkeit16 MHzBetriebsspannung5VEingangsspannung7 bis 12V DCdigitale Pins14, davon 6 als PWManaloge Pins6max. Stromaufnahme an den Pins20 mAmax. Stromaufnahme an 3.3V50 mASpeicher32 kB davon 0,5 kB für den Bootloader reserviert 2 kB SRAM 1 kB EEPROMSchnittstellenUART, I2C, SPIFeaturesLED_BUILTIN an D13

Einrichten des Keyestudio Max Board am PC

Bevor wir mit der Programmierung beginnen können, müssen wir zunächst (soweit noch nicht geschehen) den passenden USB-SERIAL Treiber installieren. Auf dem Board ist ein CP2102 Chip verbaut, in meinem Fall ist dieser nicht installiert (erkennbar am gelben Dreieck im Icon) und ich muss diesen manuell nachinstallieren.

Von der Seite https://www.pololu.com/docs/0J7/all#2 kannst du dir den passenden Treiber als ZIP-Datei für Windows herunterladen.

Programmierung in der Arduino IDE

Die Programmierung erfolgt, wie zu erwarten ist am einfachsten in der Arduino IDE. Auf der offiziellen Seite zu diesem Mikrocontroller beim Hersteller findest du viele Beispiele zu den Features. Nachfolgend möchte ich dir gerne zeigen, wie du das bereits für das Arduino Plug and Make Kit vorgestellte Spiel "Fang den Regentropfen" programmierst. Der Mikrocontroller bringt dazu zwei Taster, die 8x16 LED Matrix sowie den Piezo Buzzer, was dafür optimal ist. (Da alles am Mikrocontroller fest verbaut ist, entfällt hier ein Aufbau der Schaltung, was das ganze nochmal deutlich vereinfacht.) Spiel - "Fang den Regentropfen" am Keyestudio Max BoardHerunterladen Schritt 1 - importieren der benötigten Bibliotheken Zunächst importieren wir die benötigten Bibliotheken. Die Bibliothek für das Ansteuern der LED Matrix bekommen wir vom DropBox Repository von Keyestudio https://fs.keyestudio.com/KS0500 leider musst du dich zuvor dort anmelden, um an diese Ressourcen zu gelangen. Die Bounce2 Bibliothek findest du bequem im internen Bibliotheksverwalter, wenn du nach "Bounce2" suchst. //Einbinden der benötigten Bibliotheken //zum ansteuern der 8x16 LED Matrix #include #include "Keyestudio_LEDBackpack.h" #include "Keyestudio_GFX.h" //zum entprellen der Taster #include Schritt 2 - erzeugen der Objektinstanzen und Felder Für das Spiel benötigen wir einpaar Objektinstanzen wie für die LED Matrix, die Taster etc. Die Koordinaten des Regentropfens sowie der Leiste zum Fangen des selbigen lege ich als globale Variable an, somit muss ich diese nicht durch die Funktionen durchreichen. //Objektinstanz von der Matrix erstellen Keyestudio_8x16matrix matrix = Keyestudio_8x16matrix(); //die beiden Taster sind an //den digitalen Pins D3 & D2 angeschlossen #define buttonLinksPin 3 #define buttonRechtsPin 2 //der Piezo Buzzer ist am digitalen Pin D9 angeschlossen #define buzzer 9 //Objektinstanzen für das entprellen //der Taster mit Bounce erstellen Bounce btnLinks = Bounce(); Bounce btnRechts = Bounce(); //Koordinale für die Leiste zum fangen des Punktes int16_t barXPos = 7; int16_t barYPos = 0; //Koordinate für den Regentropfen int16_t rainDropXPos = 0; int16_t rainDropYPos = 0; //Geschwindigkeit des Spieles //am Anfang legen wir diesen auf 400 fest //dieses repräsentiert einen Wert in Millisekunden long speed = 400; //Zeitpunkt der letzten Ausführung des bewegens eines //Regentropfens auf der LED Matrix long lastAction = -1l; int wonRounds = 0; Schritt 3 - Funktion "setup" Konfigurieren der Matrix, Taster & Buzzer In der Funktion setup starten wir zunächst die Kommunikation mit der LED Matrix und anschließend konfigurieren wir die beiden Taster so das diese über Bounce2 entprellt werden. //beginnen der Kommunikation mit der LED Matrix //via I2C mit der Adresse 0x70 matrix.begin(0x70); //Konfigurieren des entprellens der Taster //verbinden des Pins des Tasters mit dem Objekt btnLinks.attach(buttonLinksPin, INPUT); btnLinks.interval(5); btnRechts.attach(buttonRechtsPin, INPUT); btnRechts.interval(5); //Pin des Piezo Buzzers als Ausgang definieren pinMode(buzzer, OUTPUT); Damit das Spiel gleich startet, setzen wir den Regentropfen an eine Zufällige stelle und zeigen diesen an. //eine Range für die Generierung einer Zufallszahl erstellen randomSeed(analogRead(0)); //setzen der Koordinaten für einen Regentropfen rainDropXPos = 7; rainDropYPos = generateRandomNumber(); //aktualisieren der LED Matrix updateMatrix(); Schritt 4 - Funktion "loop" Auswerten der Taster und Bewegen eines Regentropfens In der Funktion "loop" aktualisieren wir die Taster und werden den jeweiligen Tastendruck aus. //aktualisieren der Button Objekte btnLinks.update(); btnRechts.update(); //Wenn der linke Taster losgelassen wurde, dann... if (btnLinks.rose()) { //die Leiste nach links bewegen moveBar(-1); //aktualisieren der LED Matrix updateMatrix(); } //Wenn der rechte Taster losgelassen wurde, dann... if (btnRechts.rose()) { //die Leiste nach rechts bewegen moveBar(1); //aktualisieren der LED Matrix updateMatrix(); } Am Ende prüfen wir ob die Zeit zwischen den Bewegungen des Regentropfens abgelaufen ist. Würden wir hier mit der Funktion delay arbeiten, so können man wärend der Pause keine der Tasten auswerten. //ermitteln des Zeitpunktes für die nächste Ausführung //der Bewegung des Regentropfens long currentMillis = millis(); if (currentMillis > (lastAction + speed)) { lastAction = currentMillis; moveRainDrop(); updateMatrix(); } Schritt 5 - Funktion "Bewegen der Leiste zum Fangen eines Regentropfens" Wenn eine der beiden Tasten betätigt wurde, dann wird die Funktion moveBar ausgeführt. Zunächst wird ein Ton ausgegeben so das eine akkustische Rückmeldung erfolgt. //Funktion zum bewegen der Leiste zum fangen des Regentropfens //als Parameter wird die Richtung übergeben, //ein Positiver Wert gilt nach rechts und ein negativer nach links void moveBar(int direction) { tone(buzzer, 300, 75); if (direction > 0) { if (barXPos < 15) { barXPos++; } } else { if (barXPos > 0) { barXPos--; } } } Schritt 6 - Funktion "Bewegen eines Regentropfens" Der Regentropfen wird von oben nach unten bewegt wobei unten die Zeile mit dem Index 0 ist und oben 7. Wenn die Zeile des Regentropfens 0 ist dann wird geprüft ob die Leiste sich an der selben Stelle befindet. Wenn diese Runde gewonnen ist dann wird die Geschwindigkeit erhöht und eine neue Runde gestartet und der Wert für wonRounds um eins erhöht. Wenn jedoch die Runde verloren ist, dann werden die gewonnenen Runden angezeigt. //Funktion zum bewegen des Regentropfens UND auswerten //ob die Runde gewonnen oder verloren ist void moveRainDrop() { rainDropXPos--; tone(buzzer, 600, 75); bool startNewGame = false; if (rainDropXPos == 0 && (barXPos == rainDropYPos)) { tone(buzzer, 800, 75); startNewGame = true; speed -= 25; wonRounds++; } else if (rainDropXPos == 0 && (barXPos != rainDropYPos)) { tone(buzzer, 250, 75); startNewGame = true; speed = 400; displayWonRounds(); wonRounds = 0; } if (startNewGame) { rainDropXPos = 7; rainDropYPos = generateRandomNumber(); } }

Schritt 7 - Anzeigen der gewonnenen Runden

Zum schreiben der gewonnenen Runden auf der LED Matrix muss zuvor diese gedreht und der Cursor an eine Position gesetzt werden. Dieses müssen wir jedoch nachdem anzeigen wieder zurücksetzen da dieses globale Einstellungen sind! //Anzeigen der gewonnenen Runden auf der LED Matrix void displayWonRounds() { matrix.setTextSize(1); matrix.setTextWrap(false); matrix.setTextColor(LED_ON); //drehen der Ausrichtung der Matrix matrix.setRotation(1); matrix.clear(); //setzen des Cursors an welchem der Text //geschrieben wird matrix.setCursor(6, 0); matrix.print(String(wonRounds)); matrix.writeDisplay(); delay(1000); //Zurücksetzen des Cursors & der Drehung der Matrix matrix.setCursor(0, 0); matrix.setRotation(0); }

Schritt 8 - Aktualisieren der LED Matrix

Das Keyestudio Max Board ist schon einige Zeit auf dem Markt erhältlich. In diesem Beitrag möchte ich dir diesen Mikrocontroller vorstellen und zeigen wie du das kleine Spiel "Fang den Regentropfen" auf diesen programmierst. https://youtu.be/P-QlaSB29pI Der Preis mit knapp 25 € für diesen Mikrocontroller hat mich bisher eher abgeschreckt, da dieser zwar ein paar nette Features hat, aber wie ich finde dieses nun nichts Besonderes mehr sind. Auf aliexpress.com habe diesen jetzt für weit unter 20 € gefunden und das hat mich doch verleitet diesen zu kaufen.

Features des Keyestudio Max Board

Der Mikrocontroller im Format des normalen Arduino UNO R3 verfügt über nachfolgende Features: - USB-Typ-C Buchse, - DC / Batterie Anschluss (PH2.0), - zwei Taster, - zwei RGB LEDs, - drei farbige SMD LEDs (gelb, grün, rot), - einen Piezo Buzzer, - ein Mikrofon, - einen Fotowiderstand - eine 8x16 rote LED Matrix

Pinout des Mikrocontrollers

Die vorhandenen Komponenten auf dem Board schränken jedoch die Verwendung der digitalen Pins ein. Daher werfen wir gleich mal einen Blick auf das Pinout, sodass wir die freien Pins im Blick haben.

KomponentePin8x16 LED MatrixI2C, A4 & A5MikrofonA7FotowiderstandA6Taster RECHTSD2Taster LINKSD3RGB LED LINKSD4RGB LED RECHTSD9SMD LED RotD8SMD LED GrünD10SMD LED GelbD13 Über den 4fach DIP Schalter kann man sich zumindest vier der belegten digitalen Pins wieder "freischalten" und somit wie gewohnt über die Buchsenleisten abgreifen. Pin1D32D43A54A4 Technische Daten des ATmega328P-PU Auf dem Mikrocontroller arbeitet ein ATmega328P-PU welcher nachfolgende technische Daten hat: MikrocontrollerATmega328P-PUTaktgeschwindigkeit16 MHzBetriebsspannung5VEingangsspannung7 bis 12V DCdigitale Pins14, davon 6 als PWManaloge Pins6max. Stromaufnahme an den Pins20 mAmax. Stromaufnahme an 3.3V50 mASpeicher32 kB davon 0,5 kB für den Bootloader reserviert 2 kB SRAM 1 kB EEPROMSchnittstellenUART, I2C, SPIFeaturesLED_BUILTIN an D13

Einrichten des Keyestudio Max Board am PC

Bevor wir mit der Programmierung beginnen können, müssen wir zunächst (soweit noch nicht geschehen) den passenden USB-SERIAL Treiber installieren. Auf dem Board ist ein CP2102 Chip verbaut, in meinem Fall ist dieser nicht installiert (erkennbar am gelben Dreieck im Icon) und ich muss diesen manuell nachinstallieren.

Von der Seite https://www.pololu.com/docs/0J7/all#2 kannst du dir den passenden Treiber als ZIP-Datei für Windows herunterladen.

Programmierung in der Arduino IDE

Die Programmierung erfolgt, wie zu erwarten ist am einfachsten in der Arduino IDE. Auf der offiziellen Seite zu diesem Mikrocontroller beim Hersteller findest du viele Beispiele zu den Features. Nachfolgend möchte ich dir gerne zeigen, wie du das bereits für das Arduino Plug and Make Kit vorgestellte Spiel "Fang den Regentropfen" programmierst. Der Mikrocontroller bringt dazu zwei Taster, die 8x16 LED Matrix sowie den Piezo Buzzer, was dafür optimal ist. (Da alles am Mikrocontroller fest verbaut ist, entfällt hier ein Aufbau der Schaltung, was das ganze nochmal deutlich vereinfacht.) Spiel - "Fang den Regentropfen" am Keyestudio Max BoardHerunterladen Schritt 1 - importieren der benötigten Bibliotheken Zunächst importieren wir die benötigten Bibliotheken. Die Bibliothek für das Ansteuern der LED Matrix bekommen wir vom DropBox Repository von Keyestudio https://fs.keyestudio.com/KS0500 leider musst du dich zuvor dort anmelden, um an diese Ressourcen zu gelangen. Die Bounce2 Bibliothek findest du bequem im internen Bibliotheksverwalter, wenn du nach "Bounce2" suchst. //Einbinden der benötigten Bibliotheken //zum ansteuern der 8x16 LED Matrix #include #include "Keyestudio_LEDBackpack.h" #include "Keyestudio_GFX.h" //zum entprellen der Taster #include Schritt 2 - erzeugen der Objektinstanzen und Felder Für das Spiel benötigen wir einpaar Objektinstanzen wie für die LED Matrix, die Taster etc. Die Koordinaten des Regentropfens sowie der Leiste zum Fangen des selbigen lege ich als globale Variable an, somit muss ich diese nicht durch die Funktionen durchreichen. //Objektinstanz von der Matrix erstellen Keyestudio_8x16matrix matrix = Keyestudio_8x16matrix(); //die beiden Taster sind an //den digitalen Pins D3 & D2 angeschlossen #define buttonLinksPin 3 #define buttonRechtsPin 2 //der Piezo Buzzer ist am digitalen Pin D9 angeschlossen #define buzzer 9 //Objektinstanzen für das entprellen //der Taster mit Bounce erstellen Bounce btnLinks = Bounce(); Bounce btnRechts = Bounce(); //Koordinale für die Leiste zum fangen des Punktes int16_t barXPos = 7; int16_t barYPos = 0; //Koordinate für den Regentropfen int16_t rainDropXPos = 0; int16_t rainDropYPos = 0; //Geschwindigkeit des Spieles //am Anfang legen wir diesen auf 400 fest //dieses repräsentiert einen Wert in Millisekunden long speed = 400; //Zeitpunkt der letzten Ausführung des bewegens eines //Regentropfens auf der LED Matrix long lastAction = -1l; int wonRounds = 0; Schritt 3 - Funktion "setup" Konfigurieren der Matrix, Taster & Buzzer In der Funktion setup starten wir zunächst die Kommunikation mit der LED Matrix und anschließend konfigurieren wir die beiden Taster so das diese über Bounce2 entprellt werden. //beginnen der Kommunikation mit der LED Matrix //via I2C mit der Adresse 0x70 matrix.begin(0x70); //Konfigurieren des entprellens der Taster //verbinden des Pins des Tasters mit dem Objekt btnLinks.attach(buttonLinksPin, INPUT); btnLinks.interval(5); btnRechts.attach(buttonRechtsPin, INPUT); btnRechts.interval(5); //Pin des Piezo Buzzers als Ausgang definieren pinMode(buzzer, OUTPUT); Damit das Spiel gleich startet, setzen wir den Regentropfen an eine Zufällige stelle und zeigen diesen an. //eine Range für die Generierung einer Zufallszahl erstellen randomSeed(analogRead(0)); //setzen der Koordinaten für einen Regentropfen rainDropXPos = 7; rainDropYPos = generateRandomNumber(); //aktualisieren der LED Matrix updateMatrix(); Schritt 4 - Funktion "loop" Auswerten der Taster und Bewegen eines Regentropfens In der Funktion "loop" aktualisieren wir die Taster und werden den jeweiligen Tastendruck aus. //aktualisieren der Button Objekte btnLinks.update(); btnRechts.update(); //Wenn der linke Taster losgelassen wurde, dann... if (btnLinks.rose()) { //die Leiste nach links bewegen moveBar(-1); //aktualisieren der LED Matrix updateMatrix(); } //Wenn der rechte Taster losgelassen wurde, dann... if (btnRechts.rose()) { //die Leiste nach rechts bewegen moveBar(1); //aktualisieren der LED Matrix updateMatrix(); } Am Ende prüfen wir ob die Zeit zwischen den Bewegungen des Regentropfens abgelaufen ist. Würden wir hier mit der Funktion delay arbeiten, so können man wärend der Pause keine der Tasten auswerten. //ermitteln des Zeitpunktes für die nächste Ausführung //der Bewegung des Regentropfens long currentMillis = millis(); if (currentMillis > (lastAction + speed)) { lastAction = currentMillis; moveRainDrop(); updateMatrix(); } Schritt 5 - Funktion "Bewegen der Leiste zum Fangen eines Regentropfens" Wenn eine der beiden Tasten betätigt wurde, dann wird die Funktion moveBar ausgeführt. Zunächst wird ein Ton ausgegeben so das eine akkustische Rückmeldung erfolgt. //Funktion zum bewegen der Leiste zum fangen des Regentropfens //als Parameter wird die Richtung übergeben, //ein Positiver Wert gilt nach rechts und ein negativer nach links void moveBar(int direction) { tone(buzzer, 300, 75); if (direction > 0) { if (barXPos < 15) { barXPos++; } } else { if (barXPos > 0) { barXPos--; } } } Schritt 6 - Funktion "Bewegen eines Regentropfens" Der Regentropfen wird von oben nach unten bewegt wobei unten die Zeile mit dem Index 0 ist und oben 7. Wenn die Zeile des Regentropfens 0 ist dann wird geprüft ob die Leiste sich an der selben Stelle befindet. Wenn diese Runde gewonnen ist dann wird die Geschwindigkeit erhöht und eine neue Runde gestartet und der Wert für wonRounds um eins erhöht. Wenn jedoch die Runde verloren ist, dann werden die gewonnenen Runden angezeigt. //Funktion zum bewegen des Regentropfens UND auswerten //ob die Runde gewonnen oder verloren ist void moveRainDrop() { rainDropXPos--; tone(buzzer, 600, 75); bool startNewGame = false; if (rainDropXPos == 0 && (barXPos == rainDropYPos)) { tone(buzzer, 800, 75); startNewGame = true; speed -= 25; wonRounds++; } else if (rainDropXPos == 0 && (barXPos != rainDropYPos)) { tone(buzzer, 250, 75); startNewGame = true; speed = 400; displayWonRounds(); wonRounds = 0; } if (startNewGame) { rainDropXPos = 7; rainDropYPos = generateRandomNumber(); } }

Schritt 7 - Anzeigen der gewonnenen Runden

Zum schreiben der gewonnenen Runden auf der LED Matrix muss zuvor diese gedreht und der Cursor an eine Position gesetzt werden. Dieses müssen wir jedoch nachdem anzeigen wieder zurücksetzen da dieses globale Einstellungen sind! //Anzeigen der gewonnenen Runden auf der LED Matrix void displayWonRounds() { matrix.setTextSize(1); matrix.setTextWrap(false); matrix.setTextColor(LED_ON); //drehen der Ausrichtung der Matrix matrix.setRotation(1); matrix.clear(); //setzen des Cursors an welchem der Text //geschrieben wird matrix.setCursor(6, 0); matrix.print(String(wonRounds)); matrix.writeDisplay(); delay(1000); //Zurücksetzen des Cursors & der Drehung der Matrix matrix.setCursor(0, 0); matrix.setRotation(0); }

Schritt 8 - Aktualisieren der LED Matrix

Das coole LCD Keypad Shield gibt es schon sehr lange auf dem Markt und wurde auch auf anderen Seiten schon beschrieben. Dieser Beitrag soll jedoch etwas tiefer gehen und ich möchte dir, nachdem ich den Aufbau und die Programmierung erläutert habe, ein cooles nützliches Projekt mit diesem zeigen. https://youtu.be/4eqaoDKCIZU Ich möchte meinem ehemaligen Abteilungsleiter im Elektroniklabor herzlich danken. Durch die großzügige Möglichkeit, sich bei der Auflösung des Labors zu bedienen, konnte ich unter anderem das LCD Keypad Shield für Arduino erhalten.

Technische Daten

Zunächst zu den technischen Daten des LCD Keypad Shield: HerstellerDF-RobotBetriebsspannung5VAbmessungen80 mm x 58 mmFeatures2x16 Zeilen LCD-Display, 1x Potentiometer zur Regulierung der Hintergrundbeleuchtung, 6 Taster (davon 1 Taster für RESET),

Aufbau des LCD Keypad Shield

Das Shield verfügt über ein 2x16 Zeichen LCD-Display und sechs Tasten, welche mit SELECT, LEFT, UP, DOWN, RIGHT und RST (Reset) beschriftet sind. Zusätzlich hast du ein Drehpotentiometer zum Regulieren der Hintergrundbeleuchtung.

Aufbau des LCD Keypad Shield von DF Robot Das Shield ist fertig aufgebaut auf einer Platine, welche du direkt auf einen Arduino UNO R3 / R4, Leonardo oder Mega 2560 R3 stecken kannst. Du kannst mit zusätzlichen Stiftleisten noch die freien Pins des Mikrocontrollers nach oben führen und so an diese Pins weitere Komponenten (Sensoren, Aktoren) anschließen.

Der Mega 2560 R3 hat deutlich mehr digitale & analoge Pins und somit verbleiben noch weitere für ein eventuelles Projekt mit dem LCD Keypad Shield.

Pinout des LCD Keypad Shield

Bevor wir dieses Shield programmieren können, müssen wir zunächst prüfen, an welche Pins die Taster und das LCD-Display angeschlossen ist. KomponenteArduino UNO R3LCD-DisplayRSD8EnableD9D4D4D5D5D6D6D7D7TasterA0 Analoge Werte der Tasten am LCD Keypad Shield Die Taster sind alle am analogen Pin A0 angeschlossen und liefern beim Betätigen jeweils unterschiedliche Werte. Über diese Werte kann man die betätigte Taste im Code quasi recht einfach erkennen. Tasteranaloger WertSELECT640LEFT409RIGHT0UP99DOWN256 Unterschiede bei Mikrocontrollern Für die Schaltung in diesem Beitrag verwende ich den originalen Arduino UNO R3, dieser ist deutlich wertiger aufgebaut als die einfachen China Klone. Durch die andere Verarbeitung sind auch die Werte, welche die Tasten beim Betätigen liefern etwas anders als wie bei besagten Mikrocontrollern auch China. Getestet habe ich die Werte mit: - dem originalem Arduino UNO R3, - dem Funduino UNO R3, - einem Noname China Klone, - dem Funduino Mega 2560 R3,

Programmieren des LCD Keypad Shield in der Arduino IDE

Die Programmierung erfolgt in der Arduino IDE wobei ich hier die aktuelle Version 2.0.x verwende. Du kannst die nachfolgenden Programme aber auch in der klassischen Version 1.8.x programmieren (welche unter Umständen etwas schneller ist). Schritt 1 - auslesen der Taster Mit nachfolgendem Code lesen wir zunächst die Werte der Tasten aus und geben diese auf der seriellen Schnittstelle aus. #define taster A0 void setup() { Serial.begin(9600); pinMode(taster, INPUT); } void loop() { Serial.println(analogRead(taster)); delay(250); } Das Shield habe ich hier an einen Funduino Mega 2560 angeschlossen und dieser liefert ein paar unterschiedliche Werte für die Tasten (um genau zu sagen, um eins versetzt).

analoge Werte der Tasten am LCD Keyad Shield

Schritt 2 - Programmieren des 2x16 LCD-Display

Wie du ein LCD-Display programmierst, habe ich dir bereits im Beitrag Arduino Lektion 7: LCD Display ansteuern erläutert, hier greife ich zunächst das Beispiel auf und zeige den Text "Hallo Welt!" auf der ersten Zeile und auf der zweiten Zeile die Buchstaben A bis P. #include //Das Display ist wiefolgt mit dem Shield / Mikrocontroller verbunden /** * rs > D8 * enabled > D9 * D4 > D4 * D5 > D5 * D6 > D6 * D7 > D7 **/ LiquidCrystal lcd(8, 9, 4, 5, 6, 7); void setup() { //Das LCD-Display mit 16 Zeichen und 2 Zeilen initialisieren //Die Bibliothek LiquidCrystal kann für viele LCD-Displays verwendet werden! lcd.begin(16, 2); //Erste Zeile mit dem Text "Hallo Welt!" belegen. lcd.print("Hallo Welt!"); //Die zweite Zeile soll mit den Buchstaben A bis P belegt werden. //Dafür legen wir uns eine Variable zeichen an und weisen dieser den Wert //65 zu dieser repräsentiert den ASCII Wert A siehe (https://draeger-it.blog/ascii-tabelle/) int zeichen = 65; for (int i = 0; i < 16; i++) { //Cursor an die Position i (aus der Schleife) und Zeile 1 setzen //die erste Zeile hat den Wert 0 und die zweite 1 lcd.setCursor(i, 1); //die Zahl in ein Charakter umwandeln lcd.print(char(zeichen)); //Die Zahl um eins erhöhen. zeichen++; //eine kleine Pause von 350ms delay(350); } } void loop() { //bleibt leer } Der obige Quellcode erzeugt die Ausgabe von "Hallo Welt!" in der ersten Zeile und die Buchstabenfolge von A bis P in der zweiten Zeile.

Beispiele für das LCD Keypad Shield am Arduino UNO R3

Nachdem ich dir jetzt gezeigt habe wie dieses Shield programmiert wird, möchte ich dir nun ein paar Beispiele aufzeigen welche du damit nachprogrammieren kannst. Beispiel 1- navigieren durch ein Array Mit den Navigationstasten kannst du recht einfach über ein Array navigieren und mit der Taste SELECT die Auswahl bestätigen. Im ersten Beispiel möchte ich dir gerne zeigen wie du durch die Werte eines Arrays navigieren kannst. #include //initialisieren des Displays LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //die Taster sind gemeinsam über den //analogen Pin A0 angeschlossen #define taster A0 //analoge Werte der Taster const int SELECT = 640; const int LEFT = 409; const int RIGHT = 0; const int UP = 99; const int DOWN = 256; //Aufbau des Menüs //maximale Anzahl der Einträge im Array const int NUM_MENU_ITEMS = 4; //aktueller Index int index = -1; //das Menü String menu = { "Eintrag 1", "Eintrag 2", "Eintrag 3", "Eintrag 4" }; //Feld für den Wert des Tasters welcher betätigt wurde. int tasterValue = -1; void setup() { //das LCD-Display hat 2 Zeilen mit maximal 16 Zeichen pro Zeile lcd.begin(16, 2); //der Index ist initial auf -1 gesetzt, //die Funktion displayMenuItem prüft anhand des Indexes und der gegebenen //Richtung welche Einträge angezeigt werden sollen displayMenuItem(true); } void loop() { //auslesen des analogen Wertes, dieser ändert sich je nach Taster tasterValue = analogRead(taster); //prüfen welcher Taster betätigt wurde switch (tasterValue) { case UP: displayMenuItem(false); break; case DOWN: displayMenuItem(true); break; case SELECT: doSomething(); break; } } //Diese Funktion zeigt zwei Daten auf dem LCD-Display an, abhängig //von dem Index und der Richtung welche navigiert werden soll. void displayMenuItem(bool directionDown) { //leeren des Displays lcd.clear(); //Zeile 2 soll den Inhalt "-ENDE-" haben wenn das Ende des Menüs erreicht wurde. String line2 = "-ENDE-"; //Wenn der Wert des Parameters //directionDown Wahr/True ist UND //der Wert vom index kleiner als die maximale Anzahl der Menüeinträge -1 ist, dann... if (directionDown && index < NUM_MENU_ITEMS - 1) { index++; } else if (!directionDown && index > 0) { index--; } //Die erste Zeile enthält den Text aus dem Menü mit dem Wert index. //Der erste Eintrag im Array hat den Eintrag 0! String line1 = menu; //prüfen ob das Ende des Menüs / Arrays erreicht wurde if (index < NUM_MENU_ITEMS - 1) { line2 = menu; } //Anzeigen der Daten auf dem Display lcd.setCursor(0, 0); lcd.print(">" + line1); lcd.setCursor(0, 1); lcd.print(" " + line2); //eine kleine Pause von 250ms um die Taster zu entprellen delay(250); } void doSomething() { //eine kleine Pause von 250ms um die Taster zu entprellen delay(250); } Mit den beiden Tasten UP & DOWN können wir nun durch das Menü navigieren. Die Taste SELECT wurde im Code bereits eingebunden, hat jedoch derzeit noch keine Funktion. Beispiel 2 - Aktivieren / Deaktivieren von LEDs über ein Menü Ein einfaches Beispiel ist das Schalten von LEDs. Im nachfolgenden Beispiel möchte ich vier LEDs über das Menü Aktivieren bzw. Deaktivieren. Statt einer LED kannst du auch ein Relais schalten und somit andere Verbraucher steuern.