Dé électronique à secousses avec matrice LED – Arduino Nano et MAX7219

Composants et fournitures

Composant	Quantité
Arduino Nano R3	1
Matrice de points 8×8 3mm avec driver MAX7219	1
Module capteur d'inclinaison (tilt switch) à interface numérique	1
Interrupteur à glissière	1
Module convertisseur step-up MT3608 (2V-24V vers 5V/9V/12V/28V)	1

Outils et machines nécessaires

• Fer à souder
• Pistolet à colle chaude

Applications et services en ligne

• Arduino IDE
• Autodesk Fusion 360 (pour la conception du boîtier)

À propos du projet

Il y a environ un an, mon fils et moi avions construit un dé électronique avec un Arduino et quelques LED. C'est toujours un projet idéal pour débutants. Nous avons beaucoup appris depuis, il était temps de faire une mise à jour.

Le dé reste un projet de démarrage parfait. Son fonctionnement est clair pour tous et il permet de comprendre facilement les différents domaines : microcontrôleur, électronique simple et programmation.

Version 2.0

Ce dé permet d'aller plus loin en reliant d'autres domaines. Aujourd'hui, il existe des modules tout faits pour presque tout. On le voit bien dans les kits de démarrage Arduino ou Raspberry Pi : LED, boutons, capteurs divers sont montés sur circuits imprimés et se connectent en quelques fils aux GPIO.

Des imprimantes 3D simples sont disponibles sur eBay pour moins de 140 €. Presque tous les supports, fixations ou boîtiers peuvent être créés avec. Notre nouveau dé 2.0 en est un exemple.

Capteurs d'inclinaison

Nous implémentons le dé différemment. Un Arduino Nano est utilisé pour des raisons d'espace. Il y a toujours un interrupteur marche/arrêt, mais plus de bouton. Le lancer se fait en secouant le cube entier.

Pour cela, on utilise des capteurs d'inclinaison ou de vibration. Ils fonctionnent comme un bouton : une bille se déplace dans un tube de verre. Si elle touche les contacts, le circuit se ferme. Ce contact, parfois très court, sert de signal. On entend bien le mouvement de la bille métallique en secouant le capteur.

Normalement, la position d'installation est décisive pour un capteur d'inclinaison. Il doit déclencher un signal à une certaine position angulaire. Dans notre cas, le signal se déclenche en secouant le boîtier. La position n'est donc pas critique, car un secouement dans n'importe quelle direction génère un signal. Pour plus de fiabilité, nous utilisons deux capteurs décalés de 90° l'un par rapport à l'autre.

Interruptions matérielles

Pour détecter les secousses, il faudrait interroger les entrées des capteurs dans la boucle principale. Mais selon le moment où cela se produit et ce que fait le reste du programme, des événements peuvent passer inaperçus.

Une meilleure solution : utiliser les interruptions matérielles. La fonction attachInterrupt définit une sous-routine appelée sur le signal. L'Arduino fournit deux interruptions matérielles : les broches D2 et D3.

Affichage

L'affichage du dé pourrait se faire avec 7 LED individuelles, mais l'utilisation d'un module matrice LED 8×8 avec driver MAX7219 est plus intéressante. Il prend peu de place, coûte peu et est facile à programmer.

Selon le fournisseur, il faut souder et assembler les pièces. La seule erreur possible est d'insérer la matrice LED à l'envers dans les connecteurs. Si l'affichage est inversé, il suffit de retirer délicatement la matrice et de la tourner de 180°.

Un peu de physique

La matrice ne doit pas juste afficher le résultat. Elle doit proposer des effets visuels : les six points du dé se déplacent sur la matrice, rebondissent sur les bords et perdent progressivement de la vitesse.

Grâce aux deux capteurs d'inclinaison, on mesure l'intensité du secouement. Cette information donne aux points du dé une « vitesse » pour leur mouvement. On utilise un effet similaire pour l'affichage du résultat : les points roulent de leur position aléatoire vers leur position correcte dans le dessin du dé.

Alimentation

Au début, nous avons installé deux piles bouton CR2032 3V pour gagner de la place. Au début, tout fonctionnait bien. Mais après quelques minutes, la tension s'effondre. Si on éteint l'Arduino après chaque lancer, ça marche, mais ce n'est pas idéal. Nous passons donc à deux piles AAA. Elles ne fournissent ensemble que 3V, il faut donc un convertisseur step-up pour monter à 5V. Le raccordement se fait sur la broche VIN de l'Arduino.

Conception du boîtier

La meilleure option est une conception propre et une impression 3D. Nous avons utilisé Autodesk Fusion 360. Le boîtier se compose de 3 parties :

• Partie supérieure
• Partie inférieure avec logement pour piles AAA
• Couvercle en plexiglas (optionnel)

La matrice LED rend encore mieux avec un couvercle en plexiglas dépoli devant. Les LED éteintes deviennent invisibles et l'image est plus nette.

Programme (Sketch)

Pour piloter la matrice LED, la bibliothèque LedControl est nécessaire. Si elle n'est pas installée, téléchargez-la depuis arduino.cc.

On définit ensuite comment les points du dé s'affichent sur la matrice. Un point de dé = 4 points LED. Dans le tableau, on indique le coin supérieur gauche comme coordonnées X/Y (-1 = hors affichage).

Le code complet est disponible dans la section « Code » ci-dessous.

Assemblage

L'Arduino est placé sur une barrette de connecteurs, comme un shield. Les 5 contacts de la matrice LED sont connectés de la même façon. En centrant l'Arduino, l'espace est optimisé. Il est préférable d'utiliser les broches 5, 6, 7 pour CS, CLK et DIN de la matrice. Les connexions 5V et GND se font via un petit pont.

Les deux capteurs d'inclinaison sont connectés avec de courts fils aux broches 2 et 3, ainsi qu'au 5V et GND.

Ensuite, tout s'assemble : le plexiglas est fixé à la colle chaude, de même que la matrice LED. L'interrupteur marche/arrêt est installé, fixé à la colle chaude et câblé.

Montage de l'alimentation

L'alimentation est un peu bricolée. Selon les composants, les contacts plus et moins peuvent être ajustés. Nous utilisons les ressorts et plots d'un vieux compartiment à piles. Pour fixer au fond du boîtier, on utilise des fils et un peu de colle chaude.

Le convertisseur step-up est préréglé à environ 5V avant installation (on tourne la résistance). Ensuite, les deux parties du boîtier s'emboîtent. Grâce à un jeu de 0,1 mm, l'assemblage tient sans fixation supplémentaire et peut s'ouvrir pour changer les piles.

Et c'est fini ! Le dé 2.0 peut commencer !

Ce dont vous avez besoin

• Arduino Nano (ou ESP8266)
• 2 capteurs d'inclinaison (avec résistances intégrées)
• Matrice LED 8×8 avec MAX7219, SPC
• Barrette de connecteurs (socket strip)
• Interrupteur On/Off
• Circuit imprimé (PCB)
• 2 piles AAA

Plus d'informations

Pour en savoir plus, consultez notre site techpluscode.de/arduino-wuerfel-2-0 (en allemand).

Code

wuerfel8x8.ino (Arduino)

/* Blog-Artikel: Schüttel-Würfel mit LED Matrix und Bewegungssimulation
   https://techpluscode.de/schuettel-wuerfel-mit-led-matrix-und-bewegungssimulation/
   techpluscode.de Copyright 2019 von Thomas Angielsky */

#include "LedControl.h"

int PinTiltX = 2;
int PinTiltY = 3;
int PinCLK = 7;
int PinCS = 6;
int PinDIN = 5;

LedControl lc = LedControl(PinDIN, PinCLK, PinCS, 1);

// Coordonnées des points du dé dans la matrice LED
int DicePic[8][6][2] = {
    { // Matrice vide et position de départ
        {9,9}, {9,8}, {9,7}, {9,6}, {9,5}, {9,4}
    },
    { // 1
        {4,4}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}
    },
    { // 2
        {2,2}, {6,6}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}
    },
    { // 3
        {2,6}, {6,2}, {4,4}, {-1,-1}, {-1,-1}, {-1,-1}
    },
    { // 4
        {2,2}, {2,6}, {6,2}, {6,6}, {-1,-1}, {-1,-1}
    },
    { // 5
        {2,2}, {2,6}, {6,2}, {6,6}, {4,4}, {-1,-1}
    },
    { // 6
        {2,1}, {2,4}, {2,7}, {6,1}, {6,4}, {6,7}
    },
    { // Début
        {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}
    }
};

// Variables des points du dé : position, direction, vitesse pour X et Y
float 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() {
    shakes = shakes + 1;
    timestamp = millis();
}

void SetSpeedX() {
    if (Mode == 0) {
        for (int i = 0; i < 6; i++) {
            if (DiceXspeed[i] < 255) DiceXspeed[i] = DiceXspeed[i] + 5;
        }
    }
    InterruptChecks();
}

void SetSpeedY() {
    if (Mode == 0) {
        for (int i = 0; i < 6; i++) {
            if (DiceYspeed[i] < 255) DiceYspeed[i] = DiceYspeed[i] + 5;
        }
    }
    InterruptChecks();
}

void ShowLed(int x, int y, bool onoff) {
    if ((x < 8) && (y < 8) && (x >= 0) && (y >= 0)) {
        lc.setLed(0, x, y, onoff);
    }
}

void ShowDot(int x, int y, bool onoff) {
    ShowLed(x-1, y-1, onoff);
    ShowLed(x, y-1, onoff);
    ShowLed(x-1, y, onoff);
    ShowLed(x, y, onoff);
}

void ShowDicePic(int value) {
    boolean done;
    for (int i = 0; i < 6; i++) {
        DiceXspeed[i] = 100;
        DiceYspeed[i] = 100;
        DiceXdir[i] = 0;
        if (int(DiceXpos[i]) > DicePic[value][i][0]) DiceXdir[i] = -1;
        else if (int(DiceXpos[i]) < DicePic[value][i][0]) DiceXdir[i] = 1;
        DiceYdir[i] = 0;
        if (int(DiceYpos[i]) > DicePic[value][i][1]) DiceYdir[i] = -1;
        else if (int(DiceYpos[i]) < DicePic[value][i][1]) DiceYdir[i] = 1;
    }

    do {
        for (int i = 0; i < 6; i++) {
            if (int(DiceXpos[i]) != DicePic[value][i][0]) DoStep(DiceXpos[i], DiceXdir[i], DiceXspeed[i], false);
            if (int(DiceYpos[i]) != DicePic[value][i][1]) DoStep(DiceYpos[i], DiceYdir[i], DiceYspeed[i], false);
        }
        lc.clearDisplay(0);
        for (int i = 0; i < 6; i++) {
            ShowDot(int(DiceXpos[i]), int(DiceYpos[i]), true);
        }
        delay(50);
        done = true;
        for (int i = 0; i < 6; i++) {
            if (int(DiceXpos[i]) != DicePic[value][i][0]) done = false;
            if (int(DiceYpos[i]) != DicePic[value][i][1]) done = false;
        }
    } while (done == false);

    lc.clearDisplay(0);
    for (int i = 0; i < 6; i++) {
        ShowDot(DicePic[value][i][0], DicePic[value][i][1], true);
    }
}

void DoStep(float &pos, float &dir, volatile byte &sp, bool check) {
    pos = pos + float(sp)/255 * dir;
    if (check) {
        if (pos > 7) { pos = 7; dir = dir * (-1); }
        if (pos < 1) { pos = 1; dir = dir * (-1); }
    }
    if (sp > 0) sp = sp - 1;
}

void MoveDots() {
    for (int i = 0; i < 6; i++) {
        DoStep(DiceXpos[i], DiceXdir[i], DiceXspeed[i], true);
        DoStep(DiceYpos[i], DiceYdir[i], DiceYspeed[i], true);
    }
    lc.clearDisplay(0);
    for (int i = 0; i < 6; i++) {
        ShowDot(int(DiceXpos[i]), int(DiceYpos[i]), true);
    }
}

void setup() {
    lc.shutdown(0, false);
    lc.setIntensity(0, 8);
    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] = random(3) - 1;
        DiceYdir[i] = random(3) - 1;
        DiceXspeed[i] = random(126) + 120;
        DiceYspeed[i] = random(126) + 120;
    }
    pinMode(PinTiltX, INPUT_PULLUP);
    pinMode(PinTiltY, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(PinTiltX), SetSpeedX, CHANGE);
    attachInterrupt(digitalPinToInterrupt(PinTiltY), SetSpeedY, CHANGE);
    lc.clearDisplay(0);
    timestamp = millis();
    Mode = 1;
    ShowDicePic(6);
    delay(1000);
    lc.clearDisplay(0);
    Mode = 0;
    Serial.begin(9600);
    step = 0;
    shakes = 0;
}

void loop() {
    delay(50);
    step = step + 1;
    if (step > 20) {
        step = 0;
        ShakesPerSecond = shakes;
        shakes = 0;
    }
    if (Mode == 0) {
        MoveDots();
        if (millis() - timestamp > 2000) {
            Mode = 1;
            DiceValue = random(6) + 1;
            ShowDicePic(DiceValue);
        }
    }
    if (ShakesPerSecond > 5) {
        Mode = 0;
    }
}

Schéma de câblage

Mon schéma pour le circuit est disponible dans la section « Schémas ».