IMA3/IMA4 2021/2023 P11 : Différence entre versions

De Wiki de Projets IMA
(Commande du robot à distance)
(Semestre 7)
Ligne 527 : Ligne 527 :
 
'''Séance du 10/10/22'''
 
'''Séance du 10/10/22'''
  
Durant cette séance, nous avons cherché à améliorer notre robot et finir son montage.
+
* Amélioration du robot
 +
* Finalisation de son montage
  
  
 
'''Séance du 21/10/22'''
 
'''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 est totalement utilisée.
+
* Cherche sur une éventuelle carte qui pourrait convenir afin de pouvoir insérer d'autres composants et un servo moteur en plus. En effet la carte actuelle est entièrement utilisée et nous souhaitons rajouter des composants.
 
+
* Essai d'implémentation du programme dans le robot : celui-ci ne fonctionnant pas, nous devons revoir l'entièreté du code et teste chaque servo moteur individuellement.
 
+
* Test du capteur ultrasons : validé
'''Séance du 21/10/22'''
+
* Test des leds : validé
 
 
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'''
 
'''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.
+
* Résolution du problème concernant les servos moteurs : il provenait d'un mauvais branchement lors du montage du robot.
 +
* Le robot se déplace pour la première fois !
 +
* On remarque cependant de gros problèmes d'adhérence au niveau de ses pattes.
  
  
Ligne 562 : Ligne 563 :
  
  
'''Séance du 18/11/22'''
+
'''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.
 
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.

Version du 25 avril 2023 à 17:05

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

🌍 Enjeux

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é à distance 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, en marche arrière, 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 contrôler le mouvement de sa tête, relié à une carte électronique Adeept Hat. Après avoir programmé ces différents mouvements, nous allons le contrôler grâce à une application développée sur MIT App Inventor. Cette application communiquera avec notre robot grâce à un Module Bluetooth Arduino. Afin de la rendre plus autonome, nous allons utiliser un capteur de distance lui permettant de s'arrêter lorsque le robot se trouve face à un obstacle par exemple.

🔍 Expression du besoin

Pour réaliser notre étude 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.

Diagramme bête à cornes :

Diagramme Bête à Corne


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


Méthode 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’urgences, 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)


Analyse fonctionnelle :

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 visibles 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 attributs 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é.

Diagramme "Pieuvre"Description des fonctions

Gestion de Projet

Notion :

Pour gérer au mieux notre projet et pouvoir se partager les différents documents, nous avons utilisé 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. L'avantage de cette application est notamment que toute personne y ayant accès peut lire et déposer toute sorte de fichier mais aussi en créer au sein même de l'application. Les fichiers sont alors organisés dans différents répertoires ce qui permet une organisation efficace.

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


Wiki :

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


Diagramme de Gantt :

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.

Diagramme de Gantt S7-S8

Spécifications

🤖 Equipement

Robot Hexapode

Afin de pouvoir réaliser au mieux notre projet, l'école nous à fourni un kit de robot hexapode Arduino.

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 a été monté selon la notice suivante : Fichier:Notice de montage du robot.pdf

⚙️ Description du système

Nos composants

Voici la liste des différents composants que nous avons utilisés ainsi que leurs références :

Composant Référence Image

Carte Arduino

Adeept HAT

Carte Arduino Adeept Hat

Servo moteur

AD002

Servo moteurs

Capteur à ultrasons

HC-SR04

Capteur ultrasons

Module Bluetooth

DG010

Module bluetooth

Gyroscope

MPU6050

MPU 6050 ultrasonic

LEDs Neopixel

WS2812 RGB LED

LEDs Neopixel

Carte Arduino Adeept

Afin de faire fonctionner notre robot, nous avons utilisé la Carte Arduino Adeept fournie dans le kit que nous avions reçu. Cette carte est la carte finale que nous avons décidé d'utiliser pour le robot. En effet, lors du développement du robot, nous avions voulu changer de carte car celle-ci ne possédait pas suffisamment de ports pour rajouter une caméra. Cependant, nous n'avons pas pu approfondir cette partie de notre projet car peu de cartes Arduino possèdent assez de pins et de puissance pour brancher 13 servo moteurs, la carte de nous avions en notre possession était alors idéale.

Arduino 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 :

Branchements servo moteurs

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.

Branchements :

Branchements gyroscope

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 maître ou esclave. Ainsi si un paramètre est placé en argument de la fonction, cela doit être 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 à faire dans le setup().

La fonction requestFrom() (maître) : cette fonction est utilisée par le périphérique maître et elle sert à demander une information à un esclave. Ainsi l'argument de cette fonction est l'esclave à interroger. Exemple : Wire.requestFrom(address, quantity, stop); Le paramètre stop est à valeur 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. Réception des octets un par un.

Capteur à ultrasons

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 met en marche. L'onde ultrasonique parcourt l'air jusqu'à rencontrer un obstacle et être immédiatement réfléchie. Le capteur reçoit 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 tous les jours, tels que le radar de recul des voitures, l'UAV et la voiture intelligente.

Branchements :

Branchements capteur

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.

Branchements :

Branchements module bluetooth

LEDs Neopixels

Le module LED RGB WS2812 est une lampe RGB tricolore de faible puissance intégrée à une puce de contrôle du courant. Son utilisation sous arduino se fait grâce aux fonctions contenues dans la librairie Adafruit_NeoPixel.h. Et notamment grâce à la fonction setPixelColor(i,color). Cette fonction prend en paramètre le nombre de leds connectées et la couleur que l'on souhaite pour le pixel. Afin de choisir cette couleur il faut utiliser le fonction strip.Color(R,G,B). Dans cette fonction, nous pouvons choisir le niveau d'intensité de chaque couleur Rouge, Vert et Bleu, sachant que la valeur 0 correspond au plus sombre (donc led éteinte) et le 255 correspond au plus intense.

Branchements :

Branchements des LEDs

Développement du projet

🏃 Déplacement de Spidey

Le déplacement de notre robot 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 le moteur numéroté 2 :

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

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

#define servo2_Pin 2
servo2.attach(servo2_Pin); //Ce morceau de code sera placé dans la partie setup()

Voici l'association des servos moteurs à leurs PINS que nous avons initialisé dans notre code :

Association des PINS et des Servos

Pour créer le déplacement du robot, nous avons développé plusieurs fonctions permettant de réaliser différentes actions. Ces fonctions consistent toutes à utiliser la fonction write() de la librairie.

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


Se mettre en position stable :

Cette fonction a pour but de mettre notre robot dans une position de base : stable, tenant droit sur ses 6 pattes. Cette fonction sera placée dans la partie setup() de notre programme. Ainsi, dès la mise en marche de Spidey, notre robot se trouvera en position stable, peu importe la position initiale de ses pattes. Nous avons alors considéré que la position résultant au lancement de cette fonction était la position initiale de notre robot. Nous l'utiliserons donc dans d'autres programmes afin de remettre le robot dans sa position initiale stable.

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 notre robot, ainsi que les fonctions pour le faire reculer ou tourner ont été développées sur le même principe : un enchaînement de mouvements sur différentes pattes du robot. Ainsi, pour la fonction avancer, les différents mouvements sont les suivants :

  • Lever 3 de ses pattes
  • Les avancer
  • Poser les 3 pattes
  • Les déplacer 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 leurs mouvements. La fonction est la suivante :

 void avancer();

Voici un schéma pour mieux visualiser la décomposition des mouvements du robot qui lui permettent d'avancer :

Différents mouvements de Spidey pour avancer


Reculer : Sur le même principe que pour la fonction avancer(), la fonction permettant au robot de reculer se décompose en différents mouvements :

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

La fonction est la suivante :

 void reculer();


Tourner à droite :

 void tourne_droite();


Tourner à gauche :

 void tourne_gauche();

📱 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.

Au cours du semestre 7, nous avons commencée à réaliser l'interface de cette application qui sera disponible sur smartphone. Sur cette application, nous avons pour l'instant uniquement ajouté un bouton permettant la connexion au module bluetooth. Voici la première ébauche de l'application ainsi que le code que nous avons commencé à implémenter afin de la faire fonctionner :

Ebauche de l'interface de l'application smartphone Début de code pour l'application qui gère la connexion bluetooth

Au cours du semestre 8, nous avons reçu notre module bluetooth et ainsi la communication entre le robot et l'application a pu être possible. Nous avons alors complété l'application développée au semestre précédent en lui ajoutant :

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

Voici l'interface finale de notre application smartphone ainsi que le code correspondant :

Application smartphone Finale Code pour l'application

🌐 Utilisation du module Bluetooth

Nous avions décidé d'utiliser un module Bluetooth à la place d'un module Wifi car la connexion avec l'application que nous étions en train de développer était plus simple avec celui-ci. Cependant, nous avons rencontré quelques difficultés avec le module que nous avions commandé. En effet, celui-ci n'avait pas de référence et nous n'avons pas trouvé de datasheet sur internet. Nous avons donc opté pour un second module bluetooth que nous avons réussi à faire fonctionner. Pour pouvoir l'utiliser, nous avons dû initialiser de nombreux paramètres, notamment le Bauderate mais surtout la connexion. Afin de vérifier si celle-ci fonctionnait et si nous avions réussi les initialisations, nous avions branché le robot en série à l'ordinateur, et grâce à l'interface série sur Arduino, nous avons pu vérifier si le robot recevait bien les commandes envoyées de l'application mobile par la connexion bluetooth installée. Après avoir validé la réception de données, nous avons donc pu développer notre code final qui tournera en boucle sur notre robot. Le principe est le suivant : Tant que la liaison avec le module bluetooth est disponible :

  • On lit le message reçu (qui nous viens de l'utilisation de l'application)
  • On réalise l'analyse d'obstacle
  • Si il n'y a pas d'obstacle, on réalise le mouvement commandé par l'application
  • Après avoir réalisé une action, la variable qui stocke le message est remise à zéro et la boucle recommence

🚩 Utilisation du capteur - Détection d'obstacle

Fonctions permettant l'acquisition de données :

Le capteur de distance, placé sur la tête de notre robot, va notamment nous permettre de lui faire détecter des obstacles. D'après le fonctionnement du capteur, expliqué dans la partie description du système plus haut dans le wiki, nous avons développé une fonction ping(). Cette fonction permet de mesurer la distance entre le capteur et un objet. Pour cela, la fonction utilise la fonction pinMode() qui va nous permettre de configurer les pin pour envoyer un signal de déclenchement (trigPin) et recevoir un signal de retour (pingPin). Au début, une impulsion haute va être envoyée pour déclencher le capteur et attendre un bref instant avant de l'envoyer avec la fonction delayMicroseconds(). Ensuite, le capteur attend la réponse du signal retour qui est en mode INPUT et va utiliser la fonction pulseIn() pour mesurer la durée du signal de retour qui sera en microsecondes et stocké dans la variable interne duree. Cette valeur de retour étant en microsecondes, nous avons implémenté une fonction microsecondsToCentimeters() pour convertir la durée du signal obtenue en distance en centimètre. Les codes de ces différentes fonctions se retrouvent à la fin du wiki dans la partie Code.

Détection d'obstacles :

Pour la détection d'obstacle nous avons alors utilisé les fonctions développé ci-dessus pour construire un algorithme de détection. Tout d'abord, nous avons simplement essayé de réaliser un simple bout de programme dans la partie loop() de notre code afin de valider son fonctionnement. Le principe de cet algorithme est le suivant : le robot avance (soit en ligne droite par une commande imposée soit par utilisation de l'application) puis dès que le capteur de distance détecte un obstacle à une distance que nous avons arbitrairement choisi, le robot s'arrête et se mets en position stable. Cette fonction est la fonctions detection_obstacles() que vous pouvez retrouver à la fin de ce Wiki. Dans la partie finale de notre code, qui demande donc l'utilisation de l'application afin de commander le robot à distance, nous avons du réaliser un autre algorithme pour permettre au robot de reculer tant qu'il ne voit plus l'obstacle. Puis nous devons être capable de lui envoyer une nouvelle commande afin que celui-ci évite l'obstacle et que nous puissions continuer de l'utiliser à distance. Cependant, cette partie de notre algorithme reste perfectible. Vous pouvez aussi la retrouver à la fin de notre Wiki dans la partie loop().

Exemple de détection d'obstacles

💡 Utilisation des leds

Dans le kit Arduino de notre robot, nous avions à notre disposition deux barrettes de 3 LEDs. Ces LEDs ont été placées sur la tête de Spidey mais, dans l'objectif final, nous n'avions pas spécialement décidé de les utiliser. Cependant, après avoir validé la commande de Spidey via l'application mobile, il nous restait alors du temps pour rajouter certaines fonctionnalités comme la détection d'obstacles mais aussi l'utilisation de ces LEDs. Pour pouvoir les utiliser dans notre code, il était nécessaire d'importer la librairie Adafruit_NeoPixel.h qui nous permet de commander les LEDs. Après avoir testé leur fonctionnement, nous avons eu l'idée de les utiliser afin d'ajouter une information visuelle des commandes que nous transmettions par l'application ou encore pour montrer un problème (lors de la détection d'obstacles).

Dans notre application, nous avions choisi un code couleur pour les différents boutons :

  • Avancer : bleu
  • Reculer : vert
  • Aller à droite : rouge
  • Aller à gauche : blanc

Nous avons alors repris ces codes couleurs pour indiquer sur la tête de Spidey la commande reçue. Voici le résultat : Gestion des leds pour les différentes commandes


🧭 Utilisation du Gyroscope

L'utilisation du gyroscope n'était pour nous pas une priorité, mais il aurait pu nous aider à rendre notre robot plus stable sur des surfaces avec une pente très élevée. En effet, sur les conseils de notre professeur, nous pouvions améliorer Spidey en utilisant les données du gyroscope pour créer un programme lui faisait garder son centre de gravité stable tout en ajustant la hauteur de ses pattes. Cependant, en réfléchissant au développement de ce code, nous nous sommes aperçues que cette amélioration n'allait pas être possible. En effet, les pattes de notre robot manquent d'un degré de liberté, qui aurait pu être rajouté en modifiant ses pattes pour avoir des épaules. Sans cette modification, notre robot ne peut lever ou abaisser que la première partie de ses pattes et la seconde partie ne peut que se déplacer dans un plan horizontal. Nous avons donc décidé de ne pas aller plus loin sur cette idée, car nous aurions dû changer le squelette de ses pattes puis de nouveau développer un code qui nous paraissait assez compliqué.

Cependant, nous avons quand même réussi, grâce à un code fourni avec le robot, à acquérir les données du gyroscope :


🪜 Montée d'escalier

Pour aller plus loin dans notre projet, ne pouvans pas améliorer sa stabilité grâce au gyroscope, nous nous sommes données comme le fait que Spidey devait pouvoir monter des escaliers. Pour cela, nous avons construit un escalier en carton adapté à sa taille.

Escalier adapté à Spidey

En effet, comme pour l'utilisation du gyroscope, Spidey n'a pas d'épaules et ne peut donc pas lever ses pattes comme nous le souhaiterions. Tout d'abord nous avons décidé que pour monter une marche, Spidey devra lever ses pattes le plus haut possible. Il lèvera tout d'abord ses deux pattes avant pour pouvoir les poser sur la première marche. Il va ensuite exercer une pression en appuyant sur ses pattes de devant pour se soulever et ainsi pour pouvoir poser ses deux pattes du milieu sur la plateforme. Cependant, nous n'avons pas réussi à lui faire monter les escaliers avec cette technique. Nous avons donc décidé d'essayer simplement nos fonctions qui lui permettent d'avancer normalement, en levant au maximum ses pattes lors du mouvement où il les monte, afin de pouvoir grimper sur l'escalier.

Résultats

🌏 Mise en situation

Au cours du semestre 8, nous arrivions à la phase finale du développement de notre projet. Nous avons ainsi durant cette période, réalisé de nombreux tests fonctionnels afin de valider certaines parties du développement de notre robot et de pouvoir réaliser les réglages nécessaires à son bon fonctionnement. Nous espérons ainsi à la fin de ce projet, avoir amené notre robot jusqu'à l'échelon TRL4 ou au mieux TRL5 en ayant testé Spidey dans ces conditions d'utilisation réelles.


Utilisation du capteur de distance

Le code implémenté dans Spidey pour cette vidéo réalise une détection d'obstacle lorsque l'obstacle est à 10cm de son capteur. Puis il s'arrête et tourne jusqu'à ce qu'il ne détecte plus l'obstacle. Si il ne le détecte plus, il reprend la commande qui lui été donnée, c'est à dire avancer. (Dans cette partie, nous n'utilisions pas l'application, ainsi un ordre unique été donné au robot lors de la transmission du code dans la Carte Arduino).


Angle maximal

Ne pouvant pas réaliser de code utilisant le gyroscope pour rendre Spidey plus stable sur un terrain en pente, nous avons décidé de réaliser un test afin de déterminer l'angle maximal d'un terrain en pente sur lequel Spidey peut tenir, notamment grâce à ses rajouts au bout de ses pattes. 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 non lisse avec une légère pente

Pour ce test, nous avons placé Spidey sur une pente légère avec des dalles en béton et des touffes d'herbe. Lors de ce test, Spidey avait une unique commande implémentée, celle d'aller tout droite. Ce test reste ainsi concluant car il arrive bien à monter une légère pente non lisse mais aussi à marcher dans de l'herbe.


Montée d'un escalier

Pour ce test, nous avons fait monter Spidey sur l'escalier en carton que nous avions créé au préalable. Cependant, comme vous pouvez le constater sur cette vidéo la montée de l'escalier est un échec car Spidey tombe sur le dos.

🧑‍💻 Commande du robot à distance

Sur cette vidéo, vous pouvez voir l'utilisation des LEDs sur notre robot ainsi que la commande à distance des mouvements de Spidey grâce à l'application mobile. Comme décrit dans la partie utilisation des LEDs plus haut dans le Wiki, le code couleur se base sur les couleurs des boutons de l'application.

Bilan du semestre 7

Au cours de ce semestre, nous avons réussi à :

  • Piloter le robot via la plateforme Arduino.
  • Imprimer en 3D des supports pour les pattes pour que celles-ci ne glissent plus lorsque Spidey se déplace.
  • Commencer le développement de l'application mobile permettant le pilotage du robot à distance.

Bilan du semestre 8

Au cours de ce semestre, nous avons réussi à :

  • Créer une application mobile
  • Piloter le robot à distance grâce à l'application mobile
  • Utiliser le capteur de distance
  • Tester son gyroscope
  • Utiliser les NeoPixels pour indiquer les mouvements du robots
  • Monter un escalier
  • Gagner en stabilité

Chronologie du projet

Semestre 6

Séance du 01/03/22

Séance de découverte du sujet de notre projet. Nous avons alors poursuivi nos recherches sur les robots hexapodes existants sur le marché ainsi que leurs différentes utilisations.


Séance du 08/03/22

Diagramme Bête à Corne Diagramme "Pieuvre"

Durant cette séance,nous avons commencé à réaliser un diagramme de Gantt prévisionnel pour le semestre 7. Nous avons également commencé à réaliser une étude du besoin notamment avec la réalisation d'un diagramme "Bête à Corne" et d'un diagramme "Pieuvre", que vous pouvez retrouver ci-dessus.


Séance du 15/03/22

Durant cette séance, avions décidé de démarrer l'étude de marché. Pour cela nous avons fait des recherches sur les différents robots similaires qui pourraient exister. Cela nous a permis de démarrer l'étude de marché mais aussi de réaliser une étude des opportunités. En parallèle, nous avons également démarré l'analyse fonctionnelle 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é la rédaction du 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

  • Amélioration du robot
  • Finalisation de son montage


Séance du 21/10/22

  • Cherche sur une éventuelle carte qui pourrait convenir afin de pouvoir insérer d'autres composants et un servo moteur en plus. En effet la carte actuelle est entièrement utilisée et nous souhaitons rajouter des composants.
  • Essai d'implémentation du programme dans le robot : celui-ci ne fonctionnant pas, nous devons revoir l'entièreté du code et teste chaque servo moteur individuellement.
  • Test du capteur ultrasons : validé
  • Test des leds : validé


Séance du 28/10/22

  • Résolution du problème concernant les servos moteurs : il provenait d'un mauvais branchement lors du montage du robot.
  • Le robot se déplace pour la première fois !
  • On remarque cependant de gros problèmes d'adhérence au niveau de ses pattes.


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.

Diagramme de Gantt S7-S8


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.

Impression 3D Pièce imprimée rajoutée sur la patte


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

Gantt S8.png

Avancement du rapport de projet et du script de la vidéo

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.

Partie initialisation (variables, bibliothèques)

Initialisation Initialisation

Le setup

Fonction de setup

La fonction init_stable

Fonction init_stable

La fonction avancer

Fonction avancer Fonction avancer

La fonction reculer

Fonction reculer Fonction reculer

Les fonctions pour tourner

Pour tourner à droite : Tourner à droite

Pour tourner à gauche : Tourner à gauche

Utilisation du capteur de distance

Fonction d'acquisition des données : Fonction ping

Conversion des données : Fonction msToCm

Détection d'obstacles : Fonction de détection d'obstacles

Fonction finale

Fonction finale dans loop Fonction finale dans loop