#colormemory

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

Grays and Greiges

I’ve been reading about a basic color experiment where you find a white object and look at in a white space under different lighting conditions to begin to sense the range and implications of how diversely we see and perceive deceptively simply named colors like white, how slippery color really is.

That being said, when I was sitting in the kitchen just now, where I do my messier studying, I look out into the living room with natural light coming into the space through a central window. All the walls in the house are painted the same creamy beige color, a very warm grey neutral, and from where I’m sitting, this warm gray color, lit differently, is a paintingful of hues, a bit of my own suburban version of the color experiment I keep reading about.

I tried to take a picture of this color experience to start this post. I’m posting this mostly as a reflection of a color moment. I like the idea of collecting quick color reflections and writing them out here, color being so subjective and connected to the individual that it requires, in some proportion, a written descriptive component to it’s study, perhaps.

Then in thinking about this particular color I’ve lived with in so many of my previous rented homes and apartments, I learned a new color word: greige, defined online as as “a color between beige and gray”. (This could be a whole new research area to explore at some point, so I mention it here, perhaps to save for later investigation.)

In my experience, my domestic rented spaces have generally been dominated by these creamy greiges, warm gray and beige neutrals walls, sometimes called “designer colors” in real estate advertisements, and that is the life color story that I’ve been given as the desirable starting point in home building.  Today I also found these infographics about which colors to paint your house so that it sells, with these greiges dominating the desirable range for economic prosperity.

I’m not attempting to make a statement exactly with these reflections, just collecting this cultural information here, all color related, as I think more about the suburban and its relationship to color and the domestic spaces that dominate our lives and how they relate to color. As I think about how color relates to capitalism, real estate, the most possible profit....

images from top:

view from my kitchen

As part of a cub scout outing I recall, we visited an apple orchard in the fall outside of Detroit in the more hilly countryside (Detroit is table-top flat in Southeastern Michigan).  I recall the apple trees with their greenery, the “millions” of red apples being harvested and processed for juice and cider.  Walking around the surrounding area, some of the trees were in full autumn color: yellows, oranges, reds, browns, some green, with leaves providing a carpet like ground cover in spots. It was all a rich array of color, fall crispness in the air, and highlighted by the hilly terrain which was fascinating as well.  I was perhaps 7 or 8 years old.

I was probably 5, I was having a bad dream someone was chasing me in the dream it was all in black and white. When I woke up I called for my mom in the house & she didn’t come. So I got out of bed and started calling and searching. It was so scary, the house felt like it was black and white. I just remember how everything was devoid of color (probably because it was a night). It sort of felt a little like I hadn’t woke up from the dream as I searched the house for her & realized that she wasn’t there. I walked across the street to a neighbor’s house and knocked on the door. That yellow from her door is the only color is a sea of darkness that I remember. The memory is filled with black and grey and the teeniest sliver of yellow. They ended up finding my mom, she was drinking & smoking at another neighbor’s house. She was so furious with me for making her look bad.

My very first clear memory is from when I was 2 years old an my mom and I went back to Japan for her mother’s (my grandmother’s) funeral.

Because I was so small I don’t remember much distinctly, except for this: my mother was wearing a black kimono with a white crest (and she was crying).

There was also a Buddhist Monk dressed in black sitting on a tatami floor (I remember that smell, but that isn’t chroma).