Arduino Bingo-Maschine mit 7-Segment-Displays im A4-Format zum Selbermachen

Notwendige Werkzeuge und Maschinen

Über dieses Projekt

Bei einem Gang durch einen ACTION Store entdeckte ich eine digitale LED-Reise zu einem akzeptablen Preis (inklusive 12V Netzteil und sogar inklusive Controller mit IR-Fernbedienung). Ich beschloss, einen zu kaufen und fing an, damit zu spielen, mit dem Ziel, den LED-Streifen in meinem Fall mit einem Arduino Uno zu steuern.

Obwohl weder auf der Verpackung noch auf dem LED-Streifen selbst angegeben, fand ich bald heraus, dass es sich um eine Art Streifen mit Segmenten von drei 5050 LEDs mit einem WS2811-Treiber pro 3 LEDs handelte.

Ich habe den Streifen an ein Arduino Uno angeschlossen, um mit der Adafruit NeoPixel-Bibliothek und einigem Beispielcode wie RGBW-Strandtest damit zu experimentieren.

Ich fing an, ein Brainstorming zu machen und kam auf die Idee, diese Fahrten für die Erstellung einer 7-Segment-Anzeige im A4-Format zu verwenden. Sieben Streifenabschnitte, wie oben gezeigt, würden die Aufgabe erfüllen, plus ein zusätzlicher für den Dezimalpunkt auf dem Display. Dies macht es effektiv 8 Segmente, die von nur einem Ausgangspin des Arduino gesteuert und mit dem 12 V-Adapter versorgt würden, der bereits im ACTION-Paket enthalten ist.

Aber was kann man mit nur einer 7-Segment-Anzeige machen?

Ich habe mich entschieden, 2 davon zu machen und sie zum Erstellen einer Bingo-Maschine . zu verwenden Anzeige von Zufallszahlen zwischen 1 und 75 auf Knopfdruck.

Schritt 1:Erstellen der 7-Segment-Anzeigen

Der gesamte Herstellungsprozess der Displays ist eine ziemlich lange Geschichte, die ich in einem separaten Tutorial beschreiben könnte. Die kurze Version der Herstellung lautet wie folgt:

Beide Displays im A4-Format wurden mit herkömmlichen Mitteln und Materialien hergestellt. Bei der Verwendung von Laserschneidern und 3D-Druckern wäre der gesamte Prozess anders und vielleicht einfacher. Im Internet findet man ziemlich gute Beispiele, z.B. YouTube (https://learn.adafruit.com/ninja-timer-giant-7-segment-display/overview) und Sie können sie sogar fertig kaufen.

Ich fand es eine Herausforderung und hat Spaß gemacht, sie selbst zu machen..

Für die LED-Streifen habe ich 16 Abschnitte von 3 LEDs verwendet, die jeweils aus dem WS2811 LED-Streifen von ACTION geschnitten wurden.

Diese Segmente werden durch Lötdrähte mit +12V, GND und Do und Di der Streifen verbunden. Im Internet finden Sie viele Tutorials, wie Sie dies richtig machen.

Für das Gehäuse habe ich ein leicht erhältliches und erschwingliches Peg Board aus dem örtlichen ACTION-Laden verwendet.

Die neuen Fronten des Gehäuses wurden aus weißem transluzentem Schneidebrettmaterial von IKEA gefertigt.

Mit einer Schablone wurden die Segmente aus einer lackierten Schicht auf die Platten geschnitten (schwarze Grundierung).

Ein billiges Audiokabel (ebenfalls von ACTION) wurde verwendet, um die 7_Segment-Anzeigen mit nur 3 Drähten (12V, GND und Data in) über einen 220Ohm-Widerstand mit dem Arduino zu verbinden.

Ich habe das Gehäuse modifiziert, um ein einfaches Einstecken des Audiosteckers zu ermöglichen.

Schritt 2:Erstellen der Anzeigetafel

Außerdem habe ich beschlossen, eine Scoreboard-Anzeige zu erstellen, die die generierten Zufallszahlen anzeigt, einen Druckknopf zum Generieren einer neuen Zahl und einen "Bingo-Button" zum Beenden und Einleiten einer neuen Runde.

Die Anzeigetafel wird unter Verwendung der gleichen ACTION-Stecktafel als Gehäuse hergestellt (oben beschrieben). Die Deckplatte besteht aus einem dunkelgrauen Schneidebrett (wieder von ACTION) mit gebohrten Löchern wie oben zu sehen. Die obere Abdeckung besteht aus einem IKEA Schneidebrett. Zwischen den 2 Schichten befindet sich ein Druck auf Fotopapier und eine transparente Schutzfolie.

Im Inneren, gegen die Rückseite des Schneidebretts geklebt, befinden sich 5 Abschnitte mit jeweils 15 WS2812-LEDs plus 3 * 8 LED-Streifenabschnitte zur Hinterleuchtung des Wortes "BINGO".

Schritt 3:Erstellen der Software

Die ersten Experimente mit der Codierung und dem Spielen mit dem LED-Streifen und den 7-Segment-Anzeigen wurden mit einem Arduino und einem lötfreien Steckbrett durchgeführt.

Ein großer Taster wird an GND und an Digital IO Pin 2 des Uno angeschlossen. Durch Drücken der Taste wird die Generierung einer neuen Zufallszahl gestartet. Nach einer kurzen „Light Show 1“ wird die Zufallszahl auf den beiden 7-Segment-Anzeigen angezeigt.

Die zum Erstellen von Zahlen auf den 7-Segment-Anzeigen verwendete Tabelle lautet wie folgt:

Um den Arduino Sketch zu strukturieren, habe ich mit ClickCharts einige einfache Flussdiagramme erstellt, eine kostenlose Version für den nicht-kommerziellen Gebrauch (funktioniert gut, wenn man sich an einige inhärente Einschränkungen gewöhnt hat)

Die generierte Zahl wird in einem Array namens SCORE[] gespeichert, das aus 75 Stellen besteht, die entweder mit "0" oder "1" gefüllt sind. Falls die generierte neue Zahl bereits existiert, wird automatisch eine neue Zufallszahl generiert.

Die neue Zahl wird auf der Anzeigetafel (mit 75 Zahlen) beleuchtet und gleichzeitig wird die neue Zahl auf den 7-Segment-Anzeigen angezeigt

Die Anzeigetafel zeigt weiterhin alle generierten Zufallszahlen an, bis ein gültiges Bingo erreicht ist. Ein Druckknopf namens "BINGO" beendet die Runde mit einer kurzen "BingoLightShow"

Danach wird das SCORE-Array gelöscht und eine neue Runde kann gestartet werden.

Eine neue Runde kann auch durch Umschalten des Netzschalters (Trennen der 12-V-Stromversorgung) gestartet werden, wodurch das Arduino zurückgesetzt und das Programm neu gestartet wird.

Schritt 4:Die Elektronik

Ein 12V, 2A Ladegerät versorgt die komplette Bingomaschine mit Strom.

Der 12-V-Eingang an der Arduino-Strombuchse wurde modifiziert, um das Schalten der Stromversorgung zu ermöglichen (ein - aus).

Die 5 V-Leistung für die 99 LEDs (75 + 24), die für die Anzeigetafel verwendet werden, wird mittels eines 7805-Spannungsreglers aus der 12-V-Eingangsleistung abgeleitet (der fast die Stromaufnahme des WS2812-LED-Streifens bewältigen kann); Es wird empfohlen, einen Kühlkörper oder eine Power-Version zu installieren (in einem Update werde ich wahrscheinlich einen Leistungstransistor hinzufügen, um die erforderliche 5V-Leistung zu bewältigen, die hauptsächlich von den 99 WS2812-LEDs in der Anzeigetafel verbraucht wird. Ich habe die Skizze für den Arduino so gemacht dass der Leistungsbedarf der Anzeigetafel moderat ist.

Das Layout in einem Fritzing-Diagramm sieht wie folgt aus:

Beachten Sie, dass sowohl die 7-Segment-LED-Sektionen (12V) als auch die LED-Streifen, die die Zahlen 1-75 auf der Bingo-Anzeigetafel beleuchten, von ein und demselben Ausgangspin (6) des Uno gesteuert werden.

Entwickelt und produziert von Pierre Pennings (November 2018).

Code

• BINGO_Machine_rev04.ino

BINGO_Machine_rev04.inoArduino

/* Dies ist der Code für eine Bingo-Maschine, die von Pierre Pennings entwickelt und produziert wurde (November 2018) Die Maschine verwendet 2 DIGIT großes A4 große 7-Segment-Anzeigen aus WS2811 LED-Streifen mit 12V-Stromversorgung (Paar mit 3 LEDs mit 1 Steuerchip) Jedes Segment bestehend aus 3 LEDs wird mit nur einer Steueradresse adressiert Jedes Display hat 7 Segmente plus einen Dezimalpunkt (DP) Die Zahlen angezeigt auf den 2 Displays laufen von 1 bis 75, wie in einem normalen BINGO-Spiel Ein Taster wird mit GND und mit dem digitalen IO Pin 6 eines ARDUINO UNO verbunden „Light Show 1“ die Zufallszahl wird auf den beiden 7-Segment-Anzeigen angezeigt Die generierte Zahl wird auch in einem Array namens SCORE[] gespeichert, bestehend aus 75 Stellen, die entweder mit „0“ oder „1“ gefüllt sind Wenn die generierte Neue Zahl bereits vorhanden, automatisch eine neue Zufallszahl ber generiert wird Die gesamte Elektronik einschließlich der ARDUINO UNO selbst wurde in einem separaten Score Board Display verbaut Die 75 Zahlen werden mit einem WS2812B Controller Chip mit je einer SMD5050 LED beleuchtet (gespeist mit 5 V) Das Score Board zeigt alle erzeugten Zufallszahlen bis ein gültiges BINGO erreicht wird Ein Druckknopf namens "BINGO" beendet die Runde mit einer kurzen "BingoLightShow". 12V-Strom), der das ARDUINO zurücksetzt und das Programm neu startet Ein 12V, 2A-Ladegerät versorgt die gesamte BINGO-Maschine mit Strom Der 12-V-Eingang an der ARDUINO-Strombuchse wurde modifiziert, um das Ein- und Ausschalten der Stromversorgung zu ermöglichen Die 5-V-Stromversorgung für die 99 LEDs (75 + 24), die für das Score Board verwendet werden, wird aus der 12-V-Eingangsleistung mittels eines 7805-Spannungsreglers abgeleitet (der fast den Strom des WS2812-LED-Streifens verarbeiten kann); die Installation eines Kühlkörpers oder einer Power-Version wird empfohlen Dieser Code ist unter der GPL3+-Lizenz lizenziert.*/#include const int NewnumberButton =2; // Digitaler IO-Pin 2 ist mit einem Schließerkontakt mit der Newnumber-Taste verbunden // Pin 2 wird mit dem eingebauten Pull-up-Widerstand angesteuert, um ihn normalerweise auf HIGH zu stellen // Der Schalter zieht den Pin kurzzeitig auf Masse. // Bei einem High -> Low Übergang durch Drücken der Taste generiert das Programm eine New Number.const int BingoButton =4; // Digitaler IO-Pin 4 ist mit einem Schließerkontakt mit dem BINGO-Knopf verbunden // Pin 4 wird mit dem eingebauten Pull-Up-Widerstand angesteuert, um ihn normalerweise HIGH zu machen // Der BINGO-Knopf zieht den Pin auf Masse/ / Bei einem High -> Low Übergang wird durch Drücken der BINGO-Taste eine Lightshow gestartet und danach das Programm beendet.const int LedPin =6; // Digital IO Pin 6 über einen 220 Ohm Widerstand mit dem Data In (DI) der WS 2811 LED-Streifen verbundenint Newnumber =1;int Bingo =1;int SCORE[76];int count =0;long randNumber;int NUMBER =0;int NW_NUMBER =0;int TENSNUMBER =0;int UNITNUMBER =0;#define NUM_LEDS 99 // die ersten 16 dienen zur Ansteuerung (WS 2811) der LEDs in den 2-stelligen 7-Segment-Anzeigen //(zweimal 8 Segmente auf den beiden Displays); Nummern 0 - 7 sind für die UNIT Nummer // Nummer 8 - 15 sind für die TENS Nummer ( Nummer 7 und 15 sind die DPs jeder DIGIT) // zum Anzeigen der Nummern auf dem Anzeigetafel-Display und zur Steuerung der (WS2812) LEDs die Adressen 16 bis 99 werden verwendet // 24 LEDs werden für die Hinterleuchtung der Buchstaben BINGO und 75 für die Anzeigetafel verwendet, um die Anzeige der generierten BINGO-Nummern zu ermöglichen; // alle LEDs werden mit nur einem Draht angesteuert! ab LED_PIN 6// tatsächlich werden zwei verschiedene Arten von LED-Streifen (parallel) vom selben LedPin 6 über zwei 220 Ohm Widerstände angesteuert#define BRIGHTNESS 250 // setzt die Helligkeit der LEDs auf fast Maximum (255) Adafruit_NeoPixel strip =Adafruit_NeoPixel(NUM_LEDS, LedPin, NEO_GRB + NEO_KHZ800);/*2-dimensionales Array mit NUMBER zu Segmentzuweisungen, jede NUMBER hat ihre eigene Spalte ------------------ ---------------------------------- 8 0 13 9 5 1 14 6 12 10 4 2 11 15 3 7 Ziffer 2 Ziffer 1 Zehner Die Einheiten 7 und 15 repräsentieren die Dezimalpunkte (DP) */// 0 1 2 3 4 5 6 7 8 9 Byte SEGMENTarray [8][10] ={ {1,0,1,1,0 ,1,1,1,1,1,}, //Segment 0 oder 8 {1,1,1,1,1,0,0,1,1,1,}, //Segment 1 oder 9 {1 ,1,0,1,1,1,1,1,1,1,}, //Segment 2 oder 10 {1,0,1,1,0,1,1,0,1,1,}, //Segment 3 oder 11 {1,0,1,0,0,0,1,0,1,0,}, //Segment 4 oder 12 {1,0,0,0,1,1,1, 0,1,1,}, //Segment 5 oder 13 {0,0,1,1,1,1,1,0,1,1,}, //Segment 6 oder 14 {0,0,0, 0,0,0,0,0,0,0,}, //Segment 7 oder 15 };Byte color_scheme[] ={ 50, 100, 200, 100, 150, 250, 150, 200, 50, 200, 250, 100, 250, 50, 150, 0, 100, 200, 50, 150, 250, 100, 200, 0, 150, 250, 50, 200, 0, 100, 250, 50, 200, 0, 100, 250, 50, 150, 0, 250, 0, 0};///////////////////////// ////////////////////////// Der folgende Setup-Code wird einmal nach "Power On" oder nach einem RESETvoid setup() { Serial. beginnen (9600); pinMode (LedPin, AUSGANG); // LedPin 6 als Ausgang initialisieren:pinMode(NewnumberButton, INPUT_PULLUP); // Initialisieren Sie den Druckknopf-Pin 2 als Eingang:pinMode(BingoButton, INPUT_PULLUP); // Bingobutton Pin 4 als Eingang initialisieren:strip.setBrightness (BRIGHTNESS); strip.begin(); // Alle LEDs auf "aus" initialisieren strip.show(); für (int t =16; t <24; t++) { strip.setPixelColor (t, 0, 0, 250); // Nach dem Einschalten das Wort BINGO auf der Anzeigetafel mit blauen Zeichen anzeigen strip.show(); // Beachten Sie, dass die Reihenfolge der Farben des WS2812 LED-Streifens R,G,B ist} for (count =0; count <76; count++) { // setze alle Daten im Array SCORE auf 0 (Array-Positionen laufen von 0 bis 75, die Nullposition wird nicht verwendet) SCORE[count] =0; } /*for (int n =0; n <10; n++) // dieser Code kann zum Testen aller Zahlen von 0 - 9 auf den beiden 7-Segment-Anzeigen verwendet werden (die 2 DPs werden nicht getestet) { for ( int s =0; s <8; s++) { int z =SEGMENTarray [s][n]; int i =0 + s; intj =8 + s; strip.setPixelColor(i, z*250, 0, z*50); strip.setPixelColor(j, z*250, 0, z*50); Strip-Show(); Serial.print("["); Serial.print (n); Serial.print("]"); Serial.print("["); Seriendruck(e); Serial.print("] =");Serial.print(z); Serial.print ( " "); } Verzögerung (1500); Serial.println(); }*/}/////////////////////////////////////////// ///// Der folgende Schleifencode wird wiederholt ausgeführt, bis "Power Off" oder eine RESETvoid-Schleife () { Newnumber =digitalRead (NewnumberButton); if (Newnumber ==LOW) // keine kurze Verzögerung erforderlich, um Prelleffekte des Buttons zu beseitigen, da zuerst LOW die Schleife fortschreitet { randomSeed(millis()); mach { GENERATENEWNUMBER (75); // eine NW_NUMBER zwischen 1 und 75 generieren } // falls die NW_NUMBER bereits existiert:erneut eine NW_NUMBER generieren while (NW_NUMBER ==SCORE[NW_NUMBER] * NW_NUMBER); SCORE[NW_NUMBER] =1; // setze eine 1 in das Array an der NW_NUMBER Position NUMBER =NW_NUMBER; TENSNUMBER =int (ZAHL / 10); // den Dezimalwert der NW_NUMBER und den Einheitswert berechnen UNITNUMBER =NW_NUMBER - (10 * TENSNUMBER); CLEARDISPLAY (); LICHTSHOW1 (4, 100); // starte lightshow1 CLEARDISPLAY (); //DRUCKNUMMERSERIE(); // die generierte NW_NUMBER auf dem seriellen Monitor ausgeben und den neuen Inhalt des SCORE-Arrays anzeigen DISPLAYNUMBER (TENSNUMBER, UNITNUMBER); DISPLAYSCORE (); aufrechtzuerhalten. Sonst { Bingo =digitalRead (BingoButton); if (Bingo ==LOW) Verzögerung (3000); // eine Verzögerung von 3 Sekunden, um Prelleffekte und versehentliches Drücken der Taste zu vermeiden, denn if (Bingo ==LOW) { BINGOLIGHTSHOW (); for (count =0; count <76; count++) // setze alle Daten im Array SCORE zurück auf 0 und eine neue BINGO-Runde kann gestartet werden { SCORE[count] =0; } } }}//////////////////SCHLEIFENENDE //////////////////////// ////////////////////////////////// /////////////// /////////////////////////////////// Folgen Sie im Folgenden den spezifischen Funktionen, die aus dem Loopvoid LIGHTSHOW1 ( int Dauer, uint8_t wait) {for (int t =16; t <24; t++) { strip.setPixelColor(t, 0, 0, 0); // schalten Sie die BINGO-LEDs mit blauen Zeichen aus, wie beim Einrichten von strip.show(); aufrechtzuerhalten. Für (int k =0; k  

Kundenspezifische Teile und Gehäuse

Schaltpläne