Créer une Machine à Bingo Arduino Personnalisée avec Afficheurs 7-Segments A4 DIY

Composants et fournitures

Composant	Quantité	Notes
Plaque perforée (Peg Board)	3	Ningbo Wins Handycraft - 2 pour afficheurs 7-segments, 1 pour tableau scores
Planche à découper plastique gris	1	Pour le tableau des scores
Bandeau LED numérique 5m WS2811 (LED 5050)	1	Segments de 3 LED + 1 driver WS2811
Bandeau LED WS2812B 5m 300 LED (60 LED/m, 5050 RGB)	1	Individuellement adressables
Câble audio	1	Connexion tableau scores ↔ afficheurs 7-segments
Planche à découper plastique translucide	2	Faces avant des afficheurs 7-segments
Planche à découper plastique gris flexible	1	Couverture tableau scores
Arduino UNO	1
Résistance 220 Ω	2	Marqué 221 Ω = 220 Ω
Condensateurs 100 µF	2
Gros bouton poussoir (momentané)	1	Nouveau numéro
Petit bouton poussoir (genérique)	1	Bingo
Régulateur linéaire 7805	1	12V → 5V pour scoreboard

Outils nécessaires

• Outils communs et équipement de test (standard pour projets DIY)

À propos de ce projet

En flânant dans un magasin ACTION, j'ai découvert un bandeau LED numérique à prix abordable (avec adaptateur 12V et contrôleur IR). Je l'ai acheté pour l'expérimenter avec un Arduino Uno.

Il s'agit d'un bandeau avec segments de 3 LED 5050 + 1 driver WS2811 par segment (non indiqué sur l'emballage).

Connecté à l'Arduino Uno pour tests avec bibliothèque Adafruit NeoPixel (ex: RGBW strandtest).

Idée : utiliser ces segments pour créer un afficheur 7-segments format A4. 7 segments + 1 point décimal = 8 segments pilotés par 1 seule broche de sortie Arduino, alimentés par l'adaptateur 12V inclus.

Mais que faire avec un seul afficheur ? → J'en ai fait deux pour créer une Machine à Bingo affichant des nombres aléatoires 1-75 à chaque pression du bouton.

Étape 1 : Fabrication des afficheurs 7-segments

Processus complet décrit en détail (pourrait faire un tutoriel à part). Version courte :

• Fabrication conventionnelle (découpe laser / impression 3D possible - voir exemples Adafruit/YouTube)
• Défi personnel et plaisir de les faire soi-même
• 16 segments de 3 LED découpés du bandeau WS2811 ACTION
• Soudure fils +12V, GND, Do, Di entre segments
• Boîtier : Plaque perforée (Peg Board) ACTION
• Faces avant : plastique translucide blanc IKEA + gabarit pour découper segments sur couche peinte (apprêt noir)
• Connexion afficheurs ↔ Arduino : câble audio bon marché (3 fils : 12V, GND, Data in) via résistance 220Ω
• Modification boîtier pour branchement facile connecteur audio

Étape 2 : Fabrication du tableau des scores (Scoreboard)

• Même plaque perforée ACTION pour boîtier
• Plaque de couverture : planche à découper gris foncé ACTION (trous percés)
• Couvercle supérieur : planche IKEA
• Entre les deux : impression sur papier photo + film protecteur transparent
• À l'intérieur, collés au dos de la planche grise : 5 sections de 15 LED WS2812 + 3 sections de 8 LED pour rétroéclairage "BINGO"

Étape 3 : Logiciel

Expérimentations initiales sur breadboard sans soudure.

• Gros bouton momentané → GND + broche D2 (pull-up interne). Pression = nouveau nombre aléatoire
• Après un "Light Show 1", le nombre s'affiche sur les deux afficheurs 7-segments
• Table de correspondance segments/chiffres :

• Flux de logique structuré avec ClickCharts (version gratuite non-commerciale)

• Nombre généré stocké dans tableau SCORE[76] (0 ou 1). Si déjà existant → nouveau tirage auto
• Nombre affiché sur scoreboard (75 positions) + afficheurs 7-segments
• Scoreboard conserve tous les numéros tirés jusqu'au Bingo
• Bouton "BINGO" → fin de manche + "BingoLightShow"
• Réinitialisation tableau SCORE → nouvelle manche
• Nouvelle manche aussi via interrupteur d'alimentation (reset Arduino)

Étape 4 : Électronique

• Alimentation : chargeur 12V 2A pour toute la machine
• Prise alimentation Arduino modifiée pour interrupteur marche/arrêt
• 5V pour 99 LED (75 + 24) du scoreboard via régulateur 7805 (radiateur recommandé ; futur upgrade : transistor de puissance)
• Code optimisé pour consommation modérée du scoreboard

Schéma Fritzing :

Note : Les deux afficheurs 7-segments (12V, WS2811) ET les bandes LED du scoreboard (5V, WS2812) sont pilotés par la même broche de sortie (D6) via deux résistances 220Ω.

Développé et produit par Pierre Pennings (Novembre 2018).

Code

BINGO_Machine_rev04.ino

/* Machine à Bingo - Pierre Pennings (Nov 2018) - Licence GPL3+
 * 2 afficheurs 7-segments géants A4 (WS2811 12V, 3 LED/segment, 1 adresse/segment)
 * 8 segments par afficheur (7 + DP) - adresses 0-7 (unités), 8-15 (dizaines)
 * Nombres 1-75 comme Bingo standard
 * Bouton "Nouveau nombre" sur D2 (pull-up), bouton "BINGO" sur D4 (pull-up)
 * Scoreboard : 75 LED WS2812B 5V (numéros) + 24 LED WS2812B (rétroéclairage BINGO)
 * Tout piloté depuis broche D6 via 2x 220Ω
 */
#include <Adafruit_NeoPixel.h>

const int NewNumberButton = 2;
const int BingoButton = 4;
const int LedPin = 6;

int NewNumber = 1, Bingo = 1;
int SCORE[76];
int count = 0;
long randNumber;
int NUMBER = 0, NW_NUMBER = 0, TENSNUMBER = 0, UNITNUMBER = 0;

#define NUM_LEDS 99
#define BRIGHTNESS 250

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, LedPin, NEO_GRB + NEO_KHZ800);

// Table segments: [segment][chiffre] - segments 0-7 (unités), 8-15 (dizaines), 7/15 = DP
byte SEGMENTarray[8][10] = {
  {1,0,1,1,0,1,1,1,1,1}, // seg 0/8
  {1,1,1,1,1,0,0,1,1,1}, // seg 1/9
  {1,1,0,1,1,1,1,1,1,1}, // seg 2/10
  {1,0,1,1,0,1,1,0,1,1}, // seg 3/11
  {1,0,1,0,0,0,1,0,1,0}, // seg 4/12
  {1,0,0,0,1,1,1,0,1,1}, // seg 5/13
  {0,0,1,1,1,1,1,0,1,1}, // seg 6/14
  {0,0,0,0,0,0,0,0,0,0}  // seg 7/15 (DP)
};

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
};

void setup() {
  Serial.begin(9600);
  pinMode(LedPin, OUTPUT);
  pinMode(NewNumberButton, INPUT_PULLUP);
  pinMode(BingoButton, INPUT_PULLUP);
  strip.setBrightness(BRIGHTNESS);
  strip.begin();
  strip.show(); // Tout éteint
  
  // Afficher "BINGO" en bleu au démarrage (LED 16-23)
  for (int t = 16; t < 24; t++) {
    strip.setPixelColor(t, 0, 0, 250);
    strip.show();
  }
  
  // Initialiser SCORE à 0
  for (count = 0; count < 76; count++) SCORE[count] = 0;
}

void loop() {
  NewNumber = digitalRead(NewNumberButton);
  
  if (NewNumber == LOW) { // Bouton nouveau nombre pressé
    randomSeed(millis());
    do {
      GENERATENEWNUMBER(75); // 1-75
    } while (NW_NUMBER == SCORE[NW_NUMBER] * NW_NUMBER); // Déjà sorti ?
    
    SCORE[NW_NUMBER] = 1;
    NUMBER = NW_NUMBER;
    TENSNUMBER = NUMBER / 10;
    UNITNUMBER = NUMBER - (10 * TENSNUMBER);
    
    CLEARDISPLAY();
    LIGHTSHOW1(4, 100);
    CLEARDISPLAY();
    DISPLAYNUMBER(TENSNUMBER, UNITNUMBER);
    DISPLAYSCORE();
  } 
  else {
    Bingo = digitalRead(BingoButton);
    if (Bingo == LOW) {
      delay(3000); // Anti-rebond + anti-appui accidentel
      if (Bingo == LOW) {
        BINGOLIGHTSHOW();
        for (count = 0; count < 76; count++) SCORE[count] = 0; // Reset
      }
    }
  }
}

void LIGHTSHOW1(int duration, uint8_t wait) {
  // Éteindre "BINGO" bleu
  for (int t = 16; t < 24; t++) { strip.setPixelColor(t, 0, 0, 0); strip.show(); }
  
  // Clignotement DP blanc
  for (int k = 0; k < duration; k++) {
    strip.setPixelColor(7, 200, 200, 200); strip.show(); delay(wait);
    strip.setPixelColor(7, 0, 0, 0);
    strip.setPixelColor(15, 200, 200, 200); strip.show(); delay(wait);
    strip.setPixelColor(15, 0, 0, 0);
  }
  
  // Arc-en-ciel
  int redVal, blueVal, greenVal;
  for (int k = 1; k < 45; k += 3) {
    redVal = color_scheme[k];
    blueVal = color_scheme[k + 1];
    greenVal = color_scheme[k + 2];
    for (int p = 0; p < 7; p++) {
      int i = p; int j = 8 + p;
      strip.setPixelColor(i, strip.Color(redVal, blueVal, greenVal));
      strip.setPixelColor(j, strip.Color(greenVal, redVal, blueVal));
      strip.show(); delay(30);
    }
  }
  
  // Tout éteindre
  for (int q = 0; q < 7; q++) {
    strip.setPixelColor(q, 0, 0, 0);
    strip.setPixelColor(8 + q, 0, 0, 0);
    strip.show();
  }
}

void BINGOLIGHTSHOW() {
  for (int l = 0; l < 10; l++) {
    // Cascade blanche sur scoreboard (5 rangées de 15)
    for (int k = 24; k < 39; k++) {
      strip.setPixelColor(k, 200, 200, 200);
      strip.setPixelColor(k+15, 200, 200, 200);
      strip.setPixelColor(k+30, 200, 200, 200);
      strip.setPixelColor(k+45, 200, 200, 200);
      strip.setPixelColor(k+60, 200, 200, 200);
      strip.show(); delay(5);
      strip.setPixelColor(k, 0, 0, 0);
      strip.setPixelColor(k+15, 0, 0, 0);
      strip.setPixelColor(k+30, 0, 0, 0);
      strip.setPixelColor(k+45, 0, 0, 0);
      strip.setPixelColor(k+60, 0, 0, 0);
      strip.show();
    }
    // Allumer afficheurs + BINGO en cyan
    for (int t = 0; t < 24; t++) { strip.setPixelColor(t, 0, 250, 250); strip.show(); }
    delay(50);
    for (int t = 0; t < 24; t++) { strip.setPixelColor(t, 0, 0, 0); strip.show(); }
  }
}

void GENERATENEWNUMBER(int range) {
  randNumber = random(1, range + 1);
  NW_NUMBER = (int)randNumber;
}

void DISPLAYNUMBER(int TENS, int UNIT) {
  // "BINGO" en rouge
  for (int t = 16; t < 24; t++) { strip.setPixelColor(t, 200, 0, 0); strip.show(); }
  
  for (int s = 0; s < 8; s++) {
    int t = SEGMENTarray[s][TENS];
    int u = SEGMENTarray[s][UNIT];
    int i = s; int j = 8 + s;
    strip.setPixelColor(i, u * 250, 0, 0);
    strip.setPixelColor(j, (TENS != 0) ? t * 250 : 0, 0, 0);
    strip.show();
  }
}

void DISPLAYSCORE() {
  // "BINGO" en rouge
  for (int t = 16; t < 24; t++) { strip.setPixelColor(t, 200, 0, 0); strip.show(); }
  
  // Numéros déjà sortis en vert (adresses 24-98 = numéros 1-75)
  for (int s = 24; s < 100; s++) {
    int u = SCORE[s - 23];
    strip.setPixelColor(s, 0, u * 200, 0);
    strip.show();
  }
  // Nouveau numéro en rouge
  strip.setPixelColor(23 + NUMBER, 200, 0, 0);
  strip.show();
}

void CLEARDISPLAY() {
  for (int q = 0; q < 7; q++) {
    strip.setPixelColor(q, 0, 0, 0);
    strip.setPixelColor(8 + q, 0, 0, 0);
    strip.show();
  }
  for (int t = 16; t < 24; t++) { strip.setPixelColor(t, 0, 0, 0); strip.show(); }
}

Pièces personnalisées et boîtiers

• tekening_gaten_patroon_puntjes_xgW76A8Jmw.svg (gabari pour faces avant)

Schémas

• bingo_sketch_66WRdQITE2.fzz