Robot Hexapode Fourmi Arduino

Dans ce tutoriel, je vais vous montrer comment j'ai construit un hexapode Arduino. Comme son nom l'indique, l'hexapode a 6 pattes mais en plus de cela, il a aussi une queue ou abdomen, une tête, des antennes, des mandibules et même des yeux fonctionnels. Tout cela fait ressembler l'hexapode à une fourmi, nous pouvons donc aussi l'appeler un robot fourmi Arduino.

Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.

Aperçu

Pour contrôler le robot, j'ai créé une application Android sur mesure. L'application dispose de 4 boutons à travers lesquels nous pouvons commander au robot d'avancer ou de reculer, ainsi que de tourner à gauche ou à droite. En plus de ces fonctions principales, le robot peut également bouger la tête et la queue, ainsi qu'il peut mordre, saisir et laisser tomber des objets et même attaquer.

Comme je l'ai mentionné plus tôt, le robot a des yeux fonctionnels, ou j'ai spécifiquement conçu la tête pour s'adapter à un capteur à ultrasons. Donc, si nous essayons de toucher la tête du robot ou de rapprocher notre main du capteur, le robot se préparera initialement à une attaque.

Si nous reculons, le robot rejettera l'attaque, mais si nous rapprochons notre main, il nous attaquera et nous mordra. Alors, c'est cool ? Restez dans les parages et vous découvrirez exactement comment je le construis et comment tout fonctionne.

Arduino Hexapod - Modèle 3D de robot fourmi

Comme d'habitude, j'ai commencé par concevoir l'hexapode à l'aide d'un logiciel de modélisation 3D. L'hexapode a 6 pattes et chacune d'elles se compose de 3 articulations ou 3 servos. Cela signifie que nous avons besoin d'un total de 18 servos et dans mon cas, j'ai utilisé les servos MG996R.

À l'arrière, nous avons la queue qui est entraînée par un autre servo MG996R. La tête de ce robot fourmi a deux degrés de liberté, ou elle peut rouler et s'incliner, et encore une fois, elle est entraînée par deux autres servos. Nous avons donc besoin d'un total de 21 servos pour ce projet, de type MG996R et en plus d'un micro servo SG90 plus petit pour les mandibules.

Ici, nous avons également les yeux de la fourmi qui sont conçus pour s'adapter à un capteur à ultrasons HC-SR04. Toutes les pièces sont assemblées entre deux plaques et en plus j'ai fait un couvercle incurvé intéressant pour la plaque supérieure afin de cacher tout le câblage, l'Arduino et la batterie entre les deux plaques.

Vous pouvez trouver et télécharger ce modèle 3D, ainsi que l'explorer dans votre navigateur sur Thangs.

Fichiers STL :

Impression 3D des pièces

Je suppose que vous savez déjà ce qui va suivre, et c'est l'impression 3D des pièces du robot. J'ai utilisé l'imprimante 3D Creality CR-10 pour toutes les impressions et elle a fait un excellent travail. La partie la plus difficile à imprimer était la tête, car je voulais être une seule empreinte.

Pour cela, j'ai dû utiliser un angle de surplomb de support de 60 degrés ainsi que des bloqueurs de support. Quoi qu'il en soit, le Creality CR-10 a fait un excellent travail et la tête s'est avérée parfaite.

Assemblage de l'hexapode Arduino

Une fois toutes les pièces imprimées, nous pouvons passer à l'assemblage de l'hexapode. J'ai commencé par assembler les jambes. Pour fixer les servos aux pièces imprimées, j'ai utilisé des boulons et des écrous M3, ainsi que des rondelles élastiques. La longueur des boulons doit être d'au moins 12 mm et dans mon cas, j'ai utilisé des boulons de 16 mm de long.

Nous avons besoin d'environ 200 boulons pour l'ensemble de l'assemblage. Pour connecter les maillons les uns aux autres, nous utilisons les cornes rondes fournies avec le kit servo comme accessoires. Cependant, nous devons percer des trous de 3 mm sur chacun d'eux pour que les boulons puissent passer à travers, ou nous pouvons utiliser des cornes rondes en métal qui ont des filetages M3 et peuvent être achetées séparément.

Lors de la fixation des liaisons aux servos, nous devons nous assurer que nous les connectons toujours à la même position et qu'ils ont toute l'amplitude de mouvement.

Il faut remarquer ici que les servos ont un petit support triangulaire sur la face supérieure qui doit être retiré. J'ai utilisé un simple couteau utilitaire pour le faire, de cette façon, les servos peuvent être placés en flash avec les pièces imprimées. Avant d'insérer le troisième servo en place, nous devons d'abord insérer un boulon M4 qui sera utilisé pour connecter la jambe à la plaque de base.

Voici à quoi devrait ressembler l'assemblage des jambes. C'est en fait très facile à assembler, mais maintenant nous en avons besoin de cinq autres.

Une fois que toutes les jambes sont prêtes, nous pouvons passer à leur installation sur le corps du robot ou sur les deux plaques. Nous devons d'abord fixer les cornes rondes sur la plate-forme supérieure en utilisant la même méthode que précédemment, avec des boulons et des écrous M3. Ensuite, nous pouvons simplement les connecter aux axes des servos à l'aide des boulons, mais avant cela, nous devons ajuster la position des servos pour qu'ils soient exactement au milieu.

Ceci est nécessaire pour que nous puissions obtenir la gamme complète de mouvement des servos et réduira également le processus de réglage ou d'étalonnage lors de la programmation de l'Arduino.

Après avoir sécurisé les jambes, ce projet a déjà commencé à prendre forme et à ressembler à un hexapode.

Il y a un autre klaxon rond à l'arrière et c'est pour le servo de queue qui doit également être sécurisé à ce point.

Ensuite, nous devons placer l'hexapode à l'envers et ainsi nous pourrons insérer la plaque inférieure à travers les boulons M4 des jambes. Ensuite, j'ai fixé les pieds à l'aide de rondelles plates et d'écrous autobloquants. Nous devons faire attention à combien nous serrons ces boulons car ce sont en fait les joints de pivot et les jambes doivent également pouvoir tourner tout en étant suffisamment sécurisées.

Ensuite, nous devons installer le premier servo pour la tête et c'est pour le mouvement de roulis. Ce servo doit être placé perpendiculairement aux plaques de base, donc à cet effet j'ai fait deux petites plaques qui sont d'abord fixées au servo. Ensuite, nous pouvons insérer le servo entre les deux plaques et nous pouvons facilement le fixer avec les boulons et écrous M3.

Ensuite, nous avons un support en forme de U et ici nous devons attacher deux cornes rondes pour connecter les deux servos pour la tête. Encore une fois, avant de fixer le support au servo de roulis, nous devons nous assurer que la position du servo est au milieu afin qu'il puisse pivoter de 90 degrés dans les deux sens.

Vient ensuite le support du servo d'inclinaison. Donc, ici, nous devons d'abord insérer un boulon M4 et le fixer au support en forme de U. Avant de monter le moteur d'inclinaison, nous devons également insérer quatre boulons M3 qui seront ensuite utilisés pour fixer la tête. Ensuite, nous pouvons insérer le servo d'inclinaison dans le support et ajuster soigneusement l'arbre au cornet rond. C'est un peu serré ici, mais le support en forme de U peut utilement fléchir un peu.

Enfin, nous devons fixer le servo avec les boulons M3 et avec cela le mécanisme de la tête est terminé. Désormais, il peut à la fois rouler et s'incliner.

Avant de fixer la tête au mécanisme, nous devons le préassembler ou fixer les mandibules avec le petit servo SG90 et le capteur à ultrasons. Encore une fois, c'est un peu serré ici, mais j'ai quand même réussi à insérer la première mandibule et à la fixer à la tête à l'aide d'un boulon M4.

Vous pouvez remarquer qu'il y a un petit trou au niveau des yeux qui est spécialement conçu pour que nous puissions passer à travers un tournevis pour serrer le boulon.

Vient ensuite le micro servo en place et il est fixé à l'aide de deux vis. Sur la deuxième mandibule, nous devons d'abord attacher un petit bras pour le servo SG90.

Ensuite, nous pouvons insérer la mandibule en place, coupler les deux engrenages et la fixer à l'arbre du moteur à l'aide d'un tournevis.

Ensuite, nous pouvons mettre le capteur à ultrasons en place. Les trous pour les yeux sont faits exactement pour s'adapter au capteur à ultrasons, j'ai donc simplement utilisé quelques gouttes de colle AC pour fixer le capteur à la tête.

Il y a encore un détail à ajouter à la tête et ce sont les antennes. Pour cela, j'ai utilisé du fil à tique de 3 mm, que j'ai coupé à environ 13 cm de longueur et que j'ai légèrement plié pour obtenir la forme souhaitée. Encore une fois, j'ai utilisé quelques gouttes de colle AC pour les fixer à la tête. Enfin, nous pouvons fixer la tête au mécanisme de roulis et d'inclinaison avec les quatre boulons que nous avons insérés précédemment.

La tête est maintenant entièrement fonctionnelle, elle peut rouler, s'incliner et même mordre. Il y a deux autres pièces imprimées en 3D à installer. C'est la queue qui peut simplement glisser dans le support de queue et le couvercle incurvé que nous utiliserons à la fin pour couvrir l'électronique. C'est donc l'apparence finale de notre robot fourmi et j'aime vraiment la façon dont il s'est avéré dans cette combinaison de couleurs bleu et blanc.

Schéma du circuit du robot Arduino Ant

Ok, maintenant nous pouvons passer à l'électronique. Voici le schéma de circuit de ce projet qui est en fait simple bien qu'il semble un peu complexe à cause des nombreuses connexions de servos.

Outre les 22 servos, nous avons besoin d'un module Bluetooth HC-05 pour la communication avec le smartphone et de quelques condensateurs et résistances. Bien sûr, le cerveau du robot est une carte Arduino, et dans ce cas, c'est l'Arduino Mega car c'est la seule carte qui peut contrôler plus de 12 servos à l'aide de la bibliothèque Servo.

Tutoriel connexe : Comment fonctionnent les servomoteurs et comment contrôler les servomoteurs à l'aide d'Arduino

Pour alimenter le robot, j'utiliserai une batterie LiPo 3S qui a une tension d'environ 12V. Les batteries LiPo peuvent gérer une plus grande quantité de courant, elles conviennent donc à ce projet car si tous les servos sont engagés en même temps à pleine charge, ils peuvent tirer environ 10 ampères de courant. Cependant, la tension de fonctionnement des servos est limitée de 4,8 à 7,2 V, ce qui signifie que je dois utiliser un convertisseur abaisseur DC-DC pour convertir le 12 V en 5 V. Même si nous utilisons une batterie LiPo 2S qui a une tension d'environ 7,4 V ou 8,4 V lorsqu'elle est complètement chargée, nous devons toujours utiliser un convertisseur abaisseur. Le convertisseur abaisseur que j'utiliserai pour ce projet peut gérer jusqu'à 8 ampères de courant, mais je recommanderais d'en utiliser un de 10 à 15 A juste pour être sûr que vous aurez assez de puissance et qu'il ne surchauffera pas. Dans mon cas, la consommation de courant maximale que j'ai remarquée du robot lors du déplacement était d'environ 6 ampères.

Vous pouvez obtenir les composants nécessaires à ce projet à partir des liens ci-dessous :

• Servomoteur MG996R……………………….….
• Micro servomoteur SG90 ……..…….….…….
• Module Bluetooth HC-05 ………………….… 
• Carte Méga Arduino ……………………….….
• Batterie LiPo 3S ………………………..……….. 
• Convertisseur abaisseur CC-CC ……………………….

Conception d'un PCB pour l'Arduino Hexapod

Maintenant, si nous essayons de tout connecter ensemble, ce sera tout un gâchis à cause des nombreuses connexions servo. Par conséquent, j'ai conçu un circuit imprimé personnalisé à l'aide du logiciel de conception de circuits en ligne gratuit EasyEDA. Ce PCB agira en fait comme un Arduno Mega Shield pour l'Hexapode car nous pourrons le connecter directement au-dessus de l'Arduino Mega Board. J'ai disposé les connexions des servos les unes à côté des autres et j'ai inclus deux gros condensateurs à côté d'eux pour maintenir la tension plus stable. J'ai également inclus une connexion pour un module émetteur-récepteur NRF24L01 au cas où nous voudrions contrôler le robot à l'aide d'une radiocommande. Il existe plusieurs connexions à broches numériques et analogiques, des connexions 5V et de masse, deux connexions LED, ainsi qu'une connexion pour la surveillance de la tension de la batterie. La tension de la batterie 12V passera par un diviseur de tension composé de deux résistances R1 et R2 qui réduira la tension en dessous de 5V afin que la broche analogique puisse la lire en toute sécurité. De cette façon, nous saurons quand la batterie devra être rechargée.

Voici un lien vers les fichiers de projet de cette conception de PCB. Donc une fois la conception terminée, j'ai généré le fichier Gerber nécessaire à la fabrication du PCB.

Fichier Gerber :

Ensuite, j'ai commandé le PCB à JLCPCB qui est en fait le sponsor de cette vidéo.

Ici, nous pouvons simplement faire glisser et déposer le fichier Gerber et une fois téléchargé, nous pouvons revoir notre PCB dans la visionneuse Gerber. Si tout va bien, nous pouvons continuer et sélectionner les propriétés que nous voulons pour notre PCB. Dans ce cas, j'ai choisi la couleur du PCB pour qu'elle soit bleue afin de correspondre à la couleur de la carte Arduino. Et voilà, maintenant nous pouvons commander simplement notre PCB à un prix raisonnable. Notez que s'il s'agit de votre première commande auprès de JLCPCB, vous pouvez obtenir jusqu'à 10 PCB pour seulement 2 $.

Après plusieurs jours, les PCB sont arrivés. La qualité des PCB est excellente et tout est exactement comme dans la conception.

Assemblage du PCB

Ok, maintenant nous pouvons passer à autre chose et assembler le PCB. J'ai commencé par souder des en-têtes de broches mâles au PCB qui sont utilisés pour le connecter à la carte Arduino. Une fois que nous avons placé les en-têtes de broches sur le côté inférieur, nous pouvons utiliser une sorte de plaque pour tenir les broches et retourner le tableau. Maintenant, nous devons tous les souder au PCB. Une fois cela terminé, nous pouvons passer aux connexions servo pour lesquelles nous avons également besoin d'en-têtes de broches mâles.

À ce stade, nous pouvons réellement insérer les en-têtes de broches pour toutes les connexions et utiliser la même méthode pour retourner le PCB et y souder toutes les broches. À la fin, nous devons souder les résistances, les condensateurs et les borniers. Et voilà, l'Arduino Mega Shield pour notre Ant Robot est maintenant prêt. Maintenant, nous pouvons simplement l'insérer sur la carte Arduino.

Ensuite, nous devons régler la tension de sortie du convertisseur abaisseur sur 5V. Nous pouvons le faire en ajustant le potentiomètre du convertisseur abaisseur. Vous pouvez remarquer ici que j'ai ajouté un interrupteur d'alimentation à l'entrée et connecté la batterie 12V à la broche 12V sur le PCB qui ne sera utilisée que pour surveiller la tension de la batterie.

N'oubliez pas que l'entrée principale du PCB doit être de 5 V.

Nous pouvons donc maintenant insérer les composants électroniques entre les deux plaques. Encore une fois, c'est un peu serré, mais nous pouvons tout mettre en place. D'abord, la batterie que je l'ai sécurisée à l'aide d'un ruban adhésif, et en plus, l'Arduino avec le PCB que nous avons fabriqué. Ensuite, nous pouvons connecter l'émetteur-récepteur NRF24L01 ou simplement le module Bluetooth en fonction du type de communication que nous utiliserons. J'ai également inséré une LED pour indiquer quand la batterie doit se recharger, ou si la tension chute en dessous de 11V volts. Enfin, nous devons connecter tous les servos aux broches des servos. Tout en faisant cela, assurez-vous d'écrire à quel numéro de broche vous avez connecté chaque servo. Après avoir connecté tous les servos, nous pouvons simplement mettre le couvercle incurvé sur la plaque supérieure et nous en avons terminé avec ce projet.

Code hexapode Arduino

Ce qu'il reste à faire dans cette vidéo, c'est de voir comment fonctionne le programme Arduino. Comme le code est un peu plus long, pour une meilleure compréhension, je posterai le code source du programme dans des sections avec une description pour chaque section. Et à la fin de cet article, je posterai le code source complet.

Donc, pour contrôler les servos, nous utiliserons la bibliothèque Servo de base et pour la communication Bluetooth, nous devons également inclure la bibliothèque SoftwareSerial. Nous devons d'abord définir tous les objets servo ainsi que certaines variables nécessaires au programme ci-dessous.

#include <Servo.h>
#include <SoftwareSerial.h>

#define trigPin 7
#define echoPin 6
#define ledB 10

SoftwareSerial Bluetooth(12, 9); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

// Create servo object
Servo s24;
Servo s23;
Servo s22;Code language: Arduino (arduino)

Dans la section de configuration, nous devons initialiser la communication Bluetooth, les modes de broche pour le capteur à ultrasons, la LED et également définir les broches auxquelles les servos sont connectés.

void setup() {
  Serial.begin(38400);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
  pinMode(ledB, OUTPUT);
  // Head
  s15.attach(36, 600, 2400);
  s14.attach(35, 600, 2400);
  s13.attach(34, 600, 2400); //grip
  // Tail
  s5.attach(26, 600, 2400); // Tail
  // Leg 4
  s10.attach(31, 600, 2400);
  s11.attach(32, 600, 2400);
  s12.attach(33, 600, 2400); //rot
  // Leg 5
  s7.attach(28, 600, 2400);
  s8.attach(29, 600, 2400);
  s9.attach(30, 600, 2400); //rot
  // Leg 6
  s1.attach(22, 600, 2400);
  s2.attach(23, 600, 2400);
  s3.attach(24, 600, 2400); //rot
  // Leg 1
  s18.attach(39, 600, 2400);
  s17.attach(38, 600, 2400);
  s16.attach(37, 600, 2400); //rot
  // Leg 2
  s21.attach(42, 600, 2400);
  s20.attach(41, 600, 2400);
  s19.attach(40, 600, 2400); //rot
  // Leg 3
  s24.attach(45, 600, 2400);
  s23.attach(44, 600, 2400);
  s22.attach(43, 600, 2400); //rotCode language: Arduino (arduino)

Ensuite, en utilisant les fonctions write(), nous déplaçons les servos à leur position initiale. Voici en fait où nous pouvons calibrer nos servos. Considérez que vous ne pourrez pas régler chaque servo à la position exacte lors de l'assemblage du robot, mais ici nous pouvons faire des ajustements et découvrir nos valeurs initiales et à partir de là, nous pouvons programmer le mouvement du robot.

// == Move to initial position
  // Head
  s15.write(72);
  s14.write(50);
  s13.write(90); // Grip
  
  s5.write(65); // Tail
  
  // Leg 4
  s10.write(65);
  s11.write(35);
  s12.write(40);
  // Leg 5
  s7.write(80);
  s8.write(50);
  s9.write(25);
  // Leg 6
  s1.write(90);
  s2.write(45);
  s3.write(60);

  // Leg 1
  s18.write(60);
  s17.write(90);
  s16.write(100);
  // Leg 2
  s21.write(50);
  s20.write(85);
  s19.write(75);
  // Leg 3
  s24.write(50);
  s23.write(80);
  s22.write(80);Code language: Arduino (arduino)

Lorsqu'il s'agit de programmer un mouvement d'hexapode, il existe plusieurs façons de procéder, comme l'utilisation d'une cinématique avant ou inverse. Ces méthodes incluent des mathématiques sérieuses où la position de chaque articulation est calculée sur la base des entrées pour la position finale souhaitée du corps. Cependant, j'ai décidé de le rendre un peu moins compliqué car de toute façon les servos que j'utilise ne sont pas assez bons pour une telle tâche. C'est parce que mes servos sont la version bon marché du servo MG996R. Ils n'ont pas le bon couple et ne se positionnent pas toujours à la position exacte souhaitée.

Voyons donc comment j'ai fait marcher l'hexapode. J'ai créé une fonction personnalisée distincte pour déplacer chaque jambe. Un cycle de jambes comprend deux phases, appelées swing et position. Dans la phase d'oscillation, la jambe passe d'une position initiale à une position finale dans les airs, tandis que dans la phase d'appui, la jambe passe de la position finale à la position initiale avec l'effecteur d'extrémité de jambe touchant le sol. De cette façon, le corps de l'hexapode avancera.

Je programme donc manuellement les positions de chaque servos pour réaliser ces mouvements en utilisant la boucle principale et quelques compteurs.

void moveLeg1() {
  // Swign phase - move leg though air - from initial to final position
  // Rise the leg
  if (i1L1 <= 10) {
    s18.write(60 - i1L1 * 2);
    s17.write(90 - i1L1 * 3);
    i1L1++;
  }
  // Rotate the leg
  if (i2L1 <= 30) {
    s16.write(100 - i2L1);
    i2L1++;

  }
  // Move back to touch the ground
  if (i2L1 > 20 & i3L1 <= 10) {
    s18.write(40 + i3L1 * 2);
    s17.write(60 + i3L1 * 3);
    i3L1++;
  }
  // Stance phase - move leg while touching the ground
  // Rotate back to initial position
  if (i2L1 >= 30) {
    s16.write(70 + i4L1);
    i4L1++;
    l1status = HIGH;
  }
  // Reset the counters for repeating the process
  if (i4L1 >= 30) {
    i1L1 = 0;
    i2L1 = 0;
    i3L1 = 0;
    i4L1 = 0;
    i5L1 = 0;
  }
  // Each iteration or step is executed in the main loop section where there is also a delay time for controlling the speed of movement
}Code language: Arduino (arduino)

Ainsi, les deux servos extérieurs lèvent d'abord la jambe et le troisième servo connecté au corps commence à tourner dans une direction particulière. Lorsque le troisième servo fait 10 pas avant qu'il ne s'arrête de tourner, nous commençons à déplacer les deux servos extérieurs vers l'arrière à la même position pour toucher le sol. Ceci termine la phase de balancement, ou la jambe est passée de sa position initiale à la position finale. Ensuite, nous retournons le troisième servo de la position finale à la position initiale, et cela termine la phase d'appui. Une fois que la jambe a exécuté un cycle, les compteurs sont réinitialisés et la jambe répétera le cycle encore et encore. Chaque itération ou étape est exécutée dans la section de boucle principale où il y a aussi un temps de retard qui contrôle la vitesse des servos. J'ai créé des fonctions comme celle-ci pour toutes les autres jambes, ainsi que des fonctions supplémentaires pour déplacer les jambes dans la direction opposée afin d'obtenir des mouvements inverses, gauche et droite. De la même manière, en utilisant des compteurs pour suivre les pas, j'ai programmé le reste des fonctions, comme déplacer la tête, déplacer la queue, les mandibules, etc.

Ainsi, par exemple, si nous voulons faire avancer le robot, nous devons appeler les six fonctions personnalisées moveLeg() qui se répéteront constamment dans la boucle principale.

// Move forward
  if (m == 2) {
    moveLeg1();
    moveLeg3();
    moveLeg5();
    if (l1status == HIGH) {
      moveLeg2();
      moveLeg4();
      moveLeg6();
    }
  }Code language: Arduino (arduino)

Vous pouvez remarquer que les 3 jambes sont décalées, donc lorsque les jambes numéro 1 3 et 5 sont en phase d'oscillation, les trois autres jambes, 2, 4 et 6 sont en phase d'appui. Si nous voulons nous déplacer vers la gauche, nous appelons les fonctions moveLeft() appropriées.

Ces commandes proviennent en fait du module Bluetooth ou de l'application Android personnalisée de notre smartphone.

// Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.read();  // Read the dataCode language: Arduino (arduino)

Application Android Arduino Ant Robot

Jetons un coup d'œil à l'application maintenant et voyons quel type de données elle envoie réellement à l'Arduino. J'ai créé l'application à l'aide de l'application en ligne MIT App Inventor et voici comment cela fonctionne.

Ainsi, les graphiques de l'application sont en fait des images que j'ai créées et placées sous forme de boutons. En bas, nous avons un curseur pour contrôler la vitesse du robot et en haut, nous avons les boutons pour se connecter au module Bluetooth.

Jetons un coup d'œil au programme ou aux blocs derrière l'application.

Ainsi, par exemple, si nous cliquons sur le bouton Suivant, les blocs de l'instruction "if" seront exécutés. Cela signifie que nous enverrons le numéro 2 à l'Arduino et qu'il exécutera l'ensemble de fonctions d'avancement. En même temps, nous pouvons remarquer que nous changeons l'image du bouton en l'autre version en surbrillance de la même image. Si nous appuyons à nouveau sur le même bouton, maintenant les blocs dans l'instruction "else" seront exécutés et cela enverra le numéro 0 à l'Arduino qui réinitialisera tous les compteurs et déplacera le robot dans ses positions initiales. Nous remettons également en arrière l'image initiale de ce bouton. J'ai donc utilisé le même principe pour tous les autres boutons.

Voici un fichier de téléchargement du projet MIT App Inventor ci-dessus, ainsi que l'application Android prête à être installée sur votre smartphone :

Jetons un coup d'œil à deux autres fonctions du programme Arduino, à savoir le moniteur de tension de la batterie et le capteur à ultrasons.

// Monitor the battery voltage
    int sensorValue = analogRead(A3);
    float voltage = sensorValue * (5.00 / 1023.00) * 2.9; // Convert the reading values from 5v to suitable 12V i
    Serial.println(voltage);
    // If voltage is below 11V turn on the LED
    if (voltage < 11) {
      digitalWrite(ledB, HIGH);
    }
    else {
      digitalWrite(ledB, LOW);
    }Code language: Arduino (arduino)

Donc, si la tension de la batterie est inférieure à 11 volts, nous allumerons la LED et si le capteur à ultrasons détecte un objet à moins de 40 cm, le robot se préparera à une attaque.

// Get the distance from the ultrasonic sensor
    if (getDistance() > 40) {
      att = 0;
    }
    if (getDistance() <= 40) {
      att = 1;
      dataIn = 99;
    }Code language: Arduino (arduino)

S'il n'y a plus d'objet devant, il rejettera l'attaque et si l'objet est toujours présent et plus près de la tête, le robot attaquera.

// If there is an object in front of the sensor prepare for attack
  if (att == 1) {
    prepareAttack();
    if (aStatus == HIGH) {
      while (a == 0) {
        delay(2000);
        a = 1;
      }
      if (getDistance() > 30) {
        att = 2;
        a = 0;
        aStatus = LOW;
        initialPosHead();
      }
      if (getDistance() < 30) {
        att = 3;
        a = 0;
        aStatus = LOW;
        initialPosHead();
      }
    }
  }
  // If there is no longer object in front, dismiss the attack
  if (att == 2) {
    dismissAttack();
    if (aStatus == HIGH) {
      dataIn = 0;
      att = 0;
    }
  }
  // If there is closer to the sensor attack
  if (att == 3) {
    attack();
    if (attStatus == HIGH) {
      while (aa == 0) {
        delay(2000);
        aa = 1;
      } attStatus = LOW;
    }
    if (aStatus == HIGH) {
      while (a == 0) {
        delay(2000);
        a = 1;
      }
      dataIn = 0;
      att = 0;
      initialPosHead();
    }
  }Code language: Arduino (arduino)

C'est à peu près tout pour cette vidéo.

Ici vous pouvez télécharger le code complet de ce projet Arduino Hexapod :

Notez que si vous décidez de construire ce projet, vous devez être prêt à relever certains défis. Le plus gros problème pour moi était la mauvaise performance des servos que j'utilisais. J'espère que cette vidéo vous a plu et que vous avez appris quelque chose de nouveau. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous et à consulter ma collection de projets Arduino.