Arduino-Würfel schütteln

Notwendige Werkzeuge und Maschinen

	Lötkolben (generisch)
	Heißklebepistole (generisch)

Apps und Onlinedienste

	Arduino-IDE
	Autodesk Fusion 360

Über dieses Projekt

Vor ungefähr einem Jahr mein Sohn und Ich gebaut elektronischer Würfel mit einem Arduino und ein paar LEDs. Dies ist immer noch ein ideales Projekt für Anfänger. Wir haben dieses Jahr viel gelernt, also ist es höchste Zeit für ein Update.

Der Würfel ist immer noch ein perfektes Starterprojekt. Die Funktion ist jedem klar und die verschiedenen Bereiche leicht verständlich:Mikrocontroller, einfache Elektronik und Codierung.

Version 2.0

Der Würfel ist auch fantastisch, um noch einen Schritt weiter zu gehen:andere Bereiche zu verknüpfen.

Heute gibt es für fast alles eine fertige Komponente. Dies zeigt sich am besten, wenn Sie nach einem Starter-Kit für einen Arduino oder Raspberry Pi suchen. Komponenten wie LEDs, Taster und jede Art von Sensor sind auf einer Platine aufgebaut und können so mit wenigen Drähten an GPIOs angeschlossen und verwendet werden.

Einfache, aber ausreichende 3D-Drucker gibt es bei ebay für unter 140 €. Nahezu alle Halterungs-, Montage- oder Gehäusevarianten lassen sich damit erstellen.

Es gibt eine Reihe weiterer Möglichkeiten, eigene Projekte zu entwickeln. Ein Beispiel dafür ist unser neuer Würfel 2.0.

Neigungssensoren

Wir setzen die Würfel ganz anders um. Im Inneren arbeitet aus Platzgründen ein Arduino Nano. Es gibt noch einen Ein-Aus-Schalter, aber keine Taste. Das Würfeln erfolgt durch Schütteln des gesamten Würfels.

Dazu werden Neigungssensoren oder Vibrationssensoren verwendet. Sie funktionieren wie ein Knopf. In einem Glasrohr bewegt sich eine Kugel. Trifft es auf die Anschlusskontakte, ist der Stromkreis geschlossen. Dieser manchmal sehr kurze Kontakt wird für ein Signal verwendet.

Die Bewegung der Metallkugel ist beim Schütteln des Sensors recht gut zu hören.

Normalerweise ist die Einbaulage für einen Neigungssensor ausschlaggebend. Es soll bei einer bestimmten Winkelposition ein Signal auslösen. In unserem Fall geschieht dies durch Schütteln des Gehäuses. Hier ist die Situation nicht so wichtig, denn beim Schütteln in jede Richtung wird ein Signal ausgelöst. Zur Sicherheit verwenden wir im Projekt zwei Sensoren, die um 90° versetzt zueinander angeordnet sind. So bekommen wir immer ein zuverlässiges Shake-Signal.

Unterbrechungen

Um beim Wackeln erkennen zu können, müssten in der Skizze die Eingangspins der Neigungssensoren abgefragt werden. Je nachdem, wann dies rechtzeitig passiert und was der Sketch sonst noch leisten muss, besteht jedoch immer die Möglichkeit, dass ein oder mehrere Ereignisse unbemerkt bleiben.

Eine bessere Lösung ist die Verwendung von Hardware-Interrupts. Dies wird durch die Funktion attachInterrupt definiert. Als Parameter wird ein Unterprogramm angegeben, das auf das Signal aufgerufen werden soll.

Der Arduino bietet zwei Hardware-Interrupts:Pins D2 und D3.

Anzeige

Die Anzeige des Würfelbildes könnte natürlich auch wieder mit 7 einzelnen LEDs erfolgen. Interessanter ist es aber auch hier ein fertiges Bauteil zu verwenden.

Unsere Wahl für dieses Projekt ist viel auf einer 8x8 LED-Matrix mit MAX7219 Treiber-IC. Es braucht sehr wenig Platz, kostet nur wenig Geld und ist einfach zu codieren.

Je nachdem wo Sie es kaufen, müssen Sie die Einzelteile zusammenlöten und zusammenbauen. Das ist normalerweise kein Problem. Der einzige Fehler, der gemacht werden kann, besteht darin, die LED-Matrix verdreht in die Buchsen zu stecken.

Dies zeigt das obige Bild. Hier genügt es, die Matrize vorsichtig aus den Buchsen zu ziehen und um 180° zu drehen.

Einige Physik

Die LED-Matrix sollte dabei nicht nur das Würfelbild anzeigen. Es sollte einige Showeffekte bieten. Die sechs Würfelaugen bewegen sich auf der Matrix:Sie prallen von den Kanten ab und verlieren langsam an Geschwindigkeit.

Durch die beiden Neigungssensoren können wir sehen, wie viel geschüttelt wurde. Diese Information geben wir den Würfelaugen als "Geschwindigkeit" für ihre Bewegung.

Einen ähnlichen Effekt verwenden wir auch bei der Anzeige des Würfelergebnisses. Die Augen rollen von ihrer zufälligen Position zu ihrer richtigen Position im Würfelbild.

Netzteil

Zunächst haben wir aus Platzgründen zwei 3V CR2032 Knopfzellen verbaut. Am Anfang sah es auch ganz gut aus. Die Arduino- und LED-Matrix spielte mit und alles funktionierte. Nach einigen Minuten Betrieb bricht jedoch die Leistung der Knopfzellen zusammen.

Wenn Sie das Arduino nach jedem Würfeln ausschalten, können Sie es so verwenden. Das ist nicht perfekt, also legen wir besser zwei AAA-Batterien ein. Diese liefern jedoch nur zusammen 3V. Wir brauchen also noch einen Aufwärtswandler, der die Spannung auf 5V anhebt. Die Verbindung erfolgt weiterhin am VIN-Pin des Arduino.

Gehäusedesign

Die beste Option für ein passendes Gehäuse ist eine eigene Konstruktion und Fertigung per 3D-Druck. Für den Bau gibt es viele Apps. Wir haben Autodesk Fusion 360 für dieses Projekt verwendet. Es hat großartige Funktionen und der 3D-Druck ist gut in die Print Studio-Software integriert. Wenn Sie sich für Autodesk Fusion 360 interessieren, finden Sie einige Anregungen im Blog-Artikel Parametric Enclosures.

Unser Gehäuse besteht aus 3 Teilen:

• Großbuchstaben
• Unteres Gehäuse mit Batteriehalter für AAA-Zellen
• Plexiglas-Abdeckung (muss nicht unbedingt sein)

Noch besser sieht die LED-Matrix mit einer milchigen Plexiglasabdeckung davor aus. Dadurch ist es unmöglich, die ausgeschalteten LEDs zu erkennen und das Bild ist klarer.

Skizze

Zur Steuerung der LED-Matrix wird die LedControl-Bibliothek benötigt. Wenn es noch nicht installiert ist, kann es von arduino.cc heruntergeladen werden https://playground.arduino.cc/Main/LedControl.

Dann machen wir die anderen Variablendefinitionen. Zuerst legen wir fest, wie die Würfelaugen auf der Matrix dargestellt werden. Ein Würfelauge besteht aus 4 LED-Punkten. Im Array wird die obere linke Ecke als X/Y-Koordinate angegeben (-1 bedeutet außerhalb der Anzeige).

int DicePic[8][6][2] ={ … { //1:{4,4}, //1. Punkt {-1,-1}, //2. Punkt {-1,-1}, //3. Punkt {-1,-1}, //. Punkt {-1,-1}, //5. Punkt {-1,-1} //. Punkt }, { //2:{2,2}, //1. Punkt {6,6}, //2. Punkt {-1,-1}, //3. Punkt {-1,-1}, //. Punkt {-1,-1}, //5. Punkt {-1,-1} //. Punkt }, … 

Hier ist natürlich alles möglich. Lassen Sie Ihrer Fantasie freien Lauf. Es muss nicht immer das typische Augenbild sein.

Weitere Hinweise findest du direkt im Code.

Montage

Wir legen unseren Arduino auf eine Steckdosenleiste, als eine Art Schutzschild. Die fünf Kontakte der LED-Matrix werden auf die gleiche Weise angeschlossen. Wenn das Arduino zentriert ist, wird der Platz am besten genutzt. Daher am besten die Pins 5, 6, 7 für CS, CLK und DIN für die Matrix verwenden. Hier müssen dann nur noch die Lötstellen verbunden werden. Die Verbindung zu 5V und GND erfolgt über einen kleinen Jumper.

Auch die beiden Neigungssensoren verbinden wir mit kurzen Drähten. Diese sind mit Pin 2 und 3 und 5V und GND verbunden.

Jetzt kann alles zusammengebaut werden. Das Plexiglas wird zuerst mit Heißkleber fixiert. Das gleiche machen wir mit der LED-Matrix. Ein kleiner Punkt Heißkleber reicht aus.

Als nächstes wird der Ein-/Ausschalter montiert, mit Heißkleber befestigt und mit den entsprechenden Drähten verbunden.

Montage des Netzteils

Das Netzteil ist etwas gebastelt. Je nachdem, welche Optionen und Komponenten Sie haben, können die Kontakte für Plus und Minus entsprechend angepasst werden.

Wir verwenden die Federn und Stifte aus einem gebrauchten Batteriefach. Zur Befestigung an der Unterseite des Gehäuses verwenden wir wieder Drähte und etwas Heißkleber.

Der Aufwärtswandler wird am besten auf die ca. 5V vor der Installation. Dazu muss der Widerstand etwas verdreht werden.

Dann werden Groß- und Kleinschreibung zusammengefügt. Durch die Passung von 0,1 mm ist ein Zusammenstecken ohne weitere Sicherung ausreichend. Und für einen Batteriewechsel können sie sich trotzdem wieder öffnen.

Und dann ist es fertig!

Der Würfelspaß 2.0 kann beginnen!

Was Sie brauchen

• Arduino Nano (oder ESP8266)
• 2 x Neigungssensoren (mit integrierten Widerständen)
• 8x8 LED-Matrix mit MAX7219 IC, SPC
• Steckdosenleiste
• Ein-/Ausschalter
• PCB
• 2 x AAA-Batterien

Weitere Informationen

Wenn Sie mehr lesen möchten, besuchen Sie unsere Website techpluscode.de/arduino-wuerfel-2-0.

Leider ist dieser erweiterte Blog nur auf Deutsch verfügbar;-)

Code

• wuerfel8x8.ino

wuerfel8x8.inoArduino

/*Blog-Artikel:Schüttel-Wrfel mit LED Matrix und Bewegungssimulationhttps://techpluscode.de/schuettel-wuerfel-mit-led-matrix-und-bewegungssimulation/techpluscode.deCopyright 2019 von Thomas Angielsky *///Bibliothek für die Ansteuerung der 8x8 LED-Matrix einbinden//Lib für die 8x8 LED-Matrix einbinden#include "LedControl.h"int PinTiltX =2; // Pin fr Neigungssensor Xint PinTiltY =3; //Pin fr Tiltsensor Y//Pins der LED-Matrix//Pins der LED-Matrixint PinCLK =7; int PinCS =6;int PinDIN =5;LedControl lc =LedControl(PinDIN, PinCLK, PinCS, 1);//Koordinaten der Wrfelaugen in der LED-Matrix//Koordinaten der Würfelpunkte in der LED-Matrixint DicePic[8][ 6][2] ={ { //leere Matrix und Startposition:{9,9}, //1. Punkt {9,8}, //2. Punkt {9,7}, //3. Punkt {9,6}, //. Punkt {9,5}, //5. Punkt {9,4} //. Punkt}, { //:{4,4}, //. Punkt {-1,-1}, //2. Punkt {-1,-1}, //3. Punkt {-1,-1}, //. Punkt {-1,-1}, //5. Punkt {-1,-1} //. Punkt }, { //2:{2,2}, //1. Punkt {6,6}, //2. Punkt {-1,-1}, //3. Punkt {-1,-1}, //. Punkt {-1,-1}, //5. Punkt {-1,-1} //. Punkt }, { //3:{2,6}, //1. Punkt {6,2}, //2. Punkt {4,4}, //3. Punkt {-1,-1}, //. Punkt {-1,-1}, //5. Punkt {-1,-1} //. Punkt}, {//4:{2,2}, //. Punkt {2,6}, //2. Punkt {6,2}, //3. Punkt {6,6}, //. Punkt {-1,-1}, //5. Punkt {-1,-1} //. Punkt }, { //5:{2,2}, //1. Punkt {2,6}, //2. Punkt {6,2}, //3. Punkt {6,6}, //. Punkt {4,4}, //5. Punkt {-1,-1} //. Punkt }, { //6:{2,1}, //1. Punkt {2,4}, //2. Punkt {2,7}, //3. Punkt {6,1}, //. Punkt {6,4}, //5. Punkt {6,7} //. Punkt }, { //Start:{-1,-1}, //. Punkt {-1,-1}, //2. Punkt {-1,-1}, //3. Punkt {-1,-1}, //. Punkt {-1,-1}, //5. Punkt {-1,-1} //. Punkt } };//Variablen der Wrfelaugen:Position, Richtung, Geschwindigkeit fr X und Y//Variablen der Würfel:Position, Richtung, Geschwindigkeit für X und Yfloat DiceXpos[6];float DiceXdir[6];volatile byte DiceXspeed[ 6];float DiceYpos[6];float DiceYdir[6];volatile byte DiceYspeed[6];int DiceValue;unsigned long timestamp;byte Mode;int volatile shakes;int ShakesPerSecond;int step;void InterruptChecks() { //Schttel -Anzahl zhlen //Shakes zählen shakes=shakes+1; //Seriell.println(millis()); timestamp=millis();}void SetSpeedX() { if (Mode==0) { //alle Wrfel in X beschleunigen //Beschleunigungswürfel in X for (int i =0; i <6; i++) { if (DiceXspeed[i]<255) {DiceXspeed[i]=DiceXspeed[i]+5;} } } InterruptChecks();}void SetSpeedY() { if (Mode==0) { //alle Wrfel in Y beschleunigen / /Beschleunigungswürfel in Y für (int i =0; i <6; i++) { if (DiceYspeed[i]<255) {DiceYspeed[i]=DiceYspeed[i]+5;} } } InterruptChecks(); }void ShowLed(int x, int y, bool onoff) {//LED nur anzeigen, wenn im sichtbaren Bereich//show only, when x/y in matrix if ((x<8) and (y<8) and ( x>=0) und (y>=0)) {lc.setLed(0, x, y, onoff); }}void ShowDot(int x, int y, bool onoff) {//Wrfel-Auge anzeigen oder ausblenden//Würfelpunkt anzeigen oder ausblenden ShowLed(x-1, y-1, onoff); ShowLed(x, y-1, anaus); ShowLed(x-1, y, onoff); ShowLed(x, y, onoff);}void ShowDicePic(int value) {//Wurf anzeigen//Show diceboolean done; //alle Punkte von der aktuellen Position aus zur Zielposition von DiceValue bewegen //alle Punkte von der aktuellen Position zum Ziel von DiceValue bewegen for (int i =0; i <6; i++) { DiceXspeed[i]=100; Würfelgeschwindigkeit[i]=100; //Werte fr X berechnen //X-Werte berechnen DiceXdir[i]=0; if (int(DiceXpos[i])>DicePic[value][i][0]) {DiceXdir[i]=-1;} else if (int(DiceXpos[i])DicePic[value][i][1]) {DiceYdir[i]=-1;} else if (int(DiceYpos[i])7) { pos=7; dir=dir*(-1); aufrechtzuerhalten. Wenn (pos<1) {pos=1; dir=dir*(-1); } } // Geschwindigkeit wird pro Schritt langsamer // Geschwindigkeit nimmt mit jedem Schritt ab if (sp>
0) {sp=sp-1;}}void MoveDots() { //alle Wrfel einen Schritt weiter bewegen // Würfelpunkte einen Schritt verschieben weiter for (int i =0; i <6; i++) { //neue Koordinaten berechnen //neue Koordinaten berechnen DoStep(DiceXpos[i],DiceXdir[i],DiceXspeed[i],true); DoStep(DiceYpos[i],DiceYdir[i],DiceYspeed[i],true); } //Wrfel-Augen anzeigen //Würfelpunkte anzeigen lc.clearDisplay(0); for (int i =0; i <6; i++) { ShowDot(int(DiceXpos[i]), int(DiceYpos[i]), true); } }void setup() { //Der MAX7219 ist beim Starten im Stromsparmodus, //er muss aufgeweckt werden. //Der MAX7219 befindet sich beim Start im Energiesparmodus, //wir müssen einen Weckruf ausführen lc.shutdown(0, false); //Helligkeit auf einen Mittelwert //Setze die Helligkeit auf einen mittleren Wert lc.setIntensity(0, 8); //und Display lschen //und Display löschen lc.clearDisplay(0); randomSeed (analogRead (0)); Würfelwert=0; für (int i =0; i <6; i++) { DiceXpos[i]=DicePic[7][i][0]; WürfelYpos[i]=WürfelPic[7][i][1]; WürfelXdir[i]=zufällig(3)-1; WürfelYdir[i]=zufällig(3)-1; WürfelXspeed[i]=zufällig(126)+120; Würfelgeschwindigkeit[i]=zufällig(126)+120; } //Pins einstellen //Pins einstellen pinMode(PinTiltX, INPUT_PULLUP); pinMode (PinTiltY, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(PinTiltX),SetSpeedX,CHANGE); attachInterrupt(digitalPinToInterrupt(PinTiltY),SetSpeedY,CHANGE); lc.clearDisplay(0); Zeitstempel=Millis(); Modus=1; ShowDicePic(6); Verzögerung (1000); lc.clearDisplay(0); Modus=0; Serial.begin (9600); Schritt =0; shakes=0;}void loop () { delay (50); Schritt=Schritt+1; if (step>
20) { // sek ist vorbei // sek ist vorbei step=0; ShakesPerSecond=shakes; schüttelt =0; } if (Modus==0) ​​{ MoveDots(); if (millis()-timestamp>
2000) { //seit 2 sek kein Schütteln mehr //es zittert seit 2 sek Mode=1; Würfelwert=zufällig(6)+1; ShowDicePic(Würfelwert); } } if (ShakesPerSecond>5) { //Es wird wieder geschttelt //wieder schütteln Mode=0; }}

Kundenspezifische Teile und Gehäuse

Schaltpläne