IMA3/IMA4 2021/2023 P11

Résumé du Wiki

Dans ce wiki, vous trouverez toutes les informations concernant notre projet de robot hexapode: Dans quel contexte notre robot peut-il servir, nos objectifs, nos résultats et le déroulement de chaque séance.

Présentation générale

Enjeu

Robots dans la vie quotidienne

De nos jours, les systèmes embarqués sont présents absolument partout. De la voiture électrique aux smartphones, en passant par les frigos connectés, ce sont des systèmes que l’on utilise au quotidien. Les technologies régissant ces systèmes évoluent rapidement, si bien qu’il y est parfois difficile de s’y adapter. La robotique a permis d’automatiser de nombreuses tâches répétitives et fatigantes pour l’être humain, notamment dans les usines, mais pas que. Le domaine médical, les caisses des supermarchés...Il est presque impossible de trouver un secteur dans lequel les robots n’interviennent pas pour aider les humains. C’est ainsi également le but de notre projet, qui consiste à développer un robot hexapode léger, discret et de petite taille, jusqu’à aujourd’hui peu présent dans cette industrie afin d’effectuer certaines opérations dont l’analyse est compliquée quand on ne possède pas un grand champ de manœuvre.

Objectif

Nous voulons *créer et fabriquer* un robot hexapode (6 pattes) pouvant se déplacer, et par la suite être contrôlé par une application. Notre objectif est de pouvoir le diriger afin qu’il évolue dans des conditions de terrain instable, par exemple, où il n’y a pas nécessairement une bonne visibilité. Différentes fonctions vont être ajoutées afin de pouvoir rendre ce robot hexapode polyvalent lors des différentes interventions auxquelles il sera confronté.

Description

Notre Robot doit pouvoir se déplacer en marche avant, vers la droite et vers la gauche de façon stable sur différentes surfaces. Pour cela, il est équipé de douze servos moteurs et d'un treizième afin de controler le mouvement de sa "tête",relié à une carte électronique Adeept Hat. Après avoir initier ces différents mouvements, nous allons le contrôler grâce à une application mise en place sur MIT App Inventor. Cette application communiquera avec notre Robot grâce a un Module Bluetooth Arduino. Afin de la rendre plus autonome , nous allons utiliser un capteur de distance lui permettant de s'arrêter de façon autonome lorsque le robot se trouve face à un obstacle par exemple.

Expression du besoin

Nous nous plaçons dans le cadre d’un terrain extérieur/intérieur, possédant des irrégularités (pentes, terrains rocheux, terrains mouvants). Notre robot doit pouvoir se déplacer afin d’analyser son environnement.

Spécifications supplémentaires : Outdoor : analyser la faune et la flore Types d’interventions : déminages, accidents de la route, accidents autres(grottes...), espionnage, observation

Methode QQOQCPC :

	Questions	Réponses
Quoi ?	De quel besoin s'agit-il ?	Aider lors d’interventions dangereuses voir impossibles pour l’homme
Qui ?	Qui est concerné par ce besoin ?	Les secouristes et forces d’interventions
Où ?	A quel endroit ce besoin se fait-il ressentir ?	Sur le terrain, dans des lieux étroits,difficile d’accès
Quand ?	A quel moment ce besoin se fait-il ressentir ?	Lors d’urgence ,de catastrophes naturelles,accidents
Comment ?	Sous quelle forme ce besoin se fait-il ressentir ?	Besoins vitaux, besoins de sécurité et protection
Pourquoi ?	Quelles sont les raisons qui ont fait apparaître ce besoin ?	Le monde, la nature qui est imprévisible
Combien ?	Combien de structures sont concernées par ce besoin ?	Tout le monde ? (dans le sens personne est sans risque d’avoir un accident ?)

Une analyse fonctionnelle nous a permis de déterminer les principaux rôles que devra remplir notre araignée. Celle-ci a été réalisée de la sorte : Fonction principale -> fonction secondaire 1, fonction secondaire 2, fonction secondaire 3 -> sous-fonction 1, sous-fonction 2. On a décomposé au maximum les tâches pour rendre plus visible les différents mouvements ou réactions qu’aura notre robot araignée selon la situation à laquelle il sera exposé. De plus, même si certains attribut comme la discrétion ou la facilité de prise en main ne sont pas directement liés au bon fonctionnement du robot, ceux-ci sont néanmoins indispensables pour les utilisations auxquelles il est destiné.

Gestion de Projet

Pour gérer au mieux notre projet et pouvoir se partager ales document , nous avons utiliser l'application Notion. Nous avons préféré cette application à un drive. Notion est une application de prise de notes, de base de données, de calendrier et bien d'autres. Nous avons utilisé cette application en guise de journal de bord de notre projet où toute notre équipe ainsi que notre responsable de projet, Madame Gehin y avait accès et pouvait déposer tous types de document sur l’application.

Grâce à cette application, nous avons pu créer une section feuille de route qui nous a permis de voir ce qu’on avait accompli pendant les séances de projet et ce qu’il nous restait à faire pour les séances prochaines. Nous avons aussi une section documents où nous avons au fur et à mesure déposé les différents diagrammes qui constituent notre cahier des charges.

Lien Notion

Pour les semestres suivants, un Wiki a été mis en place pour le reste du projet, nous gardons le Notion pour les feuilles de route que nous publions sur Moodle ainsi que le stockage de document.

Pour réaliser l'ensemble des fonctionnalités de notre projet, nous avons réalisé un diagramme de Gant prévisionnel afin de gérer au mieux nos séances et se repartir les tâches pour le semestre 7 et le semestre 8.

Réalisation et résultats

Equipement

La première étape de notre projet était de monter le kit hexapode que l'école nous a fourni.

Ce robot provient de la marque Adeept et est composé de 13 servo moteurs, de plusieurs modules comme un module WIFI, un gyroscope, un capteur ultrason et de NeoPixels. Nous avons de plus, pour faciliter le développement de notre application, commandé un module Bluetooth. (https://www.gotronic.fr/art-module-bluetooth-4-0-dg010-21436.htm)

Notre robot à été monté selon la notice suivante : Fichier:Notice de montage du robot.pdf

Description du système

Composant	Référence	Image
Servo moteur	AD002
Gyroscope	MPU6050
Capteur à ultrasons	HC-SR04
Module Bluetooth	DG010
Carte arduino	Adeept HAT

Servo moteurs

Le fonctionnement du servo moteur est basé sur un contrôle automatique du système. Plus simplement, le servo moteur reçoit une impulsion et tourne ensuite à l'angle correspondant pour réaliser le déplacement. Le servo moteur à de plus la fonctionnalité d'envoyer des impulsions. Donc à chaque fois que celui-ci effectue un mouvement, un nombre correspondant d'impulsions sera envoyé. Grâce à cela, les impulsions reçues par le servomoteur forment une réponse, ou une boucle fermée. De cette façon, le système sait combien d'impulsions sont envoyées au servomoteur et combien d'impulsions sont reçues. De cette façon, il est possible de contrôler avec précision la rotation du moteur et d'obtenir un positionnement précis.

Branchements :

Ce branchement sera effectué pour les 13 autres servo moteurs les pins correspondants.

Gyroscope

Le MPU-6050 comporte un gyroscope MEMS 3 axes, un accéléromètre MEMS 3 axes intégrés. Il possède aussi une puce MEMS qui est très précise, elle permet une conversion analogique-digitale sur 16 bits simultanée sur chaque canal et une interface I2C à une fréquence de 400Hz.

Il possède aussi un capteur de température dont nous n'avons pas l'utilité.

Le capteur possède un DMP (Digital Motion Processor) capable de faire des calculs rapides directement sur la puce à partir des mesures brutes du capteur. Il est donc plus simple de traiter les mesures brutes sur sa carte Arduino.

Le gyroscope : il retourne une vitesse angulaire de rotation selon 3 axes (degrés/seconde). Ainsi il retourne 0 si il n'y a pas de rotation. Il ne donne donc pas directement un angle d'orientation en degrés. Pour obtenir l'angle, il faut réaliser une intégration dans le temps.

L'accéléromètre : il retourne une force ou une accélération (m²/s). Si le robot ne bouge pas, il renvoie la valeur de la pesanteur terrestre. La vitesse (m/s) peut s'en déduire par une première intégration dans le temps (à une vitesse initiale V0 près). La position de déplacement (m) peut s'en déduire par une seconde intégration dans le temps.

Librairie Write.h : Il est nécessaire de mettre avant chaque fonction 'Wire' en argument.

La fonction begin() : Le périphérique peut est mis en maitre ou escalve. Ainsi si un paramètre est placé en argument de la fonction, cela doit etre une adresse et spécifie que l'utilisation se fait en mode esclave. Si il n'y a pas de paramètres, alors on est en mode maître. La déclaration est a faire dans le setup().

La fonction requestFrom() (maître) : Cette fonction est utilisée par le périphérique maître et elle sert a demander une information à un escalve. Ainsi l'agrment de cette fonction est l'esclave à interroger. Exemple : Wire.requestFrom(address, quantity, stop); Le paramètre stop est a valeu booléene : True : après la requête du maître, requestFrom() envoie un message stop sur le bus, le libérant. False : à contrario, le bus n’est ici pas libéré.

La fonction beginTransmission() (maître) : Elle commence la transmission vers un esclave sur le bus de communication. Exemple : Wire.beginTransmission(adresse_du_périphérique). Cette fonction est suivie de la fonction write() ainsi que endTransmission() pour réaliser entièrement la séquence de communication.

La fonction endTransmission() (maître) : elle ferme la communication. Exemple : Wire.endTransmission(stop). Elle accepte comme paramètre une valeur booléenne. C’est le même paramètre que dans la fonction requestFrom(). Par défaut, elle est à True et la fonction envoie, après son exécution, un message stop pour relâcher le bus de communication ; comportement contraire pour la valeur False.

La fonction write() (maître/esclave) : Cette fonction écrit le paramètre qu’on lui donne (le premier) sur le bus de communication. Elle est commune aux deux types de périphériques : le maître écrit sur le bus, fonction utilisée entre beginTransmission() et endTransmission(). L’esclave écrit sur le bus mais après requête du maître, il ne peut pas écrire de son propre chef. Le premier paramètre contient les données à envoyer. Cela peut être une simple valeur de type byte, une chaîne de caractères ou des données de type tableau ou record. Dans ce dernier cas, il est nécessaire d’ajouter un second paramètre indiquant le nombre de bytes à transmettre.

La fonction read() (maitre/esclave) : Cette fonction lit le premier octet disponible sur le bus de communication. Elle renvoie donc cette valeur. Reception des octets un par un.

Capteur à ultrasons

Le fonctionnement : La méthode de détection de distance de ce capteur se réalise grâce à des ultrasons. En effet, le capteur émet des ultrasons dans une certaine direction, au lancement de cette onde, un minuteur se mets en marche. L'onde ultrasonique parcours l'air jusqu'à rencontrer un obstacle et être immédiatement réfléchie. Le capteur reçois alors cette onde réfléchie et arrête le minuteur. En fonction du temps t enregistré par le chronomètre, on peut alors calculer la distance S entre le point de lancement de l'onde et l'obstacle, c'est à dire S=(c*t)/2 avec c=340m/s. Ces capteurs sont alors largement utilisés dans des applications de tout les jours, tels que le radar de recul des voitures, l'UAV et la voiture intelligente.

Module bluetooth

--Spécifications au S8--

Code pour faire déplacer le robot

Nous avons tout d'abord déclaré les 14 servos moteurs grâce à la librairie Servo.h

Servo servo2; // Haut gauche 1 premiere patte
Servo servo3; // Haut gauche 2 premiere patte 
Servo servo4; // Haut gauche 1 milieu
Servo servo5; // Haut gauche 2 milieu
Servo servo6; // Bas gauche 1 derniere patte
Servo servo7; // Bas gauche 2 derniere patte
Servo servo8; // Bas droite 1 premiere patte
Servo servo9; // Bas droite 2 premiere patte
Servo servo10; // Haut droite 1 milieu
Servo servo11; // Haut droite 2 milieu
Servo servo12; // Haut droite 1 derniere patte
Servo servo13; // Haut droite 2 derniere patte
Servo servo14; // Tete

Nous avons ensuite déterminé sur quels pins les moteurs fonctionnaient :

#define servo2_Pin 2
#define servo3_Pin 3
#define servo4_Pin 4
#define servo5_Pin 5
#define servo6_Pin 6
#define servo7_Pin 7
#define servo8_Pin 8
#define servo9_Pin 9
#define servo10_Pin 10
#define servo11_Pin 11
#define servo12_Pin 12
#define servo13_Pin 13
#define servo14_Pin 14

Nous avons pour le code créer des sous fonctions permettant de faire avancer le robot, le faire tourner à gauche et à droite et le mettre en position stable :

void init_stable()
{
  servo2.write(90);
  servo3.write(90);
  servo4.write(90);
  servo5.write(90);
  servo6.write(90);
  servo7.write(90);
  servo8.write(90);
  servo9.write(150);
  servo10.write(90);
  servo11.write(50);
  servo12.write(90);
  servo13.write(90);
   servo14.write(30);
 }


 void avancer()
 {
  servo2.write(40);
  servo6.write(40);
  servo10.write(140);
  delay(250);
  servo3.write(150);
  servo7.write(150);
  servo11.write(10);
  delay(250);
  servo2.write(90);
  servo6.write(70);
  servo10.write(90);
    
  //Deuxième étape pour avancer
  servo8.write(140);
  servo4.write(40);
  servo12.write(140);
  delay(250);
  
  servo5.write(150);
  servo9.write(80);
  servo13.write(30);
  delay(250);
  
  servo8.write(90);
  servo4.write(90);
  servo12.write(90);

  delay(250);
  servo5.write(90);
  servo9.write(150);
  servo13.write(90);
  servo3.write(90);
  servo7.write(90);
  servo11.write(50);
  
  }

 void tourne_droite()
 {
  servo2.write(40);
  servo6.write(40);
  servo10.write(140);
  delay(250);
  servo3.write(150);
  servo7.write(150);
  servo11.write(100);
  delay(250);
  servo2.write(90);
  servo6.write(70);
  servo10.write(90);
    
  //Deuxième étape pour avancer
  servo8.write(140);
  servo4.write(40);
  servo12.write(140);
  delay(250);
  
  servo5.write(150);
  servo9.write(180);
  servo13.write(120);
  delay(250);
  
  servo8.write(90);
  servo4.write(90);
  servo12.write(90);

  delay(250);
  servo5.write(90);
  servo9.write(150);
  servo13.write(100);
  servo3.write(90);
  servo7.write(90);
  servo11.write(50);
  
  }

  void tourne_gauche()
  {
    servo2.write(60);
    servo6.write(30);
    servo10.write(140);
    delay(250);
    servo3.write(60);
    servo7.write(60);
    servo11.write(10);
    delay(250);
    servo2.write(90);
    servo6.write(70);
    servo10.write(90);
      
    //Deuxième étape pour avancer
    servo8.write(120);
    servo4.write(70);
    servo12.write(140);
    delay(250);
    
    servo5.write(60);
    servo9.write(90);
    servo13.write(30);
    delay(250);
    
    servo4.write(90);
    servo8.write(90);
    servo12.write(90);
  
    delay(250);
    servo3.write(90);
    servo5.write(90);
    servo7.write(90);
    servo9.write(150); 
    servo11.write(50);
    servo13.write(100);
  }

Ensuite, nous avons configuré les servos moteurs dans la partie setup()

void setup()
{

   // Attache la variable des servos à leur PIN
   
   servo2.attach(servo2_Pin);
   servo3.attach(servo3_Pin);
   servo4.attach(servo4_Pin);
   servo5.attach(servo5_Pin);
   servo6.attach(servo6_Pin);
   servo7.attach(servo7_Pin);
   servo8.attach(servo8_Pin);
   servo9.attach(servo9_Pin);
   servo10.attach(servo10_Pin);
   servo11.attach(servo11_Pin);
   servo12.attach(servo12_Pin);
   servo13.attach(servo13_Pin);
   servo14.attach(servo14_Pin);

   
   //myservo.write(0); // Positionne le servo moteur à 0°
   //delay(1000); //wait for a second
}

Enfin dans la partie loop() nous avons appelé ces fonctions pour que le robot enchaîne les mouvements :

void loop()
{
   //digitalWrite(servo2_Pin,HIGH);
  delay(250);
 
  servo2.write(80);
  servo3.write(90);
  servo4.write(90);
  servo5.write(90);
  servo6.write(90);
  servo7.write(90);
  servo8.write(90);
  servo9.write(150);
  servo10.write(90);
  servo11.write(50);
  servo12.write(90);
  servo13.write(90);
  servo14.write(30);
  delay(500);

  avancer();
  tourne_droite();
  avancer();
  tourne_gauche();

  
   delay(250);
  
}

Application sur MIT App Inventor

Dans notre projet, nous voulions utiliser le logiciel MIT App Inventor (MITAI) afin de créer une application permettant de contrôler le robot à distance. Cette application sera connectée au robot via une connexion Bluetooth. Nous avons commencée à réaliser l'interface de cette application :

Et nous avons aussi commencé à implémenter le code pour la faire fonctionner :

Bilan du semestre 7

Pendant ce semestre, nous avons réussi à :

• Piloter le robot via la plateforme Arduino.
• Imprimé en 3D des supports pour les pattes pour que celles-ci ne glissent plus en se déplaçant.
• Commencé l'application téléphone permettant le pilotage du robot à distance.

Chronologie du projet

Semestre 6

Séance du 01/03/22

Durant cette séance,nous avons découvert le sujet et commencé nos recherches sur les robots hexapodes ainsi que leurs utilisations

Séance du 08/03/22

Durant cette séance,nous avons commencé à réaliser un diagramme de Gantt prévisionnel pour le semestre 7. Nous avons également commencer l'étude du besoin avec la réalisation d'un diagramme "Bête à Corne" et d'un diagramme "Pieuvre".

Séance du 15/03/22

Durant cette séance,nous avons cherché ce qui existait sur le marché,afin de démarrer l'étude de marché ainsi que l'étude des opportunités. En parallèle, nous avons également demarrer l'analyse fonctionnel de notre robot.

Séance du 22/03/22

Durant cette séance,nous avons poursuivi les études de la semaine précédente.

Séance du 29/03/22

Durant cette séance,nous avons fini l'étude de marché et commencé à réfléchir au plan d'action. Nous avons également commencé à rédiger notre cahier des charges.

Séance du 05/04/22

Durant cette séance,nous avons commencé le plan d'Action et avancé le cahier des charges.

Séance du 26/04/22

Durant cette séance,nous avons réalisé un bilan de ce qui nous rester à effectuer et commencé l'étude de faisabilité et l'étude des risques.

Séance du 03/05/22

Durant cette séance, nous avons terminé l'analyse des risques,poursuivi l'étude de faisabilité et le cahier de charge.

Semestre 7

Séance du 10/10/22

Durant cette séance, nous avons chercher à améliorer notre robot et finir son montage.

Séance du 21/10/22

Durant cette séance, nous avons regardé quelle carte pourrait convenir pour insérer d'autres composants et un servo moteur en plus, la carte actuelle étant totalement utilisée.

Séance du 21/10/22

Durant cette séance, nous avons essayé d'implémenter le programme dans le robot. Le programme ne marchant pas, nous devons donc reprendre le code à 0 et tester chaque servo moteur. Nous avons toutefois réussi a tester le capteur à ultrason et les NeoPixel.

Séance du 28/10/22

Durant cette séance, nous avons résolu le problème des servos moteur qui provenait d'un mauvais branchement. Notre araignée se déplace pour la première fois. Cependant elle rencontre de gros problèmes d'adhérences.

Séance du 18/11/22

Durant cette séance, nous avons poursuivi la programmation des différents mouvements du Robot. Pour l'adhérence, nous avons testé différentes solutions : élastiques , colle chaude.

Séance du 21/11/22

Durant cette séance , nous avons cherché un logiciel de modélisation 3D afin de réaliser nos patins et commencer la prise en main de celui-ci.

Séance du 25/11/22

Durant cette séance, nous avons modifié et amélioré notre diagramme de Gantt pour le S7 et le S8. Nous avons également avancé la modélisation 3D des patins sur Onshape.

Séance du 28/11/22

Pendant cette séance, nous avons fini la modélisation des pattes de l’araignée pour qu’elle soit plus stable. Nous allons en imprimer un exemplaire pour vérifier que la pièce s’emboite bien dans la patte du robot. Nous avons aussi continuer la recherche du développement de l’application pour contrôler le robot à distance. Sur l’application MIT App Inventor, nous ne pouvons pas utiliser le module WIFI, c’est pour cela que nous allons regarder pour la séance prochaine si nous pouvons remplacer le module WIFI par un module Bluetooth.

Séance du 08/12/22

Durant cette séance,nous avons lancé l'impression 3D de nos cinq pattes manquantes et completé le Wiki.

Séance du 15/12/22

Durant cette séance, nous avons commencé le rapport et avancé le Wiki.

Séance du 18/01/23

Durant cette séance, nous avons fait des recherches pour le gyroscope, nous avons aussi continué l'application mais nous n'avons pas pu nous connecter au module bluetooth et en allumant le robot, une patte a cassé, nous devons réfléchir à comment réparer cette patte. Pour l'instant nous avons utilisé de la colle ainsi qu'un plastique chauffant pour maintenir la patte.