Version du 21 avril 2023 à 17:45 (voir la source) Jdelcour (discussion | contributions) (→‎Les fonctions pour tourner) ← Modification précédente		Version du 23 avril 2023 à 17:13 (voir la source) Jdelcour (discussion | contributions) (→‎🏃 Déplacement de l'araignée) Modification suivante →
Ligne 290 :		Ligne 290 :
	void avancer();		void avancer();
	</pre>		</pre>
		+
		+	Voici un schéma pour mieux visualiser la décomposition des mouvements du robot qui lui permettent d'avancer :
		+	[[Fichier:differentsMouvementsPourAvancer.png]]

---

Version du 23 avril 2023 à 17:13

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

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, 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 de façon seul 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 :

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

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.

Spécifications

🤖 Equipement

Afin de pourvoir 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 à é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é ainsi que leurs références :

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

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.

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.

Branchements :

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

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.

Branchements :

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 :

Code utile à Spidey

🏃 Déplacement de l'araignée

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()

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 :

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();

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

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

Bilan du semestre 8

Pendant ce semestre, nous avons réussi à :

• Créer une application Mobile
• Faire se déplacer le robot grâce à une 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

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

Durant cette séance, nous avons cherché à 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 est 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

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)

// Inclure la librairie servo.h pour pouvoir utiliser et initialiser les servos
#include <Servo.h>

// Initialisations et librairie pour le module bluetooth
#include <SoftwareSerial.h>
#define BAUDRATE 9600
SoftwareSerial HC06(1,0);
String message;

// Initialisations et librairie pour les LEDs
#include <Adafruit_NeoPixel.h>    
#define led_numbers  6 //WS2812 nombre de leds
#define LED_PIN  A1  //WS2812 PIN 
Adafruit_NeoPixel strip = Adafruit_NeoPixel(led_numbers,LED_PIN,NEO_GRB+NEO_KHZ800);//Contrôle de la bande de Led NeoPixels
int R=random(0,255);
int G=random(0,255);
int B=random(0,255);

// Déclaration des variables des différents servos
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

// Définition des différents PIN des servos
#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

// Initialisation des variables pour l'utilisation du capteur
const int pingPin = A3;  //Connexion de la pin echo
const int trigPin = A2;  //Connexion de la pin trig
#define distance_MAX 10 
#define max_capt 1012

Le setup

void setup()
{ 
  HC06.begin(BAUDRATE); //Configuration du module Bluetooth HC06 à la vitesse de transmission BAUDRATE
  
  // 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); //Tete que nous n'utilisons pas

  init_stable(); //Robot en position initiale

  //Capteur de distance
  pinMode(pingPin, INPUT); //Connection du pin INPUT en mode Echo pin
  pinMode(trigPin, OUTPUT); //Connection du pin OUTPUT en mode Trig pin

  //LEDS
  strip.begin(); //Intitialisaiton des LEDS WS2812
  strip.setBrightness(50); //Intitialisation de la luminosité des LEDS
}

La fonction init_stable

void init_stable()
{
  servo2.write(90);
  servo3.write(120); 
  servo4.write(95);
  servo5.write(100);
  servo6.write(70);
  servo7.write(90);
  servo8.write(80);
  servo9.write(110); 
  servo10.write(90);
  servo11.write(45);
  servo12.write(50); 
  servo13.write(100); 
  //servo14.write(-20); 
 }

La fonction avancer

 void avancer()
 {
  //Lever 3 de ses pattes
  servo2.write(10);
  servo6.write(10);
  servo10.write(190);
  delay(250);
  //Les déplacer vers l'avant
  servo3.write(150);
  servo7.write(140);
  servo11.write(10);
  delay(250);
  //Les poser
  servo2.write(90);
  servo6.write(70);
  servo10.write(90);
  delay(250);
  //Les déplacer vers l'arrière
  servo3.write(90);
  servo7.write(90);
  servo11.write(50);
  delay(250);
  //Lever ses 3 autres pattes
  servo8.write(170);
  servo4.write(40);
  servo12.write(140);
  delay(250);
  //Les déplacer vers l'avant
  servo5.write(130);
  servo9.write(80);
  servo13.write(40);
  delay(250);
  //Les poser
  servo8.write(80);
  servo4.write(95);
  servo12.write(50);
  delay(250);
  //Les déplacer vers l'arrière
  servo5.write(90);
  servo9.write(150);
  servo13.write(90);
  delay(250);
  }

La fonction reculer

Les fonctions pour tourner

Pour tourner à droite :

Pour tourner à gauche :

Utilisation du capteur de distance