[Tuto] Trois codes en morse : LED et boutons

Tout le matériel nécessaire se trouve dans la colonne de droite. On vous a fait une jolie liste 🙂

Branchez les jumpers sur la sortie 5V et GND de votre Arduino.
Placez vos deux LED : le + vers les pins 2 et 4 de l’Arduino.
Rajouter une résistance 220 Ω sur chaque anode des LED, reliée à la terre.
Les boutons poussoirs sont reliés à la terre, et aux sorties 8, 11 et 12 de l’Arduino.
Nous utiliserons les résistances internes de l’Arduino sur les sorties 8, 11 et 12.

Mais un schéma vaut plus que mille mots, voici à quoi doivent correspondre vos branchements:

Si vous avez la moindre question, ou remarque, concernant ce script, n’hésitez pas à me contacter. Ce programme est simple, des experts en Arduino trouveront certainement des astuces pour le rendre plus concis, mais il a l’avantage de permettre de comprendre le fonctionnement des LED, des variables et des boutons poussoirs (en bref des grands classiques en escape game!).

Le fichier du programme complet se trouve ici : le code source de TroisCodeEnMorse

Les étapes du programme en détail

On déclare sous forme de tableau les variables codeA, codeB et codeC qui correspondent au code en morse que la LED va générer. Ces chiffres peuvent être modifiés pour changer le code.

// On déclare sous forme de tableau les variables codeA, codeB et codeC 
int codeA[3] = {1, 5, 0};
int codeB[3] = {8, 7, 9};
int codeC[3] = {4, 3, 2};

Les variables ci-dessous permettent de déclarer les noms des boutons poussoirs et des LED pour les associer ensuite au numéro des pins de l’Arduino. Si vous avez plus de trois boutons poussoirs, il faut penser à déclarer d’autres variables pinBoutonX, X étant l’identité de votre bouton.

// Déclaration des variables
int pinBoutonA, pinBoutonB, pinBoutonC, pinLedJaune, pinLedVerte, num, tempsAllum;

Ce tableau contient l’équivalence chiffre > morse. J’ai initialisé un temps long de 800 ms et court de 200 ms. Ces valeurs peuvent être modifiées en fonction de vos besoins. La première ligne correspond au chiffre 0 et la dernière à 9.

// Initialisation du tableau Morse, chaque ligne étant la manière de coder en morse un chiffre, de 0 à 9
const int tabMorse[10][5] =
{
  800, 800, 800, 800, 800,
  200, 800, 800, 800, 800,
  200, 200, 800, 800, 800,
  200, 200, 200, 800, 800,
  200, 200, 200, 200, 800,
  200, 200, 200, 200, 200,
  800, 200, 200, 200, 200,
  800, 800, 200, 200, 200,
  800, 800, 800, 200, 200,
  800, 800, 800, 800, 200,
};

Pins auxquels sont associés vos boutons. Si vous avez d’autres boutons, pensez à déclarer les pins auxquels ils sont branchés.

void setup()
{
  pinBoutonA = 8;
  pinBoutonB = 11;
  pinBoutonC = 12;
  pinLedJaune = 4;
  pinLedVerte = 2;

Lors de la déclaration des modes, les boutons sont en mode « entrée » (« INPUT ») pour leur permettre de lire les données envoyées. Dans notre cas, nous vérifierons si le joueur a appuyé, ou non, sur le bouton. « PULLUP » permet d’utiliser la résistance interne à la carte Arduino. Dans ce mode, si les boutons sont enfoncés, le pin recevra comme valeur 0.

Les LED quant à elles sont en sortie, donc directement alimentées par la carte Arduino.

  //définition des modes
  pinMode(pinBoutonA, INPUT_PULLUP);
  pinMode(pinBoutonB, INPUT_PULLUP);
  pinMode(pinBoutonC, INPUT_PULLUP);
  pinMode(pinLedJaune, OUTPUT);
  pinMode(pinLedVerte, OUTPUT);
}

Ce qui suit est le programme principal qui vérifie si le bouton est enfoncé ou pas, puis il décrit les actions à faire si c’est le cas.

void loop()
{
if (!digitalRead(pinBoutonA))         // si bouton est enfoncé, c'est-à-dire si le pin indique 0.
   {
   while (!digitalRead(pinBoutonA))   // tant que le bouton est enfoncé, il se passera ce qu'on indique entre {}
     {
     delay(500);                      // on indique 500ms d'attente. 
     }
     Code_Morse(codeA);               // dès que le bouton est relâché, la fonction Code_Morse s'exécute. 
   }

Nous répétons ce code pour chaque bouton déclaré avec des « else if » comme ci dessous. Personnalisez avec la lettre du bouton correspondant (ici B et C).

else if (!digitalRead(pinBoutonB))    
   {
   while (!digitalRead(pinBoutonB))   
     {
     delay(500);
     }
     Code_Morse(codeB);   
   }
else if (!digitalRead(pinBoutonC))  
   {
   while (!digitalRead(pinBoutonC))   
     {
     delay(500);
     }
     Code_Morse(codeC);   
   }
}

Nous créons ensuite la fonction Code_Morse utilisée par le programme principal. Cette fonction est ainsi appelée plus haut en étant personnalisée en fonction du code morse à générer. Ceci est possible grâce à la boucle « for » qui va chercher les informations dans les tableaux tabMorse[10][5] et codeX[3].

void Code_Morse(int code[])
{
   // une fois le bouton relaché, on eteint toutes les LED
    digitalWrite(pinLedJaune, LOW);
    digitalWrite(pinLedVerte, LOW);

    // la LED verte clignote 8 fois pour simuler la communication du joueur vers des "aliens". 
    for (int a = 0; a < 8; a++) 
    {
      digitalWrite(pinLedVerte, HIGH);
      delay(100);
      digitalWrite(pinLedVerte, LOW);
      delay(100);
    }
    
    // la LED jaune clignote de facon générer le code en morse
    for (int m = 0; m <= 2; m++) 
    {
      num = code[m];      // on récupère les 3 chiffres du code morse choisi

      for (int b = 0; b <= 4; b++) 
      {    
        // num est ici le chiffre correspondant à la ligne du tableau tabMorse, b la colonne
        int tempsAllum = tabMorse[num][b];    
        digitalWrite(pinLedJaune, HIGH);
        delay(tempsAllum);
        digitalWrite(pinLedJaune, LOW);
        delay(300); // temps off entre deux clignotements à l'intérieur du meme chiffre
      }
      delay(1500);      // Temps off entre deux chiffres, qui se rajoute au temps entre deux clignotements                        
    }
}

Le fichier du programme complet se trouve ici : le code source de TroisCodeEnMorse

Une histoire…

Pour cet exercice, nous avons imaginé le scénario suivant : les joueurs doivent trouver quel est la planète alliée à leur race, puis les contacter. Chaque bouton est associé à un symbole alien, représentant la nation de la planète. Lorsque les joueurs trouvent le symbole, ils doivent appuyer sur le bon bouton.

La LED verte clignote dans un premier temps pour simuler l’envoi du message des joueurs vers la nation alien. En retour, les aliens leur communiquent un code en morse (oui le morse est un langage interstellaire, un problème avec ça Padawan?).

S’il s’agit de la bonne nation alien alliée, le code est juste et ouvre un cadenas, une porte, déverrouille un ordi, etc. Vous pouvez imaginer que les autres codes morse (faux donc) déclenche une pénalité de temps par exemple s’ils sont entrés dans un ordinateur.

Et une boîte…

Par manque de moyen (oui nous sommes bien loin de notre imprimante 3D en ce moment ou d’un atelier pour scier du bois) nous avons caché le mécanisme dans un caisson fabriqué à partir de carton et d’une coque de réveil (achetée d’occasion dans une ressourcerie), le tout peint en chrome. Si vous réalisez un escape game pour vos amis, vous serez peut-être amené à fabriquer des caissons avec du carton, mais tout est possible ^^.

Dans tous les cas, n’oubliez pas qu’un joueur, excité par le jeu, n’est pas toujours très doux avec les objets. Pensez-y et sécurisez au maximum vos modules. renforcez votre caisson, ne laissez pas accessible un seul câble, le tout doit résister pour au moins une heure de jeu, s’il s’agit d’un jeu pour une soirée unique.

Pour les prochains tutos, nous intégrerons plus de détails sur la fabrication du caisson. On vous donne la main, faites preuve d’imagination !