Raspberry Pi – Squelette effrayant

(unfortunately, this article is only available in French for now)

Il y a deux mois, j’ai commencé à chercher des idées originales pour préparer mon Halloween. Je voulais quelque chose d’effrayant et qui puisse s’animer automatiquement lorsque quelqu’un passe à proximité. C’est Jérôme Oufella, notre vice-président technologies, qui m’a donné l’idée dont j’avais besoin : un squelette animé! L’idée m’enthousiasma et je me lançais dans la réalisation de mon propre squelette animé pour effrayer les enfants du quartier. L’article qui suit décrit les étapes qui ont été nécessaires pour réaliser ce projet.

Chez Savoir-faire Linux, j’ai l’occasion de côtoyer des collègues travaillant sur toutes sortes de projets passionnants. En tant que responsable du département de solutions d’entreprises, je suis surtout habitué aux projets plus « classiques » (portails, cms, gestion documentaire, intelligence d’affaire, etc.) mais je m’émerveille toujours devant l’empilement de cartes, oscilloscopes, câbles et matériel divers utilisé par les équipes du département de solutions industrielles. Bon, j’avoue que malgré les quelques cours d’électrotechnique et de robotique que j’ai suivis pendant mes études, plus le niveau d’expertise requis se rapproche du hardware, moins je comprends comment ça fonctionne.

Contrairement aux projets réalisés par mes collègues du département de solutions industrielles qui requièrent une expertise pointue en développement matériel, celui-ci est relativement trivial et accessible à n’importe qui, avec un peu de motivation et de débrouillardise. Après tout, je suis juste un développeur Java à la base! 😉

Un rapide aperçu

Voici un aperçu du projet terminé. Cela servira de référence pour les sections qui suivent. Le squelette fait environ 1m60 (5pi 3′) de haut et :

• Détecte les mouvements à proximité
• Illumine ses yeux
• Bouge sa mâchoire
• Parle (ou plutôt fait des sons)

Pour ceux qui s’intéressent uniquement au résultat final, rendez-vous directement à la dernière section (démonstration) qui présente une vidéo de son fonctionnement. Pour ceux qui désirent s’en inspirer (et faire mieux!), les prochaines sections détaillent les étapes qui m’ont été nécessaires pour le construire.

Matériel nécessaire

Voici les éléments dont je me suis servi pour construire le squelette.

• Structure : pour la structure, je me suis servi de planches de bois qui me restait dans mon garage. Il me restait des montants inutilisés d’un meuble GORM de chez IKEA qui ont fait parfaitement l’affaire mais ceux-ci ne peuvent pas être achetés séparément. Par contre, n’importe quelle structure peut convenir.
• Membres du squelette : les pièces du squelette proviennent d’un kit avec tous les os des pieds et des bras pour 15$. Je ne retrouve malheureusement pas l’article en question mais je crois l’avoir acheté chez Canadian Tire ou Wallmart. Dans tous les cas, il existe énormément de magasins qui proposent ce type d’article à l’approche d’Halloween pour un montant relativement faible.
• Crâne du squelette : le crâne peut s’avérer compliquer à trouver car la plupart des magasins proposent des crânes trop petits, de mauvaise qualité ou inadaptés. C’est finalement ma femme qui a trouvé ce merveilleux article chez Target. Celui-ci est grand et sa mâchoire est déjà amovible! Coût: 10$.
• Cape : afin de masquer la structure et l’électronique, je l’ai équipé d’une cape noire qui me restait d’un déguisement pour enfant. Je ne me souviens plus de sa provenance mais c’est un article qui se trouve facilement pour une somme modique (< 10$).
• Nano-ordinateur : pour le « cerveau » du squelette, qui contrôle toutes les composantes, j’ai utilisé un Raspberry Pi (29.95$). J’ai longtemps hésité à utiliser un simple Arduino comme pour le projet dont je me suis inspiré mais j’ai finalement opté pour le Pi que je pense plus facile à maîtriser pour quelqu’un qui se débrouille en programmation et connaît Linux. Le kit est plus intéressant financièrement que d’acheter chaque composante séparément. Je me suis procuré l’ensemble du matériel chez Adafruit mais j’ai découvert par la suite des magasins d’électronique sur Montréal (comme Abra Electronics) qui proposent les mêmesproduits. Je recommande également l’achat d’un kit (44.95$) avec des fils, un breadboard, le Pi cobler, et d’autres composantes.
• Détecteur de mouvement : je me suis procuré le détecteur PIR sensor (9.95$). Celui-ci peut facilement être manipulé à partir du Raspberry Pi.
• Yeux : pour illuminer les yeux, j’ai opté pour des diodes rouges ultralumineuses. J’en ai trouvé pour 8$ le pack de 25.
• Moteur : pour faire bouger la mâchoire du squelette, il me fallait un servo-moteur. J’ai acheté l’un des modèles les moins chers (5.95$). Il faut également acheter une batterie externe 6V pour alimenter le moteur.
• Haut-parleurs : afin de pouvoir donner la parole au squelette, je l’ai muni de mini haut parleurs USB (9.95$).
• Autre matériel : je me suis servi de pas mal d’autres petites choses, fils supplémentaires, clous, ruban adhésif, ciseaux, piles 1.5V etc. dont je ne pourrais faire la liste exhaustive ici.

Au total, en incluant le prix de Raspberry Pi, il faut compter environ 200$ pour fabriquer le tout. C’est plutôt cher mais la plupart des composantes sont réutilisables pour d’autres projets et c’est tellement fun!!

Étape 1 : les composantes matérielles

Avant de se lancer dans la création du squelette lui-même, j’ai décidé de commencer par assembler, tester et programmer les différentes composantes pour m’assurer que j’aurais le résultat désiré. Pour chacune des composantes principales (détecteur de mouvement, moteur, haut-parleurs et diodes lumineuses), je me suis basé sur des tutoriels que j’ai trouvé sur Adafruit | Learn Raspberry Pi. Ces tutoriels sont fantastiques car ils permettent de comprendre rapidement comment utiliser et programmer un Raspberry Pi. Pour ceux pour qui, comme moi, il s’agit de la première expérience, je recommande vivement de suivre les leçons 1, 2, 3 et 4 afin d’apprendre comment initialiser, configurer et accéder au micro-ordinateur.

Haut-parleurs

C’est évidemment la partie la plus simple. Les hauts-parleurs n’ont qu’à être branchés sur l’un des ports USB du Raspberry Pi et l’entrée de son sur l’audio jack (se référer au guide Raspberry Pi si vous ne connaissez pas les ports).

Diodes lumineuses

Pour les diodes lumineuses, je me suis basé sur le guide Pi E-mail Notifier Using LEDs. Chaque diode dispose de deux tiges, une longue (+) et une courte (-). J’ai relié les longues à la ligne 3 de la planche à circuits (voir 2 sur le schéma ci-contre). J’ai relié les courtes sur la colonne bleue (-) (voir 3). Enfin, les diodes sont reliées au GPIO #24 par la résistance verte (voir 1). J’ai pris une résistance de 330 Ohm pour cela mais d’après le tutoriel, n’importe quelle résistance entre 330 et 1000 Ohm ferait l’affaire (ne me posez pas la question… je n’ai aucune idée comment ça se calcule).

Détecteur de mouvement

Pour le détecteur de mouvement, je me suis inspiré du guide Lesson 12. Sensing Movement. Le détecteur de mouvement dispose de 3 fils de couleurs différentes :

• Jaune (1) : ce fil est celui qui transmet le signal ON/OFF lors de la détection. Je l’ai relié au GPIO #17 tel qu’illustré sur le schéma ci-contre.
• Route (2) et noir (3) : ces fils permettent l’alimentation du senseur. Il suffit de relier les fils sur les colonnes rouges (+) et bleues (-) du circuit.

Moteur

Pour le moteur, je me suis appuyé du tutoriel Lesson 8. Using a Servo Motor. Pour installer le moteur, il est nécessaire de connecter les 3 fils suivants (attention, les couleurs peuvent varier d’un moteur à l’autre!) :

• Jaune (1) : ce fil permet d’envoyer un signal au moteur afin de le contrôler. Je l’ai relié au GPIO #18 tel qu’illustré sur le schéma ci-contre.
• Rouge (+) et Noir (-) (2) : ces fils permettent l’alimentation du senseur. Il suffit de relier les fils sur les colonnes rouges (+) et bleues (-) du circuit.

Tel que suggéré dans le tutoriel, il est recommandé d’utiliser une alimentation 5V séparée pour faire fonctionner le moteur, plutôt que le 5v0 du Raspberry Pi. Les fils de l’alimentation ont été connectés aux colonnes rouges (+) et bleues (-) de gauche du circuit (voir point 3 sur le schéma).

Autres

Comme vous pouvez le constater sur les schémas, d’autres fils ont été utilisés:

• le fil bleu relie la colonne du négatif (-) de droite avec la terre (GND) du CPIO du Raspberry Pi
• le fil jaune (juste à côté du bleu), relie la colonne du négatif (-) de gauche avec la terre.

Étape 2 : le logiciel

Une fois que toutes les composantes ont été reliées au GPIO, l’étape suivante est de les programmer pour qu’elles interagissent ensemble. L’objectif que je m’étais fixé étant le suivant, lorsque le détecteur de mouvement envoie un signal :

• Les haut-parleurs jouent un son terrifiant (tiré aléatoirement dans un répertoire « sounds »)
• Les diodes lumineuses s’allument pour que les yeux du squelette s’illuminent
• Le moteur s’active afin de faire bouger la mâchoir du squelette

Voyons comment cela se programme. Je rappelle que la programmation se fait en langage Python. Si l’une des parties ne semble pas fonctionner, je recommande de vérifier le circuit (étape 1) pour ce composant, quitte à retirer tous les autres fils afin d’isoler uniquement ce composant. Suivre le tutoriel Adafruit peut s’avérer également important pour comprendre le fonctionnement du composant.

Le code source complet peut être retrouvé sur GitHub.

Haut-parleurs :

Aucune programmation nécessaire pour les haut-parleurs, il suffit d’exécuter la commande « aplay SON » pour envoyer le flux audio. Exemple: aplay Dark_Laugh.wav

Détecteur de mouvement

Pour le détecteur de mouvement, le code nécessaire est relativement simpliste. Il suffit de configurer la pin #17 en mode input et de boucler pour attendre que le senseur détecte un mouvement.

SENSOR = 17
GPIO.setmode(GPIO.BCM)
GPIO.setup(SENSOR, GPIO.IN)

while True:
   if GPIO.input(SENSOR):
      doSomething()
      time.sleep(5)
   time.sleep(0.5)

Explications:

• 2: Activer le mode BCM pour le GPIO
• 3: Mettre le senseur en mode lecture
• 5: Boucle infinie
• 6: Vérifier l’état du senseur (True = détection)
• 7: Exécution d’une action représentée par la fonction doSomething()
• 8: Attendre quelques secondes (ici 5sec) pour éviter l’exécution successive
• 9: Attendre avant de tester le senseur une nouvelle fois

Diodes lumineuses

Le code Python nécessaire pour allumer les diodes est également très simple. Il suffit de mettre la pin #24 en mode output et d’y envoyer un signal. Voici un extrait de code qui permet d’allumer les diodes pour  une durée de 5 secondes.

RED_LED = 24
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.RED_LED, GPIO.OUT)

GPIO.output(RED_LED, True)
time.sleep(5)
GPIO.output(RED_LED, False)

Explications:

• 3: Activer le mode BCM pour le GPIO
• 4: Mettre les diodes en mode écriture
• 5: Envoyer un signal pour allumer les diodes
• 6: Attendre 5 secondes
• 7: Envoyer un signal pour éteindre les diodes

Moteur

Pour le moteur, c’est beaucoup plus compliqué. Les tutoriels d’Adafruit utilisent un module spécial (PWM) qui facilite grandement l’utilisation des servo-moteurs. Cependant, ayant opté pour la distribution Raspbian, je n’ai pas eu accès à ce module. Je me suis donc basé sur la librairie ServoBlaster qui permet de contrôler jusqu’à 8 servo-moteurs simultanément. La complexité avec les moteurs, c’est qu’il faut leur envoyer une impulsion et c’est la fréquence qui détermine la rotation du moteur. Vous devez donc connaître les spécifications de votre moteur. Dans mon cas, le moteur était supposé recevoir des impulsions suivantes:

• 1ms : rotation de -90 degrés
• 1.5ms: rotation de 0 degrés
• 2ms: rotation de 90 degrés

Pour envoyer l’impulsion au moteur, il faut utiliser la commande suivante (après avoir chargé le module ServoBlaster): echo 3=120 > /dev/servoblaster
La première valeur (3) est l’identifiant de la PIN. Il faut se référer à la documentation de ServoBlaster pour connaître la valeur à utiliser. La deuxième valeur indique la fréquence de l’impulsion en 10us (120 signifie donc 1.2ms).

J’ai du tester plusieurs valeurs pour connaître les fréquences minimales et maximales du moteur. Les spécifications étaient plus ou moins correctes:

• 0.55ms : rotation de -90 degrés (MIN)
• 2.50ms: rotation de 90 degrés (MAX)

Le code Python pour l’envoi d’une impulsion ressemble à cela:

SERVONUM = 3
PULSE = 120
f = open("/dev/servoblaster", 'w')
f.write("" + SERVONUM + "=" + PULSE + "n")
f.close()

Au final, j’ai développé toute une libraire Python pour gérer le servo-moteur, notamment pour produire une rotation lente d’un angle à un autre, afin de pouvoir m’en servir pour le squelette (GitHub).

Étape 3 : l’assemblage

Yeux qui s’illuminent

Afin de préparer le squelette pour les yeux et la mâchoire, j’ai ouvert le crâne à l’arrière. J’ai ensuite percé deux trous afin de faire passer les diodes dans les yeux. Les diodes sont reliés directement aux circuits tel qu’indiqué dans les sections précédentes.

Mâchoire animée

Afin de contrôler la mâchoire, après de nombreuses réflexions et idées infructueuses, j’ai opté pour un mécanisme très simple. J’ai fixé le moteur à l’arrière du crâne (voir photo) et j’ai utilisé du fil dentaire pour relier la mâchoire au moteur. Ainsi, en modifiant l’angle du moteur, celui-ci raccourcit ou rallonge le fil, actionnant ainsi la mâchoire. Après quelques tests, j’ai pu noter les angles min et max pour faire ouvrir la mâchoire et la refermer complètement.

Micro-ordinateur, détecteur de mouvement et haut parleurs

Les autres composantes ont été installées sur la structure, cachés sous la cape. J’ai fait passé le câble d’alimentation aux pieds du squelette et accroché le détecteur de mouvement juste en dessous de la tête.

Démonstration

Cette première vidéo présente le squelette et son fonctionnement :

La deuxième vidéo démontre son effet sur les enfants…

Et ensuite?

Voilà, c’était ma contribution de l’année! N’hésitez pas à m’envoyer vos remarques et commentaires…

Je vais me lancer sur d’autres projets similaires avec mon Raspberry Pi, peut-être pour Noël si j’en trouve le temps. Partagez et contribuez vos créations!