Arduino dobbelstenen schudden

Over dit project

Ongeveer een jaar geleden mijn zoon en Ik bouwde een elektronische dobbelstenen met een Arduino en een paar LED's. Dit is nog steeds een ideaal project voor beginners. We hebben dit jaar veel geleerd, dus hoog tijd voor een update.

De dobbelsteen is nog steeds een perfect startersproject. De functie is voor iedereen duidelijk en het is gemakkelijk om de verschillende gebieden te begrijpen:microcontroller, eenvoudige elektronica en codering.

Versie 2.0

De dobbelstenen zijn ook fantastisch, om nog een stap verder te gaan:andere gebieden koppelen.

Tegenwoordig is er voor bijna alles een kant-en-klaar onderdeel. Dit zie je het beste als je op zoek bent naar een starterskit voor een Arduino of Raspberry Pi. Componenten zoals LED's, drukknoppen en elk type sensor zijn op een printplaat gebouwd en kunnen dus met slechts een paar draden worden aangesloten en gebruikt op GPIO's.

Eenvoudige, maar voldoende, 3D-printers zijn beschikbaar op ebay voor minder dan 140 €. Vrijwel alle beugel-, montage- of behuizingsvarianten kunnen ermee worden gemaakt.

Er zijn nog een aantal mogelijkheden om je eigen projecten te ontwikkelen. Een voorbeeld hiervan is onze nieuwe dobbelsteen 2.0.

Kantelsensoren

We implementeren de dobbelstenen op een heel andere manier. Binnenin werkt een Arduino Nano om ruimteredenen. Er is nog steeds een aan-uitschakelaar, maar geen knop. Het in blokjes snijden wordt gedaan door de hele kubus te schudden.

Hiervoor worden kantelsensoren of trillingssensoren gebruikt. Ze werken net als een knop. In een glazen buis beweegt een bal. Als het de aansluitcontacten raakt, is het circuit gesloten. Dit contact, soms erg kort, wordt gebruikt voor een signaal.

De beweging van de metalen bal is goed te horen als je de sensor schudt.

Normaal gesproken is de inbouwpositie bepalend voor een hellingssensor. Het wordt verondersteld een signaal te triggeren op een bepaalde hoekpositie. In ons geval gebeurt dit door de behuizing te schudden. Hier is de situatie niet zo belangrijk, omdat bij het schudden in elke richting een signaal wordt geactiveerd. Voor de zekerheid gebruiken we in het project twee sensoren, die 90 ° ten opzichte van elkaar zijn geplaatst. We krijgen dus altijd een betrouwbaar schudsignaal.

Onderbrekingen

Om te kunnen herkennen bij schudden, zouden de invoerpinnen van de kantelsensoren in de schets moeten worden opgevraagd. Afhankelijk van wanneer dit in de tijd gebeurt en wat de schets nog meer moet doen, is er altijd de mogelijkheid dat een of meerdere gebeurtenissen onopgemerkt blijven.

Een betere oplossing is om hardware-interrupts te gebruiken. Dit wordt gedefinieerd door de functie attachInterrupt. Als parameter wordt een subprogramma gespecificeerd dat op het signaal moet worden opgeroepen.

De Arduino biedt twee hardware-interrupts:pinnen D2 en D3.

Weergave

Natuurlijk kan de weergave van het dobbelsteenbeeld weer met 7 individuele LED's worden gedaan. Maar het is ook interessanter om hier een afgewerkt onderdeel te gebruiken.

Onze keuze voor dit project is veel op een 8x8 LED matrix met MAX7219 driver IC. Het neemt zeer weinig ruimte in beslag, kost slechts een klein bedrag en is gemakkelijk te coderen.

Afhankelijk van waar je het koopt, moet je aan elkaar solderen en de losse onderdelen monteren. Dat is normaal gesproken geen probleem. De enige fout die gemaakt kan worden, is om de LED-matrix gedraaid in de aansluitingen te plaatsen.

Dit blijkt uit bovenstaande afbeelding. Hier is het voldoende om de matrix voorzichtig uit de sockets te trekken en 180 ° te draaien.

Wat natuurkunde

De LED-matrix moet daarom niet alleen het dobbelsteenbeeld weergeven. Het zou wat show-effecten moeten bieden. De ogen van de zes dobbelstenen bewegen op de matrix:ze stuiteren tegen de randen en verliezen langzaam snelheid.

Door de twee kantelsensoren kunnen we zien hoeveel er is geschud. Deze informatie geven we de dobbelstenen ogen als "snelheid" voor hun beweging.

Een soortgelijk effect gebruiken we ook bij het weergeven van het dobbelsteenresultaat. De ogen rollen van hun willekeurige positie naar hun juiste positie in het kubusbeeld.

Voeding

Ten eerste hebben we om ruimteredenen twee 3V CR2032-knoopcellen geïnstalleerd. In het begin zag het er ook best goed uit. De Arduino en LED-matrix speelden mee en alles werkte. Na een paar minuten gebruik valt de kracht van de knoopcellen echter uit.

Als je de Arduino na elke dobbelsteen uitzet, zou je hem op die manier kunnen gebruiken. Dat is niet perfect, dus plaatsen we beter twee AAA-batterijen. Deze leveren echter alleen samen 3V. We hebben dus nog een step-up converter nodig, die de spanning opvoert naar 5V. De verbinding vindt nog steeds plaats op de VIN-pin van de Arduino.

Behuizingsontwerp

De beste optie voor een geschikte behuizing is een eigen ontwerp en productie via 3D printen. Er zijn veel apps voor de bouw. Voor dit project hebben we Autodesk Fusion 360 gebruikt. Het heeft geweldige functies en 3D-printen is goed geïntegreerd met de Print Studio-software. Als u geïnteresseerd bent in Autodesk Fusion 360, vindt u enkele suggesties in het blogartikel Parametrische behuizingen (alleen Duits).

Onze behuizing bestaat uit 3 delen:

• Hoofdletters
• Onderbehuizing met batterijhouder voor AAA-cellen
• Plexiglas hoes (hoeft niet per se te zijn)

De LED-matrix ziet er nog beter uit met een melkachtige plexiglasafdekking ervoor. Dit maakt het onmogelijk om de uit-LED's te herkennen en het beeld is helderder.

Schets

Om de LED Matrix aan te sturen is de LedControl bibliotheek nodig. Als het nog niet is geïnstalleerd, kan het worden gedownload van arduino.cc https://playground.arduino.cc/Main/LedControl.

Dan doen we de andere variabele definities. Eerst bepalen we hoe de ogen van de dobbelstenen op de matrix worden weergegeven. Een dobbeloog bestaat uit 4 LED-punten. In de array wordt de linkerbovenhoek gespecificeerd als de X / Y-coördinaat (-1 betekent buiten het scherm).

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

Alles is hier natuurlijk mogelijk. Laat je fantasie de vrije loop. Het hoeft niet altijd het typische oogbeeld te zijn.

Andere opmerkingen vind je direct in de code.

Montage

We zetten onze Arduino op een stekkerdoos, als een soort schildje. De vijf contacten van de LED-matrix zijn op dezelfde manier aangesloten. Als de Arduino gecentreerd is, kan de ruimte het beste worden gebruikt. Daarom is het het beste om pinnen 5, 6, 7 voor CS, CLK en DIN te gebruiken voor de matrix. Hier hoeven dan alleen de soldeerpunten aangesloten te worden. De verbinding met 5V en GND gaat via een kleine jumper.

Ook verbinden we de twee kantelsensoren met korte draden. Deze zijn aangesloten op pin 2 en 3 en 5V en GND.

Nu kan alles worden gemonteerd. Het plexiglas wordt eerst vastgezet met hete lijm. Hetzelfde doen we met de LED-matrix. Een klein puntje hotglue is voldoende.

Vervolgens wordt de aan/uit-schakelaar geïnstalleerd, vastgezet met hotglue en verbonden met de juiste draden.

De voeding monteren

De voeding is een beetje gesleuteld. Afhankelijk van de opties en componenten die u heeft, kunnen de contacten voor plus en min overeenkomstig worden uitgelijnd.

We gebruiken de veren en pinnen uit een gebruikt batterijcompartiment. Om aan de onderkant van de behuizing te bevestigen gebruiken we weer draden en een beetje hotglue.

De step-up boost-converter kan het beste worden afgesteld op de ca. 5V voor installatie. Daarvoor moet de weerstand een beetje verdraaid worden.

Vervolgens worden hoofdletters en kleine letters samengevoegd. Door de pasvorm van 0,1 mm is in elkaar steken zonder verdere borging voldoende. En ze kunnen nog steeds weer open voor een batterijwissel.

En dan is het klaar!

Het dobbelspel 2.0 kan beginnen!

Wat je nodig hebt

• Arduino Nano (of ESP8266)
• 2 x kantelsensoren (met geïntegreerde weerstanden)
• 8x8 LED-matrix met MAX7219 IC, SPC
• Socketstrip
• Aan/Uit-schakelaar
• PCB
• 2 x AAA-batterijen

Meer informatie

Als je meer wilt lezen, kijk dan op onze website techpluscode.de/arduino-wuerfel-2-0.

Sorry, deze uitgebreide blog is alleen beschikbaar in het Duits;-)

Code

• wuerfel8x8.ino

wuerfel8x8.inoArduino

Code voor de schuddende dobbelstenen

/*Blog-Artikel:Schttel-Wrfel mit LED Matrix und Bewegungssimulationhttps://techpluscode.de/schuettel-wuerfel-mit-led-matrix-und-bewegungssimulation/techpluscode.deCopyright 2019 von Thomas Angielsky *///Bibliothek fr die Ansteuerung der 8x8 LED-Matrix einbinden//Include lib voor de 8x8 LED-matrix#include "LedControl.h"int PinTiltX =2; //Pin fr Tiltsensor Xint PinTiltY =3; //Pin fr Tiltsensor Y//Pins der LED-Matrix//Pins van de LED matrixint PinCLK =7; int PinCS =6;int PinDIN =5;LedControl lc =LedControl(PinDIN, PinCLK, PinCS, 1);//Koördinaten der Wrfelaugen in der LED-Matrix//Coördinaten van de dobbelstenen in de LED matrixint DicePic[8][ 6][2] ={ { //leere Matrix en startpositie:{9,9}, //1. Punkt {9,8}, //2. Punkt {9,7}, //3. Punkt {9,6}, //4. Punkt {9,5}, //5. Punkt {9,4} //6. Punkt }, { //1:{4,4}, //1. Punkt {-1,-1}, //2. Punkt {-1,-1}, //3. Punkt {-1,-1}, //4. Punkt {-1,-1}, //5. Punkt {-1,-1} //6. Punkt }, { //2:{2,2}, //1. Punkt {6,6}, //2. Punkt {-1,-1}, //3. Punkt {-1,-1}, //4. Punkt {-1,-1}, //5. Punkt {-1,-1} //6. Punkt }, { //3:{2,6}, //1. Punkt {6,2}, //2. Punkt {4,4}, //3. Punkt {-1,-1}, //4. Punkt {-1,-1}, //5. Punkt {-1,-1} //6. Punkt }, { //4:{2,2}, //1. Punkt {2,6}, //2. Punkt {6,2}, //3. Punkt {6,6}, //4. Punkt {-1,-1}, //5. Punkt {-1,-1} //6. Punkt }, { //5:{2,2}, //1. Punkt {2,6}, //2. Punkt {6,2}, //3. Punkt {6,6}, //4. Punkt {4,4}, //5. Punkt {-1,-1} //6. Punkt }, { //6:{2,1}, //1. Punkt {2,4}, //2. Punkt {2,7}, //3. Punkt {6,1}, //4. Punkt {6,4}, //5. Punkt {6,7} //6. Punkt }, { //Start:{-1,-1}, //1. Punkt {-1,-1}, //2. Punkt {-1,-1}, //3. Punkt {-1,-1}, //4. Punkt {-1,-1}, //5. Punkt {-1,-1} //6. Punkt } };//Variablen der Wrfelaugen:Positie, Richtung, Geschwindigkeit fr X en Y//Variabelen van de dobbelstenen:positie, richting, snelheid voor X en Yfloat DiceXpos[6];float DiceXdir[6];vluchtige byte DiceXspeed[ 6];float DiceYpos[6];float DiceYdir[6];vluchtige byte DiceYspeed[6];int DiceValue;unsigned long timestamp;byte Mode;int vluchtige shakes;int ShakesPerSecond;int step;void InterruptChecks() { //Schttel -Anzahl zhlen // Tel Shakes shakes=shakes+1; //Serial.println(millis()); timestamp=millis();}void SetSpeedX() {if (Mode==0) { //alle Wrfel in X beschleunigen //Versnellingsdobbelstenen in X voor (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 / /Versnel dobbelstenen in Y voor (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) en (y>=0)) { lc.setLed(0, x, y, aanuit); }}void ShowDot(int x, int y, bool onoff) {//Wrfel-Auge anzeigen oder ausblenden//Toon of verberg dobbelstenen ShowLed(x-1, y-1, onoff); ShowLed(x, y-1, aan-uit); ShowLed(x-1, y, aan-uit); 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 //verplaats alle punten van de huidige positie naar de bestemming van DiceValue for (int i =0; i <6; i++) { DiceXspeed[i]=100; DiceYspeed[i]=100; //Werte fr X berechnen //Calc x-waarden 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); } if (pos<1) { pos=1; dir=dir*(-1); } } // Geschwindigkeit wird pro Schritt langsamer // Snelheid neemt bij elke stap af if (sp>
0) {sp=sp-1;}}void MoveDots() { //alle Wrfel einen Schritt weiter bewegen //move dice points one step verder voor (int i =0; i <6; i++) { //neue Koordinaten berechnen //calc nieuwe coördinaten DoStep(DiceXpos[i],DiceXdir[i],DiceXspeed[i],true); DoStep(DiceYpos[i],DiceYdir[i],DiceYspeed[i],true); } //Wrfel-Augen anzeigen //dobbelstenen tonen 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 Power-Saving Modus, //er muss aufgeweckt werden. // De MAX7219 staat in de energiebesparende modus bij het opstarten, // we moeten een wake-up call doen lc.shutdown (0, false); //Helligkeit auf einen Mittelwert //Stel de helderheid in op een gemiddelde waarde lc.setIntensity(0, 8); //und Display lschen //en wis het display lc.clearDisplay (0); randomSeed(analogRead(0)); DiceValue=0; for (int i =0; i <6; i++) { DiceXpos[i]=DicePic[7][i][0]; DiceYpos[i]=DicePic[7][i][1]; DiceXdir[i]=willekeurig (3)-1; DiceYdir[i]=willekeurig (3)-1; DiceXspeed[i]=willekeurig (126)+120; DiceYspeed[i]=willekeurig (126)+120; } //Pins einstellen // Stel de pinnen in pinMode (PinTiltX, INPUT_PULLUP); pinMode (PinTiltY, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(PinTiltX),SetSpeedX,CHANGE); attachInterrupt(digitalPinToInterrupt(PinTiltY),SetSpeedY,CHANGE); lc.clearDisplay(0); tijdstempel=millis(); Modus=1; ShowDicePic(6); vertraging (1000); lc.clearDisplay(0); Modus=0; Serieel.begin(9600); stap=0; shakes=0;}void loop() { delay(50); stap=stap+1; if (stap>
20) { //1 sek ist vorbei //1 sec is voorbij stap =0; ShakesPerSecond=shakes; schudt =0; } if (Modus==0) ​​{ MoveDots(); if (millis()-timestamp>
2000) { //seit 2 sek kein Schtteln mehr //er wordt niet geschud sinds 2 sec Mode=1; DiceValue=willekeurig (6)+1; ShowDicePic(DiceValue); } } if (ShakesPerSecond>5) {//Es wird wieder geschttelt // opnieuw schudden Mode=0; }}

Aangepaste onderdelen en behuizingen

Schema's

Dit is mijn schets voor het circuit.