Elektronischer Würfel mit Arduino

Mit dem schon beschriebenen LED-Shield hatte ich einen Würfel programmiert, der die geworfene Augenzahl nur als Anzahl der leuchtenden LED darstellte. Schon seit einiger Zeit wollte ich den Würfel optisch etwas besser gestalten, so dass man ihn auch als Würfel erkennen kann. Bei youtube habe ich gesehen, wie Platinen mit der Direkttoner-Methode hergestellt wurden. Da ich dieses Verfahren ausprobieren wollte, bot es sich an, den Würfel in Form eines kleinen Shield’s herzustellen, für dass eine eigene Platine entwickelt werden sollte. Das Shield und die Software möchte ich im Folgenden vorstellen.

Zunächst muss natürlich eine Schaltung her.

Die LED’s, welche später auf dem Shield in Form eines Würfels angeordnet werden, verbindet man mit den Pin’s 7 bis 13 des Arduino. Die LED’s dürfen nicht direkt mit den Ausgängen eines Arduino verbunden werden. Sie müssen jeweils einen Vorwiderstand erhalten. Ich habe 220 Ohm Widerstände gewählt. Wie sich die Vorwiderstände berechnen lassen, habe ich in einem anderen Beitrag schon beschrieben. Dazu ein Schalter, mit dem der jeweilige „Wurf“ gestartet wird.

Nach dem Schaltungsentwurf ist eine Platine zu routen. Diese habe ich mit Fritzing erstellt und manuell ein wenig nachbearbeitet (größere Lötaugen). Wer die Platine für den weiteren Herstellungsprozess in der richtigen Größe ausdrucken möchte sollte sich die folgende PDF-Datei herunterladen .Wuerfel_Platine
Hier ist die fertige Platine zu sehen, die mit der Direkttoner-Methode hergestellt wurde. Wie das funktioniert werde ich mal in einem eigenen Beitrag beschreiben. Obwohl nicht optimal, so ist die Platine für das erste Mal trotzdem schon einigermaßen brauchbar.
Hier nun das fertige Shield, aufgesteckt auf einen Arduino UNO.
… und der Würfel in Aktion

Und hier nun der entsprechende Sketch, der in den Arduino geladen werden muss:

/* ************************************************************************************************************
 *  Elektronische Würfel mit LED-Shield
 * -----------------------------------
 *
 * Mit diesem Programm wird ein Würfel emuliert.
 * Nach dem Drücken des Tasters wird eine Zufallszahl zwischen 1 und 6 ermittelt.
 * Die gewürfelte Augenzahl wird mit 7 LED's die in Form eines Würfels auf einem Shield angeordnet sind dargestellt
 *
 * Grundlage ist ein Shield, dass auf der Homepage des BV Westfalen beschrieben ist
 *  
 * Programmiert im Januar 2017
 * Copyright BV-Westfalen
 * http://www.bv-westfalen.de
 *
 ****************************************************************************************************************/

int Zufallszahl;                                                        // Variable für die Zufallszahl wird definiert
const int Taster = 2;                                                   // Pin an dem der Taster angeschlossen ist
int TasterStatus = 0;                                                   // Definition der Variablen , die den Zustand des Tasters speichert

void setup(){
  randomSeed(analogRead(0));                                            // Initalisierung der Zufallsroutine über einen Meßwert am offenen analogen Eingang 0
  pinMode(13, OUTPUT);                                                  // digitaler Pin wird für Ausgabe festgelegt
  pinMode(12, OUTPUT);                                                  // ... auch die folgenden
  pinMode(11, OUTPUT);         
  pinMode(10, OUTPUT);         
  pinMode(9, OUTPUT);         
  pinMode(8, OUTPUT);         
  pinMode(7, OUTPUT);          
  pinMode(6, OUTPUT);         
  pinMode(Taster, INPUT);                                               // digitaler Port an dem der Taster angeschlossen ist, wird für Eingabe definiert
}

void loop(){
  do
  {
  TasterStatus = digitalRead(Taster);                                   // der Zustand des Tasters wird abgefragt
  delay (20);                                                           // warten wegen prellen des Tasters
  } while (TasterStatus == LOW);                                        // Schleife solange Taster nicht gedrückt
  do
  {
  TasterStatus = digitalRead(Taster);                                   // der Zustand des Tasters wird noch einmal abgefragt
  delay (20);                                                           // warten wegen prellen des Tasters
  } while (TasterStatus == HIGH);                                       // Schleife solange Taster noch gedrückt, erst danach statet der eigentliche Wurf
  for (int x=1; x < 10; x++)                                            // diese For-Schleife simuliert mit einem Durchlauf durch die Leuchtdioden das rollen des Würfels
    {
    for (int LEDPin=13; LEDPin > 6; LEDPin--)                           // start bei PIN 13, und ende bei Pin 7 
     {  
        digitalWrite(LEDPin, HIGH);                                     // schaltet aktuellen Pin ein 
        delay(25);                                                      // Pause fuer 1/40 Sekunde 
        digitalWrite(LEDPin, LOW);                                      // schaltet aktuellen Pin aus
     }
    }
  
   for (int LEDPin=13; LEDPin >= 6; LEDPin--)                           // start bei PIN 13, testet ob Wert größer Pin 6, verringert in jedem Durchlauf um 1
     {  
      digitalWrite(LEDPin, LOW);                                        // schaltet aktuellen Pin aus
     }
   Zufallszahl = random(6)+1;                                           // eine Zufallszhl zwischen 1 und 6 wird erzeugt (gewürfelt)

   switch (Zufallszahl) {                                               // in Abhängigkeit von der Zahl wird auf dem Würfel die Augenzahl dargestellt
    case 1:                                                             // über die Anweisungen Case werden die verschiednen LED entsprechende der Augenzahl eingeschaltet
     digitalWrite(7, HIGH);
      break;
    case 2:   
      digitalWrite(9, HIGH);
      digitalWrite(13, HIGH);
      break;
    case 3:    
      digitalWrite(7, HIGH);
      digitalWrite(8, HIGH);
      digitalWrite(11, HIGH);
      break;
    case 4:   
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      digitalWrite(11, HIGH);
      digitalWrite(13, HIGH);
      break;
    case 5:   
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      digitalWrite(11, HIGH);
      digitalWrite(13, HIGH);
      digitalWrite(7, HIGH) ;
      break;
   case 6:   
      digitalWrite(8, HIGH);
      digitalWrite(9, HIGH);
      digitalWrite(10, HIGH);
      digitalWrite(11, HIGH);
      digitalWrite(12, HIGH);
      digitalWrite(13, HIGH);
      break;
  }
   
}