Version du 15 mars 2023 à 15:25

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 :

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.

Spécification

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

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

Le module Bluetooth HC-06 permet d'établir une liaison Bluetooth entre une carte Arduino et un autre équipement possédant une connexion Bluetooth (Smartphone, tablette par exemple). Le module HC-06 est un module "esclave". Un module "esclave" ne peut recevoir que des demandes d'appairage.

Dans notre cas, notre module communiquera avec notre téléphone portable.

Les pins RX et TX permettent la communication ( RX : réception et TX : transmission ) et les deux autres pins permettent d'alimenter le module.

Ce module dispose de 4 pins à connecter à notre carte Adeept Hat:

Code utile à Spidey

Déplacement de l'araignée

Le déplacement de notre robot se repose sur l'utilisation des servos moteurs. Afin de pouvoir les utiliser dans notre code, nous avons tout d'abord déclaré les 14 servos moteur, grâce à la librairie Servo.h

Voici un exemple d'initialisation de variable pour un moteur n :

Servo servo2; //Pour premier moteur de la première patte de gauche

Afin de pouvoir relier physiquement notre code aux servos, nous avons associé les Pin sur lequels sont branchés les servos et les variables créées ci-dessus:

#define servo2_Pin 2
servo2.attach(servo2_Pin); //Ce bout de code sera placé dans le <code>void setup()</code>

Pour créer le déplacement du robot, nous avons crée plusieurs fonction dans le code permettant de réaliser différentes actions :

• se mettre en position stable
• avancer
• reculer
• tourner à droite
• tourner à gauche

Ces fonctions consistent toutes à utiliser la fonction write() de la librairie.

Se mettre en position stable :

Cette fonction à pour but de mettre notre robot dans une position de base : stable, tenant droit sur ses 6 pattes. Elle sera lancée dès la mise en alimentation du robot, ce qui lui permet de se remettre debout dans une position ou il est stable peut importe la position dans laquelle étaient ses pattes à la mise en marche.

La fonction est la suivante :

void init_stable();

Le code précis de celle ci trouve à la fin de notre wiki.

Avancer :

La fonction pour faire avancer le robot se décompose en différents mouvements :

• Lever 3 de ses pattes
• Les avancer vers l'avant
• Poser les 3 pattes
• Les décaler vers l'arrière

Il faut ensuite réaliser ce mouvement mais avec les 3 autres pattes opposées. Après chaque mouvement de 3 pattes, nous lui demandons grâce à la fonction delay(250); d'attendre un délais de 250ms pour laisser le temps aux servos moteurs de réaliser leur mouvements.

 void avancer();

Reculer :

 void reculer();

Tourner à droite :

 void tourne_droite();

Tourner à gauche :

 void tourne_gauche();

Utilisation du capteur - Détection d'obstacle

const int pingPin = A3; //pin connectée au pin Echo du module
const int trigPin = A2; //pin connectée au pin Trig du module
#define distance_MAX 10 //distance à l'obstacle en cm
#define max_capt 1012

Utilisation des leds

#include <Adafruit_NeoPixel.h>    
#define led_numbers  6 //WS2812 number  of LED
#define PIN  A1  //WS2812 PIN   
Adafruit_NeoPixel strip = Adafruit_NeoPixel(led_numbers, PIN, NEO_GRB + NEO_KHZ800);//NEO_KHZ400+NEO_RGB
int R=random(0,255);
int G=random(0,255);
int B=random(0,255);

Utilisation du module Bluetooth

#include <SoftwareSerial.h>
#define BAUDRATE 9600
SoftwareSerial HC06(1,0);
String message;

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 :

Maintenant que la connexion entre l'application et le téléphone est possible, nous avons compléter l'interface de l'application en lui ajoutant :

• 4 boutons pour les différents mouvements
• Un label indiquant si nous sommes connecté
• Un bouton pour se connecter
• Un bouton pour se déconnecter
• Un label indiquant le status
• Une photo de l'icône Bluetooth
• Une photo de Spidey

Mise en situation

Utilisation du capteur de distance

Angle maximal

Nous avons tout d'abord réalisé un test concernant la stabilité de notre robot sur un terrain en pente. D'après cette expérimentation, on en déduit que Spidey reste stable sur une surface lisse inclinée de maximum 20°.

Montée d'un terrain avec une légère pente un terrain non lisse

Utilisation du Gyroscope

Avec le programme ci-dessous, nous avons réussi à récupérer les données du gyroscope :

 code 

Voici une vidéo montrant les données du gyroscope selon la position de l'araignée :

Résultats

Jeux de lumière Application-Neopixel

En se basant sur les couleurs des flèches de l'application, nous avons retranscrit ces couleurs sur la tête du robot.

Escalier

Après avoir construit un escalier en carton, nous avons testé si le robot pouvait le monter.

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.

Semestre 8

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.

Séance du 25/01/23

Test gyroscope non concluant. (ajouter une vidéo )

Utilisation du capteur de distance

Solution pour la tête cassé : utilisation de lego (ajouter une photo)

Envoi du mail pour savoir où en est la commande du module bluetooth

Séance du 01/02/23

Durant cette séance, nous avons :

• Réalisé un test d'adhérence (chute avec un angle supérieur à 20°) : vidéo dans la partie mise en situation
• Test dans l'herbe
• Test sur une surface rocheuse (petit cailloux) : vidéo dans la partie mise en situation
• Test en pente (arrive à descendre mais pas monter car pas assez de puissance pour se tracter)
• Connexion au module Bluetooth, on arrive à se connecter mais pas de déplacement.
• Remplissage du wiki

Séance du 08/02/23

Durant cette séance, nous avons essayé de connecter le module Bluetooth au robot afin que celui-ci se déplace. Nous avons modifié le code de l’application ainsi que le code Arduino. Nous avons observé que le robot avait comme des spasmes quand nous appuyons sur les boutons de l’application, mais rien de plus. Après 3 h 50 de recherche, nous avons trouvé l’erreur (nous avions oublié de convertir en char ce que le module Bluetooth lisait) maintenant, nous pouvons commander à distance le robot en le faisant avancer.

Séance du 15/02/23

Nous avons retesté le programme de la semaine précédente mais cette fois celui-ci ne fonctionne plus. On se sait pas pourquoi car nous n’avons rien changé. Nous avons identifié qu’il n’arrive plus à faire les comparaison alors qu’il reçoit bien le message.

Séance du 01/03/23

Durant cette séance, nous avions pour objectif de faire fonctionner à nouveau la commande à distance de notre robot par liaison bluetooth à notre application. Pour cela, nous avons réalisé de nombreux tests afin de découvrir d’où venait le problème.

• Modifier des parties de notre code arduino
• Changer le module bluetooh par un nouveau module identique
• Changer les câbles reliant le module à la carte arduino
• Réaliser des tests avec un voltmètre pour déterminer si le problème venait des câbles ou des pins des cartes
• Tester la réception du module bluetooth avec une carte arduino Uno et un dispositif de leds qui devait s'allumer si la carte recevait des informations.

Résolution du problème : pour que la connexion fonctionne entre le module et l'application, nous avons changé les fils qui étaient défectueux. De plus, avons remarqué que l'inclinaison du module était nécessaire pour que celui-ci fonctionne. Nous avons donc déplacé le squelette sur lequel la carte arduino était fixée sur le dos du robot, les pins étant dirigés vers le haut.

Nous avons de plus réalisé :

• La connexion Bluetooth entre le robot et l'application fonctionne
• Nous pouvons déplacer le robot à distance (avancer,reculer,tourner)
• Nous avons rajouté un contrôle de détection d’obstacles : lorsque le robot rencontre un obstacle à une distance minimum choisie, celui ci s’arrête puis recule jusqu’à ce qu'il ne voit plus l'obstacle. Cependant cette partie reste à être perfectionnée.
• Nous avons de plus rajouté un jeu de lumières, grâce aux NeoPixels sur la tête du robot : reprenant les couleurs des boutons de l'application et un affichage rouge lorsqu’il rencontre un obstacle.
• Nous avons crée un escalier en carton

Pour la prochaine séance, nos objectifs seront de perfectionner l’arrêt du robot lors de la rencontre d'un obstacle. Mais aussi de faire en sorte que celui-ci soit capable d'escalader l'escalier que nous avons réaliser cette séance.

Séance du 08/03/23

Réalisations de cette séance :

• Vidéo de Spidey rajoutée au wiki montant un escalier de carton
• Toujours un problème de connexion avec le module bluetooth => cela viendrait très probablement des pins de la carte qui sont tordues

Sinon Spidey fonctionne, il peut être téléguidé grâce à l'application sur le téléphone. De plus il s’arrête et recule lorsqu'il rencontre un obstacle. Cependant, après avoir vu l'obstacle, on ne peut plus lui demander de réaliser une autre action. Cette partie reste alors à refaire durant la prochaine séance.

Séance du 15/03/23

Mise à jour du Diagramme de Gantt et du wiki

Fichier:Gantt S8.jpg

Code

Nous avons décidé d'implémenter le code de notre robot sous Arduino. Veuillez trouver dans cette partie l'entièreté de notre code permettant à celui-ci de fonctionner.

Bibliothèque nécessaire pour pouvoir utiliser et initialiser les servos moteurs

#include <Servo.h>

Bibliothèque et initialisation nécessaires pour l'utilisation du module bluetooth

#include <SoftwareSerial.h>
#define BAUDRATE 9600
SoftwareSerial HC06(1,0);
String message;