Attention MISSILE !

AUJOURD’HUI, mesdames, messieurs, j’ai à vous présenter une réalisation de la plus haute importance : un lance-missile en mousse. Je vous préviens tout de suite : cet appareil n’est pas de ma conception, car il est probablement arrivé sur Terre avant moi. Je l’ai simplement remis au goût du jour (ce qui inclut de pouvoir le contrôler depuis n’importe où dans le monde, mais je vous en dis pas plus, il faudra lire !).

Vous vous demandez surement quelle est la raison d’être de cet objet qui ne nous défendra pas de beaucoup d’ennemis. La réponse est simple : faire la guerre entre collègues au bureau (oui oui).

Et le lance-missile que j’ai récupéré a bel et bien servi ce but, mais il ne fonctionnait plus quand je l’ai récupéré. En plus, son contrôle se faisait par ordinateur avec une sombre logiciel sorti d’un autre siècle. C’est à ce moment que j’entre en scène : je vais vous partager dans cet article comment j’ai redonné vie à ce superbe lance-missile en lui installant une nouvelle électronique de commande, et comment je peux désormais le contrôler ! Let’s goooo

L’électronique

Je ne me suis pas embêté à essayer de comprendre le circuit imprimé actuel pour comprendre d’où venait la panne du lance-missile, et trouver le moyen de le contrôler sans son logiciel original.

Donc, j’ai démonté la partie commande pour ne garder qu’un assemblage en plastique avec quelques moteurs et capteurs. J’ai tout démonté pour comprendre le fonctionnement des mécanismes et mieux réussir la suite. Le principe est simple : un moteur tourne la base, un autre incline la tête et le dernier provoque le tir successif des trois missiles. Il y a des capteurs de fin de course pour les deux axes, un autre indiquant la position de l’axe qui tire les missiles et trois derniers pour détecter le chargement de chaque missile.

Conception du circuit

J’ai posé quelques contraintes avant de commencer à créer le circuit :

• avoir un microcontrôleur (ordinateur) programmable qui gérera la calibration et l’interfaçage avec des équipements externes (ordinateur, autre système) ;
• alimenter et communiquer avec le lance-missile en USB-C pour la connexion à un ordinateur ;
• avoir un autre port d’alimentation et de communication en UART avec le lance-missile pour le connecter au système de domotique de ma chambre (voir plus bas !) ;
• et évidemment pouvoir contrôler les moteurs et récupérer l’état des capteurs !

Ceci étant posé, j’ai commencé par choisir le microcontrôleur, et le choix aura été rapide. Je suis parti sur un Arduino Nano Every pour sa petite taille, et parce que c’est ce que j’ai en stock ^^. Il est largement suffisant pour l’usage que l’on en aura en termes de broches disponibles et de capacité de calcul/stockage.

Ensuite, un autre point est important : le contrôle des moteurs. On ne peut pas brancher un moteur directement sur un microcontrôleur, car ils ne sont faits que pour commander, pas alimenter (sauf pour les petites charges). Donc, j’ai ajouté un pont en H par moteur : il alimente les moteurs sur ordre de l’Arduino (direction et puissance). Le nom de ce composant vient de sa représentation schématique qui forme un H. Cette configuration permet d’actionner le moteur dans les deux sens.

Ici, on va utiliser un circuit intégré (CI), un L293D qui nous simplifiera la vie. Il suffit de connecter dessus alimentation, entrée (l’Arduino qui contrôle) et sortie (le moteur). Un CI intègre d’ailleurs deux ponts en H.

J’en suis venu au schéma suivant, qui est assez simple :

On retrouve les deux L293D à gauche qui gèrent les trois moteurs, l’Arduino à sa droite et les capteurs qui sont ni plus ni moins que des boutons sur la droite. Un des deux ports est connecté au Serial1, et l’autre au Serial qui vient du port USB de l’Arduino (ce port série n’a pas de broches exposées).

Réalisation du circuit

Maintenant que nous savons que faire, passons à l’action ! Les composants seront assemblés sur un circuit imprimé de prototypage. J’ai aussi prévu des connecteurs Dupont pour chaque composant externe afin de faciliter le démontage.

Je n’ai pas grand-chose d’autre à dire sur cette partie, c’est simplement de l’exécution avec un peu de rigueur pour pas faire d’erreurs qui pourraient être fâcheuses… Mais j’ai eu de la chance sur ce projet : rien n’a brulé !

Maintenant que notre lance-missile a un nouveau cœur, il faut lui donner une nouvelle âme, et ça passe par un peu de programmation !

Le logiciel

Pour ce projet, je vais développer plusieurs programmes qui travailleront ensemble :

• tout d’abord, il y a le programme du lance-missile en lui-même : il gèrera la communication avec l’extérieur, le déplacement, le tir et tout un système de calibration pour connaître la position de la tête et la présence des missiles à l’aide des capteurs ;
• ensuite, nous développerons une petite interface sur ordinateur pour contrôler le lance-missile, comme à l’époque !
• enfin, je programmerai une bibliothèque Arduino pour piloter le lance-missile très simplement depuis un autre Arduino (en l’occurrence : mon système de domotique).

Il était important de penser chaque composante logicielle en amont de leur développement pour s’assurer que tout s’emboitera parfaitement (c’est de l’anticipation quoi).

Avant d’aller plus loin, je vous partage ici le répertoire complet du projet avec une copie des programmes et la doc.

Le logiciel du lance-missile en lui-même

Attaquons par le plus important : le code de l’Arduino qui gère le lance-missile. C’est lui qui reçoit les ordres (USB, UART) et les informations (les capteurs), puis qui les transforme en actions (les moteurs).

Je ne vais pas rentrer dans les détails du programme, mais simplement vous expliquer dans les grandes lignes ses fonctions. Tout commence au démarrage : l’Arduino ne sait pas dans quelle position se situe la tête, donc il va se calibrer. Le principe est simple : les moteurs sont enclenchés jusqu’à entrer en butée, ce qui active le capteur de fin de course. À partir d’ici, l’Arduino connaît la position des deux axes. Après, le programme calculera l’évolution de sa position en fonction des ordres de déplacement pour toujours savoir où se situe la tête.

Par exemple : si on demande à la tête de tourner à 90°, l’Arduino calculera le temps qu’il faudra au moteur pour déplacer la tête à cet angle.

Et vous allez peut-être vous demander : mais il faut la vitesse de rotation pour calculer ce temps, non ? Exact ! C’est pour ça qu’en plus de la calibration nécessaire à chaque démarrage, j’ai implémenté une sorte se « super calibration » qui mesure les vitesses de déplacement et les enregistre dans la mémoire EEPROM (persistante au redémarrage). Pour cela, les deux axes se déplacent complètement d’une butée à l’autre. On peut mesurer le temps de déplacement pour l’angle connu (180° pour la rotation de la base, 45° pour l’inclinaison de la tête) et en déduire la vitesse.

Avec ce système de calibration, on connaît la position de la tête à chaque instant, ce qui est super pratique ! J’ai codé autour de ces infos des fonctions de déplacement absolu, relatif et pour un temps donné.

En plus de ça, j’ai quelques fonctions pour récupérer des états, notamment ceux des missiles. J’ai aussi des vérifications continues pour arrêter le mouvement en cas de butée, etc. Je vous laisse aller voir le programme sur GitHub si vous voulez en savoir plus !

Un dernier point intéressant sur ce programme est la communication en USB et UART. Le fonctionnement est identique dans le programme pour les deux. Le but était de pouvoir envoyer des messages au lance-missile pour qu’il effectue toutes les actions possibles, et qu’il remonte ses informations (état, position, missiles chargés). Pour qu’il y ait communication, il faut que les deux côtés parlent la même « langue » ! J’ai donc défini un protocole qui sera respecté par les deux parties pour se comprendre et échanger convenablement. Il est décrit en détail sur le README.md du dépôt GitHub, mais pour faire simple, je l’ai basé sur une combinaison de chiffres. Le premier chiffre désigne la commande : déplacement, tir de missile, récupération d’informations, etc. Ensuite, selon la commande, les chiffres suivants sont des paramètres de la commande, comme l’angle de rotation.

Exemple : avec l’extrait du protocole en image, envoyer le message 0201000\n aurait pour effet de déplacer la tête pendant une durée (0) en faisant une rotation vers la gauche (2) et pour une seconde (01000 – c’est en millisecondes). Le \n est un retour chariot, et il sert comme sur les machines à écrire à indiquer la fin de la ligne (ou la commande dans notre cas) !

Voilà pour cette partie programme un peu théorique, j’espère qu’elle ne vous aura pas perdue ! Maintenant, place au plus marrant

Un lance-missile contrôlé par ordinateur

C’est marrant de pouvoir contrôler le lance-missile par des commandes incompréhensibles comme 0201000\n (non en fait c’est pas marrant), mais le must serait d’avoir une interface de contrôle aux petits oignons directement sur l’ordinateur !

Je me suis donc lancé dans la conception d’une petite application toute simple qui comprend une fenêtre graphique et la communication avec le lance-missile en USB. Pour ça, j’ai choisi d’utiliser Python avec la bibliothèque de création d’interfaces customtkinter, et PySerial pour la communication.

Je ne vais pas du tout rentrer dans les détails du code ici, mais vous pouvez encore une fois aller le voir sur GitHub. Tout est contenu dans un fichier, et il y a pas mal d’espace occupé par la mise en page de l’interface.

Le résultat est très sympa, je vous laisse le confirmer par vous-même !

On peut donc déplacer la tête avec la croix directionnelle (mouvement relatif) mais aussi avec les curseurs pour définir une position absolue. Le bouton de fusée tire un missile, et on peut voir le chargement des munitions en dessous. Magnifique, non ? Et la cerise sur le gâteau, qui ne peut malheureusement pas se voir ici puisque c’est audio, c’est son joué au tir d’un missile (si vous cherchez sur le dépôt, vous pouvez le trouver ^^) !

La bibliothèque Arduino

Je vous avais dit que le logiciel de contrôle était le must, mais je vous ai menti : il n’y a pas mieux que ce que je vais vous présenter ici (rien que ça, oui).

On en revient encore une fois à notre protocole qui permet de communiquer avec le lance-missile depuis un autre système, et notamment un autre Arduino. Je pourrais donc envoyer des messages codés comme 0201000\n directement, mais ce ne serait pas très pratique ! Le mieux est de préparer une bibliothèque Arduino qui rendra son utilisation simple comme bonjour. Vous en trouverez d’ailleurs un exemple avec la bibliothèque en elle-même sur GitHub.

Le principe est assez-simple, on empaquette les commandes dans des fonctions qui ont des beaux noms et des paramètres. Pour notre exemple de 0201000\n, ça donnerait missileLauncher.timerMove(LEFT, 1000). Bien plus propre, non ?! La documentation d’utilisation de cette bibliothèque est détaillée dans le dépôt GitHub.

Je n’ai pas développé ce code dans le vide, non, j’avais une idée derrière tout ça : intégrer le lance-missile au système de domotique de ma chambre ! J’en ai parlé très rapidement sur la série d’articles à propos de ce projet, donc je vais détailler un peu plus ici.

Avec le lance-missile connecté en UART au système central de la domotique de ma chambre, je peux l’utiliser dans plein de cas différents :

• tout d’abord, lorsque l’alarme de ma chambre sonne (oui vous avez bien lu ^^ – j’en parle plus en détail ici), le lance-missile dirige sa tête vers l’entrée et tire ses trois missiles. Ça claque un peu quand ça sonne, d’autant plus qu’il y a avec une alarme puissante, un gyrophare, des lumières qui clignotent en rouge et mon assistant vocal qui parle !
• ensuite, je peux contrôler le lance-missile depuis le boîtier de contrôle de la chambre. J’utilise les touches du pavé numérique comme croix directionnelle. C’est un peu comme le logiciel de contrôle !
• et enfin, le must du must : le contrôle à distance, et oui mesdames messieurs. Comme mon système est relié au serveur de domotique Home Assistant, je peux, depuis n’importe où dans le monde, tirer des missiles ! Magnifique !

Conclusion

Et voilà, j’ai survolé tout ce que j’ai réalisé pour ce projet qui m’aura beaucoup amusé à faire. J’espère que cette lecture aura été tout autant intéressante !

Je laisse le mot de la fin à mon cher lance-missile qui vit sa plus belle vie avec mon système de domotique !