The Butter Robot : le robot Arduino à la crise existentielle : 6 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Ce projet est basé sur la série animée "Rick et Morty". Dans l'un des épisodes, Rick fabrique un robot dont le seul but est d'apporter du beurre. En tant qu'étudiants de Bruface (Faculté d'ingénierie de Bruxelles), nous avons une mission pour le projet mécatronique qui consiste à construire un robot basé sur un sujet suggéré. La mission de ce projet est: Fabriquer un robot qui ne sert que du beurre. Il peut y avoir une crise existentielle. Bien sûr le robot dans l'épisode de Rick et Morty est un robot assez complexe et quelques simplifications doivent être faites:

Comme son seul but est d'apporter du beurre, il existe des alternatives plus simples. Au lieu de faire en sorte que le robot regarde et attrape le beurre, avant qu'il ne l'apporte à la bonne personne, le robot peut transporter le beurre tout le temps. L'idée principale est donc de fabriquer un chariot qui transporte le beurre là où il doit être.

En plus de transporter le beurre, le robot doit savoir où il doit apporter le beurre. Dans l'épisode, Rick utilise sa voix pour appeler et commander le robot. Cela nécessite un système de reconnaissance vocale coûteux et serait trop compliqué. Au lieu de cela, tout le monde à table reçoit un bouton: une fois ce bouton activé, le robot peut localiser ce bouton et se déplacer vers lui.

Pour rappel, le robot doit remplir les conditions suivantes:

• Il doit être sûr: il doit éviter les obstacles et s'empêcher de tomber de la table;
• Le robot doit être petit: l'espace sur la table est limité et personne ne voudrait d'un robot qui sert du beurre mais qui fait la moitié de la taille de la table elle-même;
• Le fonctionnement du robot ne peut pas dépendre de la taille ou de la forme de la table, il peut donc être utilisé sur différentes tables;
• Il doit apporter le beurre à la bonne personne à table.

Étape 1: Concept principal

Les exigences mentionnées ci-dessus peuvent être satisfaites en utilisant différentes techniques. Les décisions concernant la conception principale qui ont été prises sont expliquées dans cette étape. Des détails sur la façon dont ces idées sont mises en œuvre peuvent être trouvés dans les étapes suivantes.

Pour accomplir son devoir, le robot doit se déplacer jusqu'à ce que la destination soit atteinte. Compte tenu de l'application du robot, il est évident qu'il est préférable d'utiliser des roues au lieu d'un mouvement de « marche » pour le faire bouger. Étant donné qu'une table est une surface plane et que le robot n'atteindra pas des vitesses très élevées, deux roues actionnées et une roulette à billes sont la solution la plus simple et la plus facile à contrôler. Les roues actionnées doivent être alimentées par deux moteurs. Les moteurs doivent avoir un couple important mais ils n'ont pas besoin d'atteindre une vitesse élevée, c'est pourquoi des servomoteurs continus seront utilisés. Un autre avantage des servomoteurs est la simplicité d'utilisation avec un Arduino.

La détection d'obstacles peut se faire à l'aide d'un capteur à ultrasons qui mesure la distance, relié à un servomoteur pour choisir la direction de la mesure. Les bords peuvent être détectés à l'aide de capteurs LDR. L'utilisation de capteurs LDR nécessitera la construction d'un appareil contenant à la fois une lumière LED et un capteur LDR. Un capteur LDR mesure la lumière réfléchie et peut être considéré comme une sorte de capteur de distance. Le même principe existe avec la lumière infrarouge. Il existe des capteurs de proximité infrarouges qui ont une sortie numérique: fermé ou non fermé. C'est exactement ce dont le robot a besoin pour détecter les bords. En combinant 2 capteurs de bord placés comme deux antennes insectes et un capteur à ultrasons actionné, le robot devrait pouvoir éviter les obstacles et les bords.

La détection des boutons peut également être réalisée en utilisant des capteurs IR et des leds. L'avantage de l'IR est qu'il est invisible ce qui rend son utilisation non gênante pour les personnes à table. Des lasers pourraient également être utilisés, mais la lumière serait alors visible et également dangereuse lorsque quelqu'un pointe le laser dans l'œil d'une autre personne. De plus, l'utilisateur aurait besoin de cibler les capteurs du robot avec seulement un mince faisceau laser, ce qui serait assez ennuyeux. En équipant le robot de deux capteurs IR et en construisant le bouton avec une LED IR, le robot sait dans quelle direction il doit aller en suivant l'intensité de la lumière IR. Lorsqu'il n'y a pas de bouton, le robot peut se retourner jusqu'à ce qu'une des LED capte le signal de l'un des boutons.

Le beurre est mis dans un compartiment sur le dessus du robot. Ce compartiment peut être constitué d'une boîte et d'un couvercle actionné pour ouvrir la boîte. Pour ouvrir le couvercle et déplacer le capteur à ultrasons pour scanner et détecter les obstacles, nous avons besoin de deux moteurs et pour cela, les servomoteurs non continus sont plus adaptés car les moteurs doivent aller à une certaine position et maintenir cette position.

Une fonctionnalité supplémentaire du projet était d'interagir avec l'environnement externe avec une voix de robot. Un buzzer est simple et adapté à cet effet mais il ne peut être utilisé à aucun moment car le tirage courant est élevé.

La principale difficulté du projet réside dans le codage, car la partie mécanique est assez simple. De nombreux cas doivent être pris en compte pour éviter que le robot ne se coince ou fasse quelque chose d'indésiré. Les principaux problèmes que nous devons résoudre sont la perte du signal IR à cause d'un obstacle et l'arrêt lorsqu'il arrive au niveau du bouton !

Étape 2: Matériaux

Parties mécaniques

• Imprimante 3D et machine de découpe laser

  • Le PLA sera utilisé pour l'impression 3D mais vous pouvez également utiliser l'ABS
  • Une plaque de contreplaqué de bouleau de 3 mm sera utilisée pour la découpe laser car elle permet de faire des modifications plus tard facilement, le plexiglas peut également être utilisé mais il est plus difficile de le modifier une fois découpé au laser sans le détruire

• Boulons, écrous, rondelles

  La plupart des composants sont maintenus ensemble à l'aide de boulons à tête ronde M3, de rondelles et d'écrous, mais certains d'entre eux nécessitent un jeu de boulons M2 ou M4. La longueur des boulons est comprise entre 8 et 12 mm

• Entretoises PCB, 25 mm et 15 mm
• 2 servomoteurs avec roues compatibles
• Du fil métallique épais d'environ 1-2 mm de diamètre

Parties éléctroniques

• Microcontrôleur

  1 carte arduino UNO

• Servomoteurs

  • 2 grands servomoteurs: Feetech continu 6Kg 360 degrés
  • 2 micro servomoteurs: Feetech FS90

• Capteurs

  • 1 capteur à ultrasons
  • 2 capteurs de proximité IR
  • 2 photodiodes IR

• Piles

  • 1 porte-pile 9V + pile
  • 1 porte-piles 4AA + piles
  • 1 boitier pile 9V + pile

• Composants supplémentaires

  • Quelques fils sauteurs, fils et plaques à souder
  • Quelques résistances
  • 1 DEL infrarouge
  • 3 interrupteurs
  • 1 sonnerie
  • 1 bouton
  • 1 connecteur de batterie Arduino vers 9V

Étape 3: Test de l'électronique

Création du bouton:

Le bouton est simplement constitué d'un interrupteur, d'une LED infrarouge, et d'une résistance de 220 Ohm en série, alimentée par une pile 9V. Ceci est mis dans une batterie 9V pour un design compact et propre.

Création des modules récepteurs infrarouges:

Ces modules sont fabriqués avec des cartes à souder à trous traversants, qui seront ensuite fixées avec des vis au robot. Les circuits de ces modules sont représentés dans les schémas généraux. Le principe est de mesurer l'intensité de la lumière infrarouge. Pour améliorer les mesures, des collimateurs (fabriqués avec des tubes thermorétractables) peuvent être utilisés pour se concentrer sur une certaine direction d'intérêt.

Différentes exigences du projet doivent être accomplies à l'aide d'appareils électroniques. Le nombre de dispositifs doit être limité afin de garder une complexité relative faible. Cette étape contient les schémas de câblage et chaque code pour tester toutes les pièces séparément:

• Servomoteurs continus;
• Capteur à ultrasons;
• Servomoteurs non continus;
• Avertisseur sonore;
• Détection de la direction du bouton IR;
• Détection des bords par capteurs de proximité;

Ces codes peuvent aider à comprendre les composants au début, mais ils sont également très utiles pour le débogage à des étapes ultérieures. Si un certain problème survient, le bogue peut être détecté plus facilement en testant tous les composants séparément.

Étape 4: Conception de pièces imprimées en 3D et découpées au laser

Pièces découpées au laser

L'assemblage est composé de trois plaques horizontales principales maintenues ensemble par des entretoises PCB pour obtenir une conception ouverte offrant un accès facile à l'électronique si nécessaire.

Ces plaques doivent avoir les trous nécessaires pour visser les entretoises et autres composants pour l'assemblage final. Principalement, les trois plaques ont des trous au même endroit pour les entretoises, et des trous spécifiques pour l'électronique fixés respectivement sur chaque plaque. Notez que la plaque du milieu a un trou pour faire passer les fils au milieu.

Des pièces plus petites sont coupées aux dimensions du grand servo pour les fixer à l'ensemble.

Pièces imprimées en 3D

En plus de la découpe laser, certaines pièces devront être imprimées en 3D:

• Le support du capteur à ultrasons, qui le relie à un bras de micro servomoteur
• Le support de la roulette et des deux capteurs de bord IR. La conception particulière du type d'extrémités en forme de boîte de la pièce pour les capteurs IR agit comme un écran pour éviter les interférences entre le bouton émettant un signal IR et les capteurs IR qui doivent se concentrer sur ce qui se passe au sol uniquement
• Le support pour le micro servomoteur ouvrant le couvercle

• Et enfin le couvercle lui-même, composé de deux pièces pour avoir un plus grand angle de fonctionnement en évitant les collisions avec le micro servomoteur ouvrant le couvercle:

  • Celui du bas qui sera fixé à la plaque du haut
  • Et le haut qui est relié au bas par une charnière, et actionné par le servo à l'aide d'un fil métallique épais. Nous avons décidé d'ajouter un peu de personnalité au robot en lui donnant une tête.

Une fois toutes les pièces conçues et les fichiers exportés au bon format pour les machines utilisées, les pièces peuvent effectivement être fabriquées. Sachez que l'impression 3D prend beaucoup de temps, notamment avec les dimensions de la partie supérieure du couvercle. Vous pourriez avoir besoin d'un ou deux jours pour imprimer toutes les pièces. La découpe au laser n'est cependant qu'une question de minutes.

Tous les fichiers SOLIDWORKS se trouvent dans le dossier zippé.

Étape 5: Assemblage et câblage

L'assemblage sera un mélange de câblage et de vissage des composants ensemble, en partant du bas vers le haut.

Plaque inférieure

La plaque inférieure est assemblée avec la batterie 4AA, les servomoteurs, la partie imprimée (fixation de la roulette à billes sous la plaque), les deux capteurs de bord et 6 entretoises mâle-femelle.

Plaque médiane

Ensuite, la plaque médiane peut être montée, comprimant les servomoteurs entre les deux plaques. Cette plaque peut ensuite être fixée en plaçant un autre jeu d'entretoises dessus. Certains câbles peuvent être passés à travers le trou central.

Le module à ultrasons peut être attaché à un servo non continu, qui est fixé sur la plaque centrale avec l'Arduino, la batterie 9V (alimentant l'arduino) et les deux modules récepteurs infrarouges à l'avant du robot. Ces modules sont fabriqués avec des cartes à souder à trous traversants et fixés avec des vis à la plaque. Les circuits de ces modules sont représentés dans les schémas généraux.

La plaque supérieure

A cette partie du montage, les interrupteurs ne sont pas fixes mais le robot peut déjà tout faire sauf des actions nécessitant le couvercle, cela nous permet donc de faire quelques tests pour corriger le seuil, d'adapter le code du mouvement et d'avoir un accès aux ports de l'arduino.

Lorsque tout cela est réalisé, la plaque supérieure peut être fixée avec des entretoises. Les derniers composants que sont les deux interrupteurs, le bouton, le servo, le buzzer et le système de couvercle peuvent enfin être fixés sur la plaque supérieure pour terminer l'assemblage.

La dernière chose à tester et à corriger est l'angle du servo pour ouvrir correctement le couvercle.

Le seuil des capteurs de bord doit être adapté avec le potentiomètre inclus (à l'aide d'un tournevis plat) pour différentes surfaces de table. Une table blanche doit avoir un seuil plus bas qu'une table marron par exemple. De plus, la hauteur des capteurs influencera le seuil nécessaire.

A la fin de cette étape, l'assemblage est terminé et la dernière pièce restante est les codes manquants.

Étape 6: Codage: tout mettre en place

Tout le code nécessaire pour faire fonctionner le robot se trouve dans le fichier zippé téléchargeable. Le plus important est le code "principal" qui comprend la configuration et la boucle fonctionnelle du robot. La plupart des autres fonctions sont écrites dans des sous-fichiers (également dans le dossier zippé). Ces sous-fichiers doivent être enregistrés dans le même dossier (nommé "principal") que le script principal avant de le télécharger sur l'Arduino

Tout d'abord, la vitesse générale du robot est définie avec la variable "rappel". Ce "rappel" est une valeur qui se souvient dans quelle direction le robot tournait. Si "rappel = 1", le robot tournait/tournait à gauche, si "rappel = 2", le robot tournait/tournait à droite.

vitesse int = 9; // Vitesse générale du robot

int rappeler = 1; // Sens initial

Dans la configuration du robot, les différents sous-fichiers du programme sont initialisés. Dans ces sous-fichiers, sont écrites les fonctions de base sur le contrôle des moteurs, capteurs, …. En les initialisant dans le setup, les fonctions qui sont décrites dans chacun de ces fichiers peuvent être utilisées dans la boucle principale. En activant la fonction r2D2(), le robot fera un bruit comme le robot R2D2 de la franchise de films Star Wars quand ça démarre. Ici, la fonction r2D2() est désactivée pour éviter que le buzzer ne consomme trop de courant.

//Configuration @ reset//----------------

void setup(){ initialize_IR_sensors(); initialize_obstacles_and_edges(); initialize_movement(); initialize_lid(); initialize_buzzer(); // r2D2(); int rappeler = 1; // direction initiale Starter(rappel); }

La fonction Démarreur (rappel) est d'abord sollicitée dans l'installation. Cette fonction fait se retourner le robot et chercher le signal IR de l'un des boutons. Une fois qu'il a trouvé le bouton, le programme quittera la fonction Starter en changeant la variable 'cond' en false. Pendant la rotation du robot, il doit être conscient de son environnement: il doit détecter les bords et les obstacles. Ceci est vérifié à chaque fois avant de continuer à tourner. Une fois que le robot détecte un obstacle ou un bord, le protocole pour éviter ces obstacles ou bords sera exécuté. Ces protocoles seront expliqués plus loin dans cette étape. La fonction Starter a une variable qui est la variable de rappel qui a été discutée précédemment. En donnant la valeur de rappel à la fonction Starter, le robot sait dans quelle direction il doit tourner pour chercher le bouton.

//Loop de démarrage: Faites demi-tour et recherchez le bouton //------------------------------------ ----------------

void Starter(int rappelle) { if (isedgeleft() || isedgeright()) { // Détecte les bords edgeDetected(remind); } else { bool cond = vrai; while (cond == true) { if (buttonleft() == false && buttonright() == false && isButtonDetected() == true) { cond = false; } else { if (rappel == 1) { // Nous tournions à gauche if (isobstacleleft()) { stopspeed(); éviter_obstacle(rappeler); } else if (isedgeleft() || isedgeright()) { // Détecte les bords edgeDetected (rappel); } else { tourner à gauche (vitesse); } } else if (rappel == 2) { if (isobstacleright()) { stopspeed(); éviter_obstacle(rappeler); } else if (isedgeleft() || isedgeright()) { // Détecte les bords edgeDetected (rappel); } else { tourner à droite (vitesse); } } } } } }

Si le robot trouve le bouton, la première boucle de démarrage est terminée et la boucle fonctionnelle principale du robot commence. Cette boucle principale est assez complexe puisqu'à chaque fois, le robot a besoin de détecter s'il y a ou non un obstacle ou un bord devant lui. L'idée principale est que le robot suive le bouton en le trouvant et en le perdant à chaque fois. En utilisant deux capteurs IR, on peut distinguer trois situations:

• la différence entre la lumière IR détectée par les capteurs gauche et droit est supérieure à un certain seuil, et il y a un bouton.
• la différence de lumière IR est inférieure au seuil et il y a un bouton devant le robot.
• la différence de lumière IR est inférieure au seuil et il n'y a AUCUN bouton devant le robot.

Le fonctionnement de la routine de suivi est le suivant: lorsque le bouton est détecté, le robot se déplace vers le bouton en tournant dans la même direction qu'il tournait (en utilisant la variable de rappel) et en même temps avance un peu. Si le robot tourne trop loin, le bouton sera à nouveau perdu et à ce stade, le robot se rappelle qu'il doit tourner dans l'autre sens. Cela se fait aussi en avançant un peu. En faisant cela, le robot tourne constamment à gauche et à droite, mais en attendant il avance toujours vers le bouton. Chaque fois que le robot trouve le bouton, il continue de tourner jusqu'à ce qu'il l'ait perdu, auquel cas il commence à se déplacer dans l'autre sens. Remarquez la différence de fonctions qui sont utilisées dans la boucle de démarrage et la boucle principale: la boucle de démarrage utilise "turnleft()" ou "turnright()", tandis que la boucle principale utilise "moveleft()" et "moveright()". Les fonctions moveleft/right ne font pas seulement tourner le robot mais le font aussi avancer en même temps.

/* Boucle fonctionnelle ---------------------------- Ici, il n'y a que la routine track */

entier perdu = 0; // Si perdu = 0 le bouton est trouvé, si perdu = 1 le bouton est perdu void loop() { if (isedgeleft() || isedgeright()) {

si (!isobstacle()) {

avancer (vitesse); retard(5); } else { éviter_obstacle(rappeler); } else {if (rappel == 1 && lost == 1) { // Nous tournions à gauche stopspeed(); if (!isobstacleright()) { moveright(vitesse); // Faites demi-tour pour trouver le bouton } else { Avoid_obstacle(remind); } rappeler = 2; } else if (rappel == 2 && lost == 1) { stopspeed(); if (!isobstacleleft()) { moveleft(vitesse); //Nous tournions à droite } else { Avoid_obstacle(rappel); } rappeler = 1; }else if (lost == 0) { if (rappel == 1) { // Nous tournions à gauche if (!isobstacleleft()) { moveleft(speed); //Nous tournions à droite } else { stopspeed(); éviter_obstacle(rappeler); } // } else if (rappel == 2) { if (!isobstacleright()) { moveright(speed); // Faites demi-tour pour trouver le bouton } else { stopspeed(); éviter_obstacle(rappeler); } } } délai(10); perdu = 0; } } //} }

Maintenant, une petite explication des deux routines les plus complexes est donnée:

Eviter les bords

Le protocole pour éviter les bords est défini dans une fonction appelée "edgeDetection()" qui est écrite dans le sous-fichier "mouvement". Ce protocole repose sur le fait que le robot ne doit rencontrer une arête que lorsqu'il a atteint sa destination: le bouton. Une fois que le robot détecte un bord, la première chose qu'il fait est de reculer un peu pour être à une distance sûre du bord. Une fois cela fait, le robot attend 2 secondes. Si quelqu'un appuie sur le bouton à l'avant du robot pendant ces deux secondes, le robot sait qu'il a atteint la personne qui veut le beurre et ouvre le compartiment à beurre et présente le beurre. À ce stade, quelqu'un peut prendre du beurre du robot. Au bout de quelques secondes, le robot se fatiguera d'attendre et se contentera de fermer le couvercle du beurre. Une fois le couvercle fermé, le robot exécute la boucle de démarrage pour rechercher un autre bouton. S'il arrive que le robot rencontre un bord avant d'atteindre sa destination et que le bouton à l'avant du robot n'est pas enfoncé, le robot n'ouvrira pas le couvercle du beurre et exécutera immédiatement la boucle de démarrage.

Éviter les obstacles

La fonction Avoid_obstacle() est également située dans le sous-fichier "mouvement". La difficulté à éviter les obstacles est le fait que le robot a un angle mort assez important. Le capteur à ultrasons est placé à l'avant du robot, ce qui signifie qu'il peut détecter les obstacles, mais ne sait pas quand il est passé. Pour résoudre ce problème, le principe suivant est utilisé: Une fois que le robot rencontre un obstacle, il utilise la variable reming pour tourner dans l'autre sens. De cette façon, le robot évite de heurter l'obstacle. Le robot continue de tourner jusqu'à ce que le capteur à ultrasons ne détecte plus l'obstacle. Pendant le temps que le robot tourne, un compteur est augmenté jusqu'à ce que l'obstacle ne soit plus détecté. Ce compteur donne alors une approximation de la longueur de l'obstacle. En avançant puis en diminuant en même temps le compteur, l'obstacle peut être évité. Une fois que le compteur atteint 0, la fonction Starter peut être à nouveau utilisée pour déplacer le bouton. Bien sûr, le robot effectue la fonction de démarrage en tournant dans la direction dans laquelle il se souvenait qu'il allait avant de rencontrer l'obstacle (en utilisant à nouveau la variable de rappel).

Maintenant que vous comprenez parfaitement le code, vous pouvez commencer à l'utiliser !

Veillez à adapter les seuils à votre environnement (la réflexion IR est plus élevée sur les tableaux blancs par exemple) et à adapter les différents paramètres à vos besoins. Aussi, une grande attention doit être accordée à l'alimentation des différents modules. Il est primordial que les servomoteurs ne soient pas alimentés par le port Arduino 5V, car ils consomment beaucoup de courant (cela pourrait endommager le microcontrôleur). Si la même source d'alimentation est utilisée pour les capteurs que celle pour alimenter les servos, des problèmes de mesure peuvent être rencontrés.