Fabriquer son Docteur Maboul

Publié par Atelier Rlv, le 10 juin 2022 3.2k

Avec le développement de nos animations, nous essayons de mettre en place une nouvelle ressource : le Wiki de l'Atelier, où nous répertorions nos projets, nos supports, nos expériences, etc. En ce moment, nous travaillons sur des projets pour les ateliers Arduino, ces cartes électroniques programmables souvent utilisées dans de petits projets de bricolage.

Voici donc une première réalisation : une variante du jeu « Docteur Maboul », avec une petite plaque personnalisée imprimée en 3D et illustrée avec la constellation de la Petite Ourse. À vos outils !

Le joueur fait face à une plaque avec des trous contenant de petits objets. Il dispose d'une pince, pour attraper ces objets, sans toucher les bords de la plaque. Si un contact a lieu, cela déclenche une sonnerie révélant l'erreur.

▶ Fiche de présentation du projet

Matériel

1 buzzer PKM22EPP-40
1 résistance 10 kΩ
1 pince crocodile
1 planche percée conductrice
1 pince métallique

Circuit

Le circuit est très simple. D'une part, il faut brancher le buzzer sur la carte Arduino, en branchant le ➕ sur une broche numérique et le ➖ sur la masse. D'autre part, il faut pouvoir détecter si le joueur est en train de toucher la plaque avec sa pince. Pour ce faire, on relie la pince au 5V, à l'aide d'une pince crocodile. La plaque est conductrice. Lorsque la pince touchera la plaque, le courant pourra passer, si elle est reliée à la masse. On intercale simplement une pour éviter un court circuit. La détection se fait donc au niveau de la plaque : si la pince ne touche pas, la plaque sera à 0V (LOW). Si la pince touche, la plaque sera à 5V (HIGH).

Code

Comme pour tous les projets Arduino, nous commençons avec la structure suivante :

void setup()
{
}
void loop()
{
}

Détection du contact entre la pince et la plaque

Comme expliqué dans la section précédente, la broche numérique n°3 va nous permettre de détecter le contact entre la pince et la plaque. Il s'agit d'une entrée numérique, dont l'état varie entre LOW (pas de contact) et HIGH (contact). Pour rappel, pour lire l'état d'une broche numérique, il faut paramétrer la broche comme « entrée » dans la fonction setup avec la fonction pinMode(numero_de_la_broche, INPUT) et utiliser la fonction digitalRead(numero_de_la_broche).

Mais ce qui nous intéresse ici, ce n'est pas exactement de savoir si la pince et la plaque sont en contact, mais plutôt de détecter l'instant précis où celà se produit. Tant qu'il n'y a pas de contact, la broche est dans l'état LOW. Lorsque la pince touche, elle passe à HIGH. Il faut donc détecter le passage de la broche de LOW à HIGH. Voici ce que ça donne :

#define BROCHE_BUZZER 13
int ancien_etat = LOW;
void setup()
{
    pinMode(BROCHE_PINCE, INPUT);
}
void loop()
{
    // On lit l'état actuel de la broche
    int etat = digitalRead(BROCHE_PINCE);
    // On regarde s'il y a un contact (etat == HIGH)
    // et si à l'instant d'avant, il n'y en avait pas (ancient_etat == LOW)
    if (ancien_etat == LOW && etat == HIGH)
    {
        // Le contact vient juste de se produire !
    }
    // L'état actuel devient l'ancien état
    ancien_etat = etat;
}

Contrôle du buzzer

Au moment où le contact se produit, on souhaite déclencher une petite sonnerie avec le buzzer. Pour contrôller le buzzer, il faut d'abord paramétrer sa broche en « sortie » dans la fonction setup avec la fonction pinMode(numero_de_la_broche, OUTPUT), puis utiliser la fonction tone(numero_de_la_broche, frequence_en_hertz, duree_en_millisecondes). Voici, par exemple, comment jouer un La 4 (440 Hz) pendant une seconde :

tone(BROCHE_BUZZER, 440, 1000);
delay(1000);

Notez qu'après la fonction tone on utilise la fonction delay. Cela permet d'attendre que la note finisse de jouer avant de continuer le programme. Comme nous allons jouer plusieurs notes à la suite, il faudra toujours attendre qu'une note soit terminée pour jouer la suivante.

Maintenant, place à nos talents de mélomanes, pour composer un petit jingle de défaite. En voici un exemple :

tone(BROCHE_BUZZER, NOTE_SOL_3, 100);
delay(110);
tone(BROCHE_BUZZER, NOTE_FA_3, 80);
delay(90);
tone(BROCHE_BUZZER, NOTE_DO_3, 100);
delay(100);

où les notes correspondent aux fréquences suivantes :

#define NOTE_DO_3  131
#define NOTE_FA_3  175
#define NOTE_SOL_3  196

Code complet

Les deux composantes de notre programme sont prêtes, il ne reste qu'à les assembler.

#define BROCHE_BUZZER 13
#define BROCHE_PINCE 3
#define NOTE_DO_3  131
#define NOTE_FA_3  175
#define NOTE_SOL_3  196
int ancien_etat = LOW;
void setup()
{
    pinMode(BROCHE_BUZZER, OUTPUT);
    pinMode(BROCHE_PINCE, INPUT);
}
void loop()
{
    int etat = digitalRead(BROCHE_PINCE);
    if (ancien_etat == LOW && etat == HIGH)
    {
        tone(BROCHE_BUZZER, NOTE_SOL_3, 100);
        delay(110);
        tone(BROCHE_BUZZER, NOTE_FA_3, 80);
        delay(90);
        tone(BROCHE_BUZZER, NOTE_DO_3, 100);
        delay(100);
    }
    ancien_etat = etat;
}

Conception de la plaque

Pour s'éloigner un peu du jeu original, nous allons utiliser un boîtier sur la thématique de l'espace : une représentation de la constellation de la Petite ourse, percée aux emplacements des étoiles. La plaque est imprimée en 3D, recouverte d'une feuille d'aluminium puis d'une couverture imprimée. Pour la re-créer, voici les étapes à suivre :

Imprimer la plaque en 3D

Télécharger et imprimer le fichier STL (100 mm de longueur, 70 mm de largeur, 11 mm de hauteur) :

▶ Visualiser la pièce

Pour que la plaque repose sur le socle de l'imprimante, il faut l'imprimer à l'envers, en ajoutant des supports pour les trous.

Les trous correspondent aux étoiles de la constellation de la Petite Ours. Pour modéliser cela avec Tinkercad, nous avons tout d'abord positionné les cercles sur une image vectorielle en suivant une photographie du ciel comme modèle. Ensuite, nous avons exporté l'image en SVG, format accepté par Tinkercad, qui crée automatiquement des volumes à partir de ces images. Ainsi, nous pouvons placer facilement, rapidement et précisément les étoiles conformément à leur position dans notre ciel !

Recouvrir d'une feuille d'aluminium

Pour la rendre conductrice, il faut l'envelopper d'une feuille d'aluminium, percée au niveau des étoiles. Il est possible de percer manuellement la feuille, mais le résultat n'est jamais très propre. Il vaut mieux utiliser la découpeuse. Les paramètres de découpe du papier de photocopie ordinaire fonctionnent bien pour l'aluminium. Commencer donc par mettre à plat la feuille sur le support de la découpeuse, en veillant à ne pas le froisser. Découper les étoiles en suivant ce fichier de découpe.

Une fois les étoiles découpées, placer la feuille sur la plaque et replier les bords sous la plaque.

Recouvrir avec la couverture

Télécharger et imprimer la couverture ci-dessous :

L'imprimer en respectant les dimensions suivantes :

L'image entière (avec les bords invisibles) fait 100 mm de large et 148 mm de haut
L'image pleine (sans les bords invisibles) fait 92 mm de large et 12mm de haut

Sous Windows, pour respecter la taille d'impression, il faut régler le paramètre « Dimensions de la photo » sur 100 mm x 148 mm (les bords invisibles ont été ajouté justement pour correspondre à ces dimensions prédéfinies) :

Il va ensuite falloir découper cette couverture au niveau du contour et des emplacements des étoiles. Encore une fois, on pourrait le faire à la main, mais utiliser la découpeuse donnera un résultat plus propre. Donc, pré-découper la couverture en laissant une marge de 1 cm autour, et utiliser ce fichier de découpe pour utiliser la brodeuse.

Maintenant, il ne reste plus qu'à coller la couverture sur la plaque d'aluminium, et planter le fil de la masse (GND) de la carte dans l'aluminium à travers la couverture, et voilà !

Imprimer les étoiles

Dernière petite étape : imprimer les objets à récupérer à l'intérieur des trous.

▶ Visualiser la pièce

Et le tour est joué !

Recommander