Learning Lab Environnements Connectés - Contributions de l’utilisateur [fr]

Robots jardiniers

2023-05-22T17:07:00Z

Emilie cnvt : /* Pseudo code estimé */

=Missions des robots jardiniers=

 Comment concevoir un robot jardinier capable d’explorer son environnement, d’identifier les emplacements optimaux pour semer des graines et s’occuper des plants ? 

 

On dispose de 3 bases roulantes holonomes sur lesqueless on peut monter une batterie de capteur qu'on appellera par la suite robot 1, 2 et 3. L'environnement de fonctionnement du robot est un terrain plat contenant des obstacles à éviter (type rochers), et des points d'intérêts où il est possible de planter des graines. Les positions de ces éléments ne sont pas connues initialement. Il est donc possible de séparer le fonctionnement du robots en 2 phases successives. Un première phase de découverte de l'environnement puis un phase d'action.

 

On peut alors définir un plan d'action des robots jardiniers à travers les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol

 

On peut finalement reformuler ces actions sous forme d'un cahier des charges plus concis.
 
Robot 1 :
* Explorer un environnement
* Mesurer des paramètres expérimentaux
* Déterminer un environnement propice à l'ensemencement
* Enregistrer et communiquer un chemin

 

Robot 2 et 3 :
* Suivre un chemin
* Arroser / forer le sol

Les solutions techniques mises en place pour répondre à ces attentes seront détaillées par la suite. Il convient de noter que toutes ces fonctions n'ont cependant pas pu être réalisées.

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Également, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.

 

Ces groupes sont les suivants :
* Groupe 1 : Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots) : 6 étudiants
* Groupe 2 : Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1) : 3 étudiants
* Groupe 3 : Robot 3 (robot planteur qui suivra le chemin créé par le robot 1) : 3 étudiants

 

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes ont souvent travaillé ensemble.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.
 

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

 

Étant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continu à droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode, mais en inversant la droite et la gauche.

 

Voici un schéma explicatif de l'algorithme utilisé :
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra, au choix, refaire le même chemin en sens inverse (on retiendra chacun des mouvements), ou s'arrêter lorsque la coordonnée y du robot sera assez proche de celle de départ.
Ce schéma est assez simpliste, mais présente globalement la façon dont notre algorithme fonctionne. Il est également applicable sur certaines formes plus complexes (voir schéma ci-dessous)
[[Fichier:robot_algo_3.png|600px]] 
Pour faciliter la compréhension de l'algorithme, voici un schéma explicatif de ce dernier
[[Fichier:Schéma_stylé.png|1000px]]

 

Cet algorithme est assez simpliste mais sera capable de parcourir la plupart des terrains proposés de manière efficace. Il faudra malgré tout veiller à positionner le point de départ du robot sur le point le plus éloigné du mur en face possible.
Un problème de notre algorithme est que le robot peut rester coincé dans certaines configurations, cela aurait été évitable mais par manque de temps, nous ne pourrons pas palier à ce problème.

==Pseudo code estimé==
Voici notre première version de l'algorithme du contrôle du robot, ce code a changé car nous n'effectuons plus d'interruptions. En effet, on teste tout les 10cm s'il n'y a pas d'obstacle ainsi nous n'avons plus besoin d'interruptions. La prise de mesure des capteurs ultrasons est relevée à intervalles réguliers dans la loop.
<pre>
int deplacement ;
int direction;

suivant(deplacement) //suivant le déplacement qu'on a choisi
cas avant:
moteur_avant(10); //on avance le moteur correspondant

cas gauche:
moteur_gauche(10);

cas droite:
moteur_droite(10);

default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
si direction = gauche //si la direction était gauche alors, elle devient droite et inversement
deplacement=droite;
else
deplacement=gauche;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

s'il n'y a pas d'obstacle à droite
deplacement=droite; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=arriere; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=avant; //dès qu'on arrive en bas du jardin, on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes donc nous n'avons pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs :
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

 

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors :
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises.

 

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.
 
== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple : la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Contraintes liés au capteur d'humidité du sol =
Le capteur d'humidité du sol comme son nom l’indique, prend une mesure de l’humidité d’un sol. Nous avons donc dû trouver une méthode pour planter la fourche sensoriel du capteur dans le sol à mesurer. Pour ce faire, nous avons imaginé trois méthodes :

* Utilisation d’un vérin
* Utilisation d’une vis sans fin
* utilisation d’un bras

Le vérin semblait être une bonne idée, cependant son coût ainsi que sa consommation d'énergie ne correspondait pas à nos attentes (30€ pour les moins chère et au minimum 12V d’alimentation).

La vis sans fin nous à paru être la meilleure option, elle nécessite uniquement un moteur, une vis et un écrou. Nous avions deux moteurs à disposition, l’un était rapide mais avec peu de couple et l’autre était lent avec plus de couple. Dans l’objectif d’enfoncer notre capteur dans le sol nous avons donc choisi d’utiliser le moteur lent avec du couple. En effet, il faut beaucoup de force pour enfoncer le capteur, de plus, le temps n’est pas une contrainte dans ce cas. Pour relier la vis au moteur, nous avons essayé de souder la vis au moteur : [[Fichier:Capture d’écran 2023-05-11 171145.png]]

Malheureusement, il nous à été trop difficile d'axer parfaitement la vis. De plus la vitesse du moteur (1/4 tour par seconde) ainsi que la forme de la vis on rendu cette méthode obsolète ( 1 minute pour descendre le capteur et 1 minute pour le remonter).

Nous avons finalement choisi la dernière méthode, qui consistait à fixer un bras sur le moteur avec notre capteur au bout. Cette méthode est assez facile à mettre en place cependant elle est également moins efficace pour planter un capteur, car elle développe moins de force. Pour la conception du bras, nous avons utilisé les outils et matériaux disponibles dans l’atelier. Au final voici à quoi ressemble le bras : [[Fichier:Capture d’écran 2023-05-11 171434.png]]

Concernant le moteur utilisé :
Nous avons utilisé un moteur 28BYJ ce moteur pas à pas est composé de 5 entrées, 4 bobinages et une alimentation. Pour le faire tourner, on va donc alimenter chaque bobinage l’un après l’autre, de façon à faire un cycle. On fera par la suite une boucle de descente et une boucle de monté du capteur en laissant un délai en bas pour prendre les mesures.
[[Fichier:Capture d’écran 2023-05-11 170600.png]]

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : ESP32 Thing et Teensy.

- ESP32 Thing : 
Nous avons choisi cette carte, car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5 VDC. Il s'alimente à l'aide d'une batterie de 9.6 V composée de 8 cellules Ni.Mh, la tension maximale est d'environ 10.7 V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2 V, ils consomment chacun à 0.5 A en fonctionnement à vide et jusqu'à 1.3 A en fonctionnement nominal (à un couple de 2 kg.cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9 V -> 3.3 V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni.Mh, qui délivre 9.6 V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
: Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

=Déplacement des robots=

==Robot 1==

===Contrôle des déplacements du robot===
Afin de contrôler les déplacements du robot, nous allons utiliser le code pour une plateforme holonome moteur.
La procédure à suivre pour vérifier et tester le fonctionnement des moteurs et de l'asservissement :

 

#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Tester les moteurs en envoyer les commandes suivantes :
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.
 
On peut tester le code grâce à une console série avec une vitesse de 115 200. On utilise alors le port sérié par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin(115200);</code>).
 
Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient un problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :
 
Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.
 
Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandées et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

 

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.
 
Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la Due utiliser (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

== Robot 2 et 3 ==

La première étape est de contrôler les moteurs avec la Teensy, pour cela, il faut utiliser le code suivant :[[Fichier:teensy_r_esp.zip]]
 
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes :
#La commande ahXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande ahXXX.
#Vous pouvez aussi tester les commandes AT et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

 

 Remarque: L'asservissement des moteurs n'est pas fonctionnel, le robot se déplace bien dans les directions qui ne nécessitent que la rotation de deux roues (ah000, ah120, ah240) mais pour le reste le robot dévie de la trajectoire désirée.

 

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela, vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas, nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes, nous avons donc utilisé Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

==Asservissement des déplacements==

Afin de pouvoir contrôler la distance parcourue par chaque, nous avons essayé de mettre en place un asservissement à l'aide d'une centrale inertielle. Pour cela, on utilise une centrale inertielle 10DOF équipée d'un MPU9250.

Pour avoir des mesures fiables, nous avons réaliser un étalonnage de l'accéléromètre sur ses trois axes. Ensuite, en utilisant une formule de dérivation numérique, on peut calculer la distance parcourue par chaque robot. Pour être sûr que cette méthode soit fiable, il faut avoir la fréquence de rafraichissement du capteur et la fréquence d'interruption, afin d'accorder la fréquence de calcul à notre problème.

On a déterminé les valeurs d'étalonnage suivantes:
Sensibilité: Sx=1.000085
Sy=0.99634
Sz=1.01619
Offset: Offx=0.034625
Offy=0.01245
Offz=0.04328

Cette méthode n'a cependant pas pu être mis en place et tester sur les robots.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et choisit le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.
 
La suite d'instruction permettant de guider les robots jusqu'au point d'intérêt est envoyée dans une seule chaîne de caractère, les ESP32 des robots 2 et 3 auront ensuite pour rôle de lire cette chaine par couple de caractère, chacun indiquant une instruction, celle-ci est ensuite traduite en une commande que la Teensy pourra comprendre. Les instructions envoyées par le robot 1 via la chaîne de caractère seront les suivantes : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.
* ac : Action : Planter/Arroser (selon le robot)

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code utiliser pour le Bluetooth : [Cliquer ici pour télécharger le fichier ] [[Fichier:Bluetooth.zip]]

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz.

 
Il existe deux méthodes de communication avec la bibliothèque ESP-NOW:
#La première est qu'une première carte (initiator) envoie des données à une autre carte (responder) précise via son adresse MAC.
#Le broadcast, cette méthode permet à l'initiator de communiquer avec toutes les responders à portée. Cela ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder.
 
Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. L'ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

Dans notre cas, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports Serial 3 deux fils vers Serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

Ici la carte envoie un message à l'ESP32 qui doit la transmettre à l'autre ESP32, c'était un test. Par la suite, ce message sera modifié en fonction du chemin parcouru par le robot 1.

 

Les ESP32 des robots 2&3 devront ensuite découper le message en instructions (couple de caractères), ces instructions sont ensuite traduites pour être comprises par la Teensy. Exemple: av --> ah000 et ho3, dr --> ah270 et ho3.
 

Voici donc les codes nécessaires pour cette communication:

 

Pour la ESP32 en mode Broadcast : [Cliquer ici pour télécharger le fichier] [[Fichier:Boradcast.ZIP]]

 
POur la ESP32 qui reçoit le message : [Cliquer ici pour télécharger le fichier] [[Fichier:Responder.ZIP]]

 

Comme dit précédemment les robots 2&3 ne sont pas bien asservis et ne peuvent donc pas reproduire le trajet demandé par le robot 1, ici un délai de 500ms a été mis pour chaque instruction (ex: av --> le robot avance tout droit pendant 500ms) tandis que pour le robot 1 chaque commande correspond à une durée de 0.5s. Cependant les robots ne vont pas à la même vitesse, il faudrait donc prendre en compte celles ci pour déterminer la durée de chaque instruction pour les robots 2&3.

=Implémentation des algorithme finaux=
==Implémentation de l'algorithme de déplacement du robot 1==
Le programme principal sera disponible ici :[[Fichier:Prog_principal.zip]]
Afin de simplifier la compréhension et la lisibilité du code, nous utiliserons 2 énumérations permettant de lier un entier à un texte utilisable dans le code.
<pre>
enum directions { AUCUNE,
AVANT,
ARRIERE,
DROITE,
GAUCHE };
enum action { RIEN,
PLANTE,
ARROSE,
LESDEUX };
</pre>
Notre programme est constitué de 3 fonctions principales:
*La '''boucle principale()''' permettant de faire rouler le robot et d'appeler les autres fonctions.
*La fonction '''capture()''' permettant de détecter si la zone doit être plantée, arrosée, ou aucun des deux
*La fonction '''Determine_direction()''' permettant de déterminer la prochaine direction
'''Fonction Capture()'''
<pre>
int capture() {
int act;
float temperature, humidite;
int moisture, uvi;
temperature = temp(); // fonction retournant la température
humidite = hum(); // fonction retournant l'humidité
moisture = mois(); fonction retournant l'humidité du sol
uvi = uv(); fonction retournant l'indice UV
act = RIEN;
// UV INDEX LIMIT : 40
// TEMPERATURE INDEX LIMIT: 25
if (humidite > 50 && moisture < 400) {
act = LESDEUX;
} else {
if (humidite > 50) { act = PLANTE; }
if (moisture < 400) { act = ARROSE; }
}
return act;
}
</pre>
'''Fonction determine_direction()''' 
Cette fonction est appelée toutes les 0.5 secondes et permet d'actualiser la direction du robot en fonction de son environnement.
à chaque incrément, on envoie la direction aux roues avec la fonction Serial2.print() en indiquant dans les parenthèses la direction souhaitée.
<pre>
void determine_direction() {
distance_av = ultrasonic_av.read();
distance_ar = ultrasonic_ar.read();
distance_d = ultrasonic_d.read();
distance_g = ultrasonic_g.read();
switch (direction) {
case AVANT:
if (distance_av > 50) {
Serial.println("Avance ");
Serial2.print("avd");
position_tab[tab_index].direction = AVANT;
y = y + 1;
} else {
depart = true;
direction = GAUCHE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case DROITE:
if (distance_d > 30) {
Serial.println("Droite ");
Serial2.print("dr");
position_tab[tab_index].direction = DROITE;
direction_prec = DROITE;
x = x + 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case GAUCHE:
if (distance_g > 30) {
Serial.println("Gauche ");
Serial2.print("ga");
position_tab[tab_index].direction = GAUCHE;
direction_prec = GAUCHE;
x = x - 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;

case ARRIERE:
if (distance_ar > 30) {
if (pas_arriere < 5) { // On recule sur des incréments de 5
pas_arriere++;
Serial.println("Arriere ");
Serial2.print("ard");
y = y - 1;
position_tab[tab_index].direction = ARRIERE;
} else {
position_tab[tab_index].direction = AUCUNE;

pas_arriere = 0;
if (direction_prec == DROITE) { // Balayer de gauche à droite
direction = GAUCHE;
} else {
direction = DROITE;
}
}
} else {
position_tab[tab_index].direction = AUCUNE;
if (direction_prec == DROITE) {
direction = GAUCHE;
} else {
direction = DROITE;
}
}
break;
default: break;
}
if (position_tab[tab_index].direction != AUCUNE) { j++; }
}
</pre>
'''Boucle principale''' 
Cette fonction est décomposée en 2 parties. Tout d'abord, on détecte si le programme est terminé. Si tel est le cas, on envoie les données aux autres robots en parcourant le tableau position_tab rempli dans les autres fonctions (données de direction et d'action). Sinon, on continue la boucle en déterminant la direction et en capturant tous les 5 incréments de temps
<pre>
void loop() {
if (!fin) {
if (depart && y <= 1) { // Lorsqu'on revient au point de départ, on s'arrête et on envoie les informations
Serial2.println("st");
// Amelioration possible, le faire revenir à x = 0
// ENVOI DES DONNEES
for (int i = 0; i < tab_index; i++) {
switch (position_tab[i].direction) {
case AVANT:
Serial3.print("av");
break;
case DROITE:
Serial3.print("dr");
break;
case GAUCHE:
Serial3.print("ga");
break;
case ARRIERE:
Serial3.print("ar");
break;
default:
break;
}
switch (position_tab[i].action) {
case PLANTE:
Serial3.print("pl");
break;
case ARROSE:
Serial3.print("wa");
break;
case LESDEUX:
Serial3.print("l2");
break;
default:
break;
}
}
fin = true;
} else {
determine_direction();
if (j == 5) { // On effectue une capture tous les 5 incréments
condition = capture();
switch (condition) {
case ARROSE:
Serial.println("On arrose");
position_tab[tab_index].action = ARROSE;
break;
case PLANTE:
Serial.println("On plante");
position_tab[tab_index].action = PLANTE;
break;
case LESDEUX:
Serial.println("Les deux");
position_tab[tab_index].action = LESDEUX;
break;
default:
position_tab[tab_index].action = RIEN;
break;
}
j = 0;
} else {
position_tab[tab_index].action = RIEN;
}
tab_index++;
}
delay(500); // On rafraichit la direction toutes les 0.5 secondes
}
}
</pre>
==Tests de l'algorithme du robot 1==
Plusieurs tests ont été effectués tout au long du projet pour tester nos algorithmes les premiers utilisaient seulement les capteurs à ultrasons mais au fur et à mesure, nous avons réussi a lier l'ensemble des composants, voici quelques vidéos montrant les tests effectués.
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=hlS6NtwyzBk
|alignment=left
|description=test du robot 1 immobile
}}
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=ECn0T1XQ3xc
|alignment=right
|description=test du robot 1 en conditions "réelles"
}}
 
Comme on voit sur la 2ème vidéo, puisque l'une des roues ne fonctionne pas dans un sens, il est impossible pour le robot d'aller à droite, et donc impossible de tester notre robot de façon réelle.

Robots jardiniers

2023-05-22T16:57:51Z

Emilie cnvt : /* Communication entre les robots */

=Missions des robots jardiniers=

 Comment concevoir un robot jardinier capable d’explorer son environnement, d’identifier les emplacements optimaux pour semer des graines et s’occuper des plants ? 

 

On dispose de 3 bases roulantes holonomes sur lesqueless on peut monter une batterie de capteur qu'on appellera par la suite robot 1, 2 et 3. L'environnement de fonctionnement du robot est un terrain plat contenant des obstacles à éviter (type rochers), et des points d'intérêts où il est possible de planter des graines. Les positions de ces éléments ne sont pas connues initialement. Il est donc possible de séparer le fonctionnement du robots en 2 phases successives. Un première phase de découverte de l'environnement puis un phase d'action.

 

On peut alors définir un plan d'action des robots jardiniers à travers les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol

 

On peut finalement reformuler ces actions sous forme d'un cahier des charges plus concis.
 
Robot 1 :
* Explorer un environnement
* Mesurer des paramètres expérimentaux
* Déterminer un environnement propice à l'ensemencement
* Enregistrer et communiquer un chemin

 

Robot 2 et 3 :
* Suivre un chemin
* Arroser / forer le sol

Les solutions techniques mises en place pour répondre à ces attentes seront détaillées par la suite. Il convient de noter que toutes ces fonctions n'ont cependant pas pu être réalisées.

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Également, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.

 

Ces groupes sont les suivants :
* Groupe 1 : Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots) : 6 étudiants
* Groupe 2 : Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1) : 3 étudiants
* Groupe 3 : Robot 3 (robot planteur qui suivra le chemin créé par le robot 1) : 3 étudiants

 

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes ont souvent travaillé ensemble.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.
 

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

 

Étant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continu à droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode, mais en inversant la droite et la gauche.

 

Voici un schéma explicatif de l'algorithme utilisé :
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra, au choix, refaire le même chemin en sens inverse (on retiendra chacun des mouvements), ou s'arrêter lorsque la coordonnée y du robot sera assez proche de celle de départ.
Ce schéma est assez simpliste, mais présente globalement la façon dont notre algorithme fonctionne. Il est également applicable sur certaines formes plus complexes (voir schéma ci-dessous)
[[Fichier:robot_algo_3.png|600px]] 
Pour faciliter la compréhension de l'algorithme, voici un schéma explicatif de ce dernier
[[Fichier:Schéma_stylé.png|1000px]]

 

Cet algorithme est assez simpliste mais sera capable de parcourir la plupart des terrains proposés de manière efficace. Il faudra malgré tout veiller à positionner le point de départ du robot sur le point le plus éloigné du mur en face possible.
Un problème de notre algorithme est que le robot peut rester coincé dans certaines configurations, cela aurait été évitable mais par manque de temps, nous ne pourrons pas palier à ce problème.

==Pseudo code estimé==
Voici une version de base du code de contrôle du robot, ce code a changé car nous n'effectuons plus d'interruptions. La prise de mesure des capteurs ultrasons est relevée dans la loop. On teste avant d'avancer s'il n'y a pas d'obstacle.
<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors, elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin, on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes donc nous n'avons pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs :
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

 

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors :
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises.

 

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.
 
== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple : la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Contraintes liés au capteur d'humidité du sol =
Le capteur d'humidité du sol comme son nom l’indique, prend une mesure de l’humidité d’un sol. Nous avons donc dû trouver une méthode pour planter la fourche sensoriel du capteur dans le sol à mesurer. Pour ce faire, nous avons imaginé trois méthodes :

* Utilisation d’un vérin
* Utilisation d’une vis sans fin
* utilisation d’un bras

Le vérin semblait être une bonne idée, cependant son coût ainsi que sa consommation d'énergie ne correspondait pas à nos attentes (30€ pour les moins chère et au minimum 12V d’alimentation).

La vis sans fin nous à paru être la meilleure option, elle nécessite uniquement un moteur, une vis et un écrou. Nous avions deux moteurs à disposition, l’un était rapide mais avec peu de couple et l’autre était lent avec plus de couple. Dans l’objectif d’enfoncer notre capteur dans le sol nous avons donc choisi d’utiliser le moteur lent avec du couple. En effet, il faut beaucoup de force pour enfoncer le capteur, de plus, le temps n’est pas une contrainte dans ce cas. Pour relier la vis au moteur, nous avons essayé de souder la vis au moteur : [[Fichier:Capture d’écran 2023-05-11 171145.png]]

Malheureusement, il nous à été trop difficile d'axer parfaitement la vis. De plus la vitesse du moteur (1/4 tour par seconde) ainsi que la forme de la vis on rendu cette méthode obsolète ( 1 minute pour descendre le capteur et 1 minute pour le remonter).

Nous avons finalement choisi la dernière méthode, qui consistait à fixer un bras sur le moteur avec notre capteur au bout. Cette méthode est assez facile à mettre en place cependant elle est également moins efficace pour planter un capteur, car elle développe moins de force. Pour la conception du bras, nous avons utilisé les outils et matériaux disponibles dans l’atelier. Au final voici à quoi ressemble le bras : [[Fichier:Capture d’écran 2023-05-11 171434.png]]

Concernant le moteur utilisé :
Nous avons utilisé un moteur 28BYJ ce moteur pas à pas est composé de 5 entrées, 4 bobinages et une alimentation. Pour le faire tourner, on va donc alimenter chaque bobinage l’un après l’autre, de façon à faire un cycle. On fera par la suite une boucle de descente et une boucle de monté du capteur en laissant un délai en bas pour prendre les mesures.
[[Fichier:Capture d’écran 2023-05-11 170600.png]]

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : ESP32 Thing et Teensy.

- ESP32 Thing : 
Nous avons choisi cette carte, car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5 VDC. Il s'alimente à l'aide d'une batterie de 9.6 V composée de 8 cellules Ni.Mh, la tension maximale est d'environ 10.7 V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2 V, ils consomment chacun à 0.5 A en fonctionnement à vide et jusqu'à 1.3 A en fonctionnement nominal (à un couple de 2 kg.cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9 V -> 3.3 V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni.Mh, qui délivre 9.6 V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
: Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

=Déplacement des robots=

==Robot 1==

===Contrôle des déplacements du robot===
Afin de contrôler les déplacements du robot, nous allons utiliser le code pour une plateforme holonome moteur.
La procédure à suivre pour vérifier et tester le fonctionnement des moteurs et de l'asservissement :

 

#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Tester les moteurs en envoyer les commandes suivantes :
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.
 
On peut tester le code grâce à une console série avec une vitesse de 115 200. On utilise alors le port sérié par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin(115200);</code>).
 
Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient un problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :
 
Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.
 
Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandées et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

 

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.
 
Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la Due utiliser (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

== Robot 2 et 3 ==

La première étape est de contrôler les moteurs avec la Teensy, pour cela, il faut utiliser le code suivant :[[Fichier:teensy_r_esp.zip]]
 
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes :
#La commande ahXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande ahXXX.
#Vous pouvez aussi tester les commandes AT et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

 

 Remarque: L'asservissement des moteurs n'est pas fonctionnel, le robot se déplace bien dans les directions qui ne nécessitent que la rotation de deux roues (ah000, ah120, ah240) mais pour le reste le robot dévie de la trajectoire désirée.

 

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela, vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas, nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes, nous avons donc utilisé Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

==Asservissement des déplacements==

Afin de pouvoir contrôler la distance parcourue par chaque, nous avons essayé de mettre en place un asservissement à l'aide d'une centrale inertielle. Pour cela, on utilise une centrale inertielle 10DOF équipée d'un MPU9250.

Pour avoir des mesures fiables, nous avons réaliser un étalonnage de l'accéléromètre sur ses trois axes. Ensuite, en utilisant une formule de dérivation numérique, on peut calculer la distance parcourue par chaque robot. Pour être sûr que cette méthode soit fiable, il faut avoir la fréquence de rafraichissement du capteur et la fréquence d'interruption, afin d'accorder la fréquence de calcul à notre problème.

On a déterminé les valeurs d'étalonnage suivantes:
Sensibilité: Sx=1.000085
Sy=0.99634
Sz=1.01619
Offset: Offx=0.034625
Offy=0.01245
Offz=0.04328

Cette méthode n'a cependant pas pu être mis en place et tester sur les robots.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et choisit le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.
 
La suite d'instruction permettant de guider les robots jusqu'au point d'intérêt est envoyée dans une seule chaîne de caractère, les ESP32 des robots 2 et 3 auront ensuite pour rôle de lire cette chaine par couple de caractère, chacun indiquant une instruction, celle-ci est ensuite traduite en une commande que la Teensy pourra comprendre. Les instructions envoyées par le robot 1 via la chaîne de caractère seront les suivantes : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.
* ac : Action : Planter/Arroser (selon le robot)

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code utiliser pour le Bluetooth : [Cliquer ici pour télécharger le fichier ] [[Fichier:Bluetooth.zip]]

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz.

 
Il existe deux méthodes de communication avec la bibliothèque ESP-NOW:
#La première est qu'une première carte (initiator) envoie des données à une autre carte (responder) précise via son adresse MAC.
#Le broadcast, cette méthode permet à l'initiator de communiquer avec toutes les responders à portée. Cela ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder.
 
Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. L'ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

Dans notre cas, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports Serial 3 deux fils vers Serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

Ici la carte envoie un message à l'ESP32 qui doit la transmettre à l'autre ESP32, c'était un test. Par la suite, ce message sera modifié en fonction du chemin parcouru par le robot 1.

 

Les ESP32 des robots 2&3 devront ensuite découper le message en instructions (couple de caractères), ces instructions sont ensuite traduites pour être comprises par la Teensy. Exemple: av --> ah000 et ho3, dr --> ah270 et ho3.
 

Voici donc les codes nécessaires pour cette communication:

 

Pour la ESP32 en mode Broadcast : [Cliquer ici pour télécharger le fichier] [[Fichier:Boradcast.ZIP]]

 
POur la ESP32 qui reçoit le message : [Cliquer ici pour télécharger le fichier] [[Fichier:Responder.ZIP]]

 

Comme dit précédemment les robots 2&3 ne sont pas bien asservis et ne peuvent donc pas reproduire le trajet demandé par le robot 1, ici un délai de 500ms a été mis pour chaque instruction (ex: av --> le robot avance tout droit pendant 500ms) tandis que pour le robot 1 chaque commande correspond à une durée de 0.5s. Cependant les robots ne vont pas à la même vitesse, il faudrait donc prendre en compte celles ci pour déterminer la durée de chaque instruction pour les robots 2&3.

=Implémentation des algorithme finaux=
==Implémentation de l'algorithme de déplacement du robot 1==
Le programme principal sera disponible ici :[[Fichier:Prog_principal.zip]]
Afin de simplifier la compréhension et la lisibilité du code, nous utiliserons 2 énumérations permettant de lier un entier à un texte utilisable dans le code.
<pre>
enum directions { AUCUNE,
AVANT,
ARRIERE,
DROITE,
GAUCHE };
enum action { RIEN,
PLANTE,
ARROSE,
LESDEUX };
</pre>
Notre programme est constitué de 3 fonctions principales:
*La '''boucle principale()''' permettant de faire rouler le robot et d'appeler les autres fonctions.
*La fonction '''capture()''' permettant de détecter si la zone doit être plantée, arrosée, ou aucun des deux
*La fonction '''Determine_direction()''' permettant de déterminer la prochaine direction
'''Fonction Capture()'''
<pre>
int capture() {
int act;
float temperature, humidite;
int moisture, uvi;
temperature = temp(); // fonction retournant la température
humidite = hum(); // fonction retournant l'humidité
moisture = mois(); fonction retournant l'humidité du sol
uvi = uv(); fonction retournant l'indice UV
act = RIEN;
// UV INDEX LIMIT : 40
// TEMPERATURE INDEX LIMIT: 25
if (humidite > 50 && moisture < 400) {
act = LESDEUX;
} else {
if (humidite > 50) { act = PLANTE; }
if (moisture < 400) { act = ARROSE; }
}
return act;
}
</pre>
'''Fonction determine_direction()''' 
Cette fonction est appelée toutes les 0.5 secondes et permet d'actualiser la direction du robot en fonction de son environnement.
à chaque incrément, on envoie la direction aux roues avec la fonction Serial2.print() en indiquant dans les parenthèses la direction souhaitée.
<pre>
void determine_direction() {
distance_av = ultrasonic_av.read();
distance_ar = ultrasonic_ar.read();
distance_d = ultrasonic_d.read();
distance_g = ultrasonic_g.read();
switch (direction) {
case AVANT:
if (distance_av > 50) {
Serial.println("Avance ");
Serial2.print("avd");
position_tab[tab_index].direction = AVANT;
y = y + 1;
} else {
depart = true;
direction = GAUCHE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case DROITE:
if (distance_d > 30) {
Serial.println("Droite ");
Serial2.print("dr");
position_tab[tab_index].direction = DROITE;
direction_prec = DROITE;
x = x + 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case GAUCHE:
if (distance_g > 30) {
Serial.println("Gauche ");
Serial2.print("ga");
position_tab[tab_index].direction = GAUCHE;
direction_prec = GAUCHE;
x = x - 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;

case ARRIERE:
if (distance_ar > 30) {
if (pas_arriere < 5) { // On recule sur des incréments de 5
pas_arriere++;
Serial.println("Arriere ");
Serial2.print("ard");
y = y - 1;
position_tab[tab_index].direction = ARRIERE;
} else {
position_tab[tab_index].direction = AUCUNE;

pas_arriere = 0;
if (direction_prec == DROITE) { // Balayer de gauche à droite
direction = GAUCHE;
} else {
direction = DROITE;
}
}
} else {
position_tab[tab_index].direction = AUCUNE;
if (direction_prec == DROITE) {
direction = GAUCHE;
} else {
direction = DROITE;
}
}
break;
default: break;
}
if (position_tab[tab_index].direction != AUCUNE) { j++; }
}
</pre>
'''Boucle principale''' 
Cette fonction est décomposée en 2 parties. Tout d'abord, on détecte si le programme est terminé. Si tel est le cas, on envoie les données aux autres robots en parcourant le tableau position_tab rempli dans les autres fonctions (données de direction et d'action). Sinon, on continue la boucle en déterminant la direction et en capturant tous les 5 incréments de temps
<pre>
void loop() {
if (!fin) {
if (depart && y <= 1) { // Lorsqu'on revient au point de départ, on s'arrête et on envoie les informations
Serial2.println("st");
// Amelioration possible, le faire revenir à x = 0
// ENVOI DES DONNEES
for (int i = 0; i < tab_index; i++) {
switch (position_tab[i].direction) {
case AVANT:
Serial3.print("av");
break;
case DROITE:
Serial3.print("dr");
break;
case GAUCHE:
Serial3.print("ga");
break;
case ARRIERE:
Serial3.print("ar");
break;
default:
break;
}
switch (position_tab[i].action) {
case PLANTE:
Serial3.print("pl");
break;
case ARROSE:
Serial3.print("wa");
break;
case LESDEUX:
Serial3.print("l2");
break;
default:
break;
}
}
fin = true;
} else {
determine_direction();
if (j == 5) { // On effectue une capture tous les 5 incréments
condition = capture();
switch (condition) {
case ARROSE:
Serial.println("On arrose");
position_tab[tab_index].action = ARROSE;
break;
case PLANTE:
Serial.println("On plante");
position_tab[tab_index].action = PLANTE;
break;
case LESDEUX:
Serial.println("Les deux");
position_tab[tab_index].action = LESDEUX;
break;
default:
position_tab[tab_index].action = RIEN;
break;
}
j = 0;
} else {
position_tab[tab_index].action = RIEN;
}
tab_index++;
}
delay(500); // On rafraichit la direction toutes les 0.5 secondes
}
}
</pre>
==Tests de l'algorithme du robot 1==
Plusieurs tests ont été effectués tout au long du projet pour tester nos algorithmes les premiers utilisaient seulement les capteurs à ultrasons mais au fur et à mesure, nous avons réussi a lier l'ensemble des composants, voici quelques vidéos montrant les tests effectués.
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=hlS6NtwyzBk
|alignment=left
|description=test du robot 1 immobile
}}
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=ECn0T1XQ3xc
|alignment=right
|description=test du robot 1 en conditions "réelles"
}}
 
Comme on voit sur la 2ème vidéo, puisque l'une des roues ne fonctionne pas dans un sens, il est impossible pour le robot d'aller à droite, et donc impossible de tester notre robot de façon réelle.

Robots jardiniers

2023-05-22T16:57:04Z

Emilie cnvt : /* Contraintes liés au capteur d'humidité du sol */

=Missions des robots jardiniers=

 Comment concevoir un robot jardinier capable d’explorer son environnement, d’identifier les emplacements optimaux pour semer des graines et s’occuper des plants ? 

 

On dispose de 3 bases roulantes holonomes sur lesqueless on peut monter une batterie de capteur qu'on appellera par la suite robot 1, 2 et 3. L'environnement de fonctionnement du robot est un terrain plat contenant des obstacles à éviter (type rochers), et des points d'intérêts où il est possible de planter des graines. Les positions de ces éléments ne sont pas connues initialement. Il est donc possible de séparer le fonctionnement du robots en 2 phases successives. Un première phase de découverte de l'environnement puis un phase d'action.

 

On peut alors définir un plan d'action des robots jardiniers à travers les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol

 

On peut finalement reformuler ces actions sous forme d'un cahier des charges plus concis.
 
Robot 1 :
* Explorer un environnement
* Mesurer des paramètres expérimentaux
* Déterminer un environnement propice à l'ensemencement
* Enregistrer et communiquer un chemin

 

Robot 2 et 3 :
* Suivre un chemin
* Arroser / forer le sol

Les solutions techniques mises en place pour répondre à ces attentes seront détaillées par la suite. Il convient de noter que toutes ces fonctions n'ont cependant pas pu être réalisées.

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Également, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.

 

Ces groupes sont les suivants :
* Groupe 1 : Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots) : 6 étudiants
* Groupe 2 : Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1) : 3 étudiants
* Groupe 3 : Robot 3 (robot planteur qui suivra le chemin créé par le robot 1) : 3 étudiants

 

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes ont souvent travaillé ensemble.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.
 

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

 

Étant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continu à droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode, mais en inversant la droite et la gauche.

 

Voici un schéma explicatif de l'algorithme utilisé :
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra, au choix, refaire le même chemin en sens inverse (on retiendra chacun des mouvements), ou s'arrêter lorsque la coordonnée y du robot sera assez proche de celle de départ.
Ce schéma est assez simpliste, mais présente globalement la façon dont notre algorithme fonctionne. Il est également applicable sur certaines formes plus complexes (voir schéma ci-dessous)
[[Fichier:robot_algo_3.png|600px]] 
Pour faciliter la compréhension de l'algorithme, voici un schéma explicatif de ce dernier
[[Fichier:Schéma_stylé.png|1000px]]

 

Cet algorithme est assez simpliste mais sera capable de parcourir la plupart des terrains proposés de manière efficace. Il faudra malgré tout veiller à positionner le point de départ du robot sur le point le plus éloigné du mur en face possible.
Un problème de notre algorithme est que le robot peut rester coincé dans certaines configurations, cela aurait été évitable mais par manque de temps, nous ne pourrons pas palier à ce problème.

==Pseudo code estimé==
Voici une version de base du code de contrôle du robot, ce code a changé car nous n'effectuons plus d'interruptions. La prise de mesure des capteurs ultrasons est relevée dans la loop. On teste avant d'avancer s'il n'y a pas d'obstacle.
<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors, elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin, on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes donc nous n'avons pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs :
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

 

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors :
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises.

 

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.
 
== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple : la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Contraintes liés au capteur d'humidité du sol =
Le capteur d'humidité du sol comme son nom l’indique, prend une mesure de l’humidité d’un sol. Nous avons donc dû trouver une méthode pour planter la fourche sensoriel du capteur dans le sol à mesurer. Pour ce faire, nous avons imaginé trois méthodes :

* Utilisation d’un vérin
* Utilisation d’une vis sans fin
* utilisation d’un bras

Le vérin semblait être une bonne idée, cependant son coût ainsi que sa consommation d'énergie ne correspondait pas à nos attentes (30€ pour les moins chère et au minimum 12V d’alimentation).

La vis sans fin nous à paru être la meilleure option, elle nécessite uniquement un moteur, une vis et un écrou. Nous avions deux moteurs à disposition, l’un était rapide mais avec peu de couple et l’autre était lent avec plus de couple. Dans l’objectif d’enfoncer notre capteur dans le sol nous avons donc choisi d’utiliser le moteur lent avec du couple. En effet, il faut beaucoup de force pour enfoncer le capteur, de plus, le temps n’est pas une contrainte dans ce cas. Pour relier la vis au moteur, nous avons essayé de souder la vis au moteur : [[Fichier:Capture d’écran 2023-05-11 171145.png]]

Malheureusement, il nous à été trop difficile d'axer parfaitement la vis. De plus la vitesse du moteur (1/4 tour par seconde) ainsi que la forme de la vis on rendu cette méthode obsolète ( 1 minute pour descendre le capteur et 1 minute pour le remonter).

Nous avons finalement choisi la dernière méthode, qui consistait à fixer un bras sur le moteur avec notre capteur au bout. Cette méthode est assez facile à mettre en place cependant elle est également moins efficace pour planter un capteur, car elle développe moins de force. Pour la conception du bras, nous avons utilisé les outils et matériaux disponibles dans l’atelier. Au final voici à quoi ressemble le bras : [[Fichier:Capture d’écran 2023-05-11 171434.png]]

Concernant le moteur utilisé :
Nous avons utilisé un moteur 28BYJ ce moteur pas à pas est composé de 5 entrées, 4 bobinages et une alimentation. Pour le faire tourner, on va donc alimenter chaque bobinage l’un après l’autre, de façon à faire un cycle. On fera par la suite une boucle de descente et une boucle de monté du capteur en laissant un délai en bas pour prendre les mesures.
[[Fichier:Capture d’écran 2023-05-11 170600.png]]

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : ESP32 Thing et Teensy.

- ESP32 Thing : 
Nous avons choisi cette carte, car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5 VDC. Il s'alimente à l'aide d'une batterie de 9.6 V composée de 8 cellules Ni.Mh, la tension maximale est d'environ 10.7 V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2 V, ils consomment chacun à 0.5 A en fonctionnement à vide et jusqu'à 1.3 A en fonctionnement nominal (à un couple de 2 kg.cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9 V -> 3.3 V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni.Mh, qui délivre 9.6 V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
: Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

=Déplacement des robots=

==Robot 1==

===Contrôle des déplacements du robot===
Afin de contrôler les déplacements du robot, nous allons utiliser le code pour une plateforme holonome moteur.
La procédure à suivre pour vérifier et tester le fonctionnement des moteurs et de l'asservissement :

 

#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Tester les moteurs en envoyer les commandes suivantes :
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.
 
On peut tester le code grâce à une console série avec une vitesse de 115 200. On utilise alors le port sérié par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin(115200);</code>).
 
Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient un problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :
 
Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.
 
Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandées et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

 

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.
 
Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la Due utiliser (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

== Robot 2 et 3 ==

La première étape est de contrôler les moteurs avec la Teensy, pour cela, il faut utiliser le code suivant :[[Fichier:teensy_r_esp.zip]]
 
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes :
#La commande ahXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande ahXXX.
#Vous pouvez aussi tester les commandes AT et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

 

 Remarque: L'asservissement des moteurs n'est pas fonctionnel, le robot se déplace bien dans les directions qui ne nécessitent que la rotation de deux roues (ah000, ah120, ah240) mais pour le reste le robot dévie de la trajectoire désirée.

 

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela, vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas, nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes, nous avons donc utilisé Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

==Asservissement des déplacements==

Afin de pouvoir contrôler la distance parcourue par chaque, nous avons essayé de mettre en place un asservissement à l'aide d'une centrale inertielle. Pour cela, on utilise une centrale inertielle 10DOF équipée d'un MPU9250.

Pour avoir des mesures fiables, nous avons réaliser un étalonnage de l'accéléromètre sur ses trois axes. Ensuite, en utilisant une formule de dérivation numérique, on peut calculer la distance parcourue par chaque robot. Pour être sûr que cette méthode soit fiable, il faut avoir la fréquence de rafraichissement du capteur et la fréquence d'interruption, afin d'accorder la fréquence de calcul à notre problème.

On a déterminé les valeurs d'étalonnage suivantes:
Sensibilité: Sx=1.000085
Sy=0.99634
Sz=1.01619
Offset: Offx=0.034625
Offy=0.01245
Offz=0.04328

Cette méthode n'a cependant pas pu être mis en place et tester sur les robots.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.
 
La suite d'instruction permettant de guider les robots jusqu'au point d'intérêt est envoyée dans une seule chaîne de caractère, les ESP32 des robots 2 et 3 auront ensuite pour rôle de lire cette chaine par couple de caractère, chacun indiquant une instruction, celle-ci est ensuite traduite en une commande que la Teensy pourra comprendre. Les instructions envoyées par le robot 1 via la chaîne de caractère seront les suivantes : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.
* ac : Action : Planter/Arroser (selon le robot)

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code utiliser pour le Bluetooth : [Cliquer ici pour télécharger le fichier ] [[Fichier:Bluetooth.zip]]

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz.

 
Il existe deux méthodes de communication avec la bibliothèque ESP-NOW:
#La première est qu'une première carte (initiator) envoie des données à une autre carte (responder) précise via son adresse MAC.
#Le broadcast, cette méthode permet à l'initiator de communiquer avec toutes les responders à portée. Cela ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder.
 
Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. L'ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

Dans notre cas, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports Serial 3 deux fils vers Serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

Ici la carte envoie un message à l'ESP32 qui doit la transmettre à l'autre ESP32, c'était un test. Par la suite, ce message sera modifié en fonction du chemin parcouru par le robot 1.

 

Les ESP32 des robots 2&3 devront ensuite découper le message en instructions (couple de caractères), ces instructions sont ensuite traduites pour être comprises par la Teensy. Exemple: av --> ah000 et ho3, dr --> ah270 et ho3.
 

Voici donc les codes nécessaires pour cette communication:

 

Pour la ESP32 en mode Broadcast : [Cliquer ici pour télécharger le fichier] [[Fichier:Boradcast.ZIP]]

 
POur la ESP32 qui reçoit le message : [Cliquer ici pour télécharger le fichier] [[Fichier:Responder.ZIP]]

 

Comme dit précédemment les robots 2&3 ne sont pas bien asservis et ne peuvent donc pas reproduire le trajet demandé par le robot 1, ici un délai de 500ms a été mis pour chaque instruction (ex: av --> le robot avance tout droit pendant 500ms) tandis que pour le robot 1 chaque commande correspond à une durée de 0.5s. Cependant les robots ne vont pas à la même vitesse, il faudrait donc prendre en compte celles ci pour déterminer la durée de chaque instruction pour les robots 2&3.

=Implémentation des algorithme finaux=
==Implémentation de l'algorithme de déplacement du robot 1==
Le programme principal sera disponible ici :[[Fichier:Prog_principal.zip]]
Afin de simplifier la compréhension et la lisibilité du code, nous utiliserons 2 énumérations permettant de lier un entier à un texte utilisable dans le code.
<pre>
enum directions { AUCUNE,
AVANT,
ARRIERE,
DROITE,
GAUCHE };
enum action { RIEN,
PLANTE,
ARROSE,
LESDEUX };
</pre>
Notre programme est constitué de 3 fonctions principales:
*La '''boucle principale()''' permettant de faire rouler le robot et d'appeler les autres fonctions.
*La fonction '''capture()''' permettant de détecter si la zone doit être plantée, arrosée, ou aucun des deux
*La fonction '''Determine_direction()''' permettant de déterminer la prochaine direction
'''Fonction Capture()'''
<pre>
int capture() {
int act;
float temperature, humidite;
int moisture, uvi;
temperature = temp(); // fonction retournant la température
humidite = hum(); // fonction retournant l'humidité
moisture = mois(); fonction retournant l'humidité du sol
uvi = uv(); fonction retournant l'indice UV
act = RIEN;
// UV INDEX LIMIT : 40
// TEMPERATURE INDEX LIMIT: 25
if (humidite > 50 && moisture < 400) {
act = LESDEUX;
} else {
if (humidite > 50) { act = PLANTE; }
if (moisture < 400) { act = ARROSE; }
}
return act;
}
</pre>
'''Fonction determine_direction()''' 
Cette fonction est appelée toutes les 0.5 secondes et permet d'actualiser la direction du robot en fonction de son environnement.
à chaque incrément, on envoie la direction aux roues avec la fonction Serial2.print() en indiquant dans les parenthèses la direction souhaitée.
<pre>
void determine_direction() {
distance_av = ultrasonic_av.read();
distance_ar = ultrasonic_ar.read();
distance_d = ultrasonic_d.read();
distance_g = ultrasonic_g.read();
switch (direction) {
case AVANT:
if (distance_av > 50) {
Serial.println("Avance ");
Serial2.print("avd");
position_tab[tab_index].direction = AVANT;
y = y + 1;
} else {
depart = true;
direction = GAUCHE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case DROITE:
if (distance_d > 30) {
Serial.println("Droite ");
Serial2.print("dr");
position_tab[tab_index].direction = DROITE;
direction_prec = DROITE;
x = x + 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case GAUCHE:
if (distance_g > 30) {
Serial.println("Gauche ");
Serial2.print("ga");
position_tab[tab_index].direction = GAUCHE;
direction_prec = GAUCHE;
x = x - 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;

case ARRIERE:
if (distance_ar > 30) {
if (pas_arriere < 5) { // On recule sur des incréments de 5
pas_arriere++;
Serial.println("Arriere ");
Serial2.print("ard");
y = y - 1;
position_tab[tab_index].direction = ARRIERE;
} else {
position_tab[tab_index].direction = AUCUNE;

pas_arriere = 0;
if (direction_prec == DROITE) { // Balayer de gauche à droite
direction = GAUCHE;
} else {
direction = DROITE;
}
}
} else {
position_tab[tab_index].direction = AUCUNE;
if (direction_prec == DROITE) {
direction = GAUCHE;
} else {
direction = DROITE;
}
}
break;
default: break;
}
if (position_tab[tab_index].direction != AUCUNE) { j++; }
}
</pre>
'''Boucle principale''' 
Cette fonction est décomposée en 2 parties. Tout d'abord, on détecte si le programme est terminé. Si tel est le cas, on envoie les données aux autres robots en parcourant le tableau position_tab rempli dans les autres fonctions (données de direction et d'action). Sinon, on continue la boucle en déterminant la direction et en capturant tous les 5 incréments de temps
<pre>
void loop() {
if (!fin) {
if (depart && y <= 1) { // Lorsqu'on revient au point de départ, on s'arrête et on envoie les informations
Serial2.println("st");
// Amelioration possible, le faire revenir à x = 0
// ENVOI DES DONNEES
for (int i = 0; i < tab_index; i++) {
switch (position_tab[i].direction) {
case AVANT:
Serial3.print("av");
break;
case DROITE:
Serial3.print("dr");
break;
case GAUCHE:
Serial3.print("ga");
break;
case ARRIERE:
Serial3.print("ar");
break;
default:
break;
}
switch (position_tab[i].action) {
case PLANTE:
Serial3.print("pl");
break;
case ARROSE:
Serial3.print("wa");
break;
case LESDEUX:
Serial3.print("l2");
break;
default:
break;
}
}
fin = true;
} else {
determine_direction();
if (j == 5) { // On effectue une capture tous les 5 incréments
condition = capture();
switch (condition) {
case ARROSE:
Serial.println("On arrose");
position_tab[tab_index].action = ARROSE;
break;
case PLANTE:
Serial.println("On plante");
position_tab[tab_index].action = PLANTE;
break;
case LESDEUX:
Serial.println("Les deux");
position_tab[tab_index].action = LESDEUX;
break;
default:
position_tab[tab_index].action = RIEN;
break;
}
j = 0;
} else {
position_tab[tab_index].action = RIEN;
}
tab_index++;
}
delay(500); // On rafraichit la direction toutes les 0.5 secondes
}
}
</pre>
==Tests de l'algorithme du robot 1==
Plusieurs tests ont été effectués tout au long du projet pour tester nos algorithmes les premiers utilisaient seulement les capteurs à ultrasons mais au fur et à mesure, nous avons réussi a lier l'ensemble des composants, voici quelques vidéos montrant les tests effectués.
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=hlS6NtwyzBk
|alignment=left
|description=test du robot 1 immobile
}}
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=ECn0T1XQ3xc
|alignment=right
|description=test du robot 1 en conditions "réelles"
}}
 
Comme on voit sur la 2ème vidéo, puisque l'une des roues ne fonctionne pas dans un sens, il est impossible pour le robot d'aller à droite, et donc impossible de tester notre robot de façon réelle.

Robots jardiniers

2023-05-22T16:56:05Z

Emilie cnvt : /* Missions des robots jardiniers */

=Missions des robots jardiniers=

 Comment concevoir un robot jardinier capable d’explorer son environnement, d’identifier les emplacements optimaux pour semer des graines et s’occuper des plants ? 

 

On dispose de 3 bases roulantes holonomes sur lesqueless on peut monter une batterie de capteur qu'on appellera par la suite robot 1, 2 et 3. L'environnement de fonctionnement du robot est un terrain plat contenant des obstacles à éviter (type rochers), et des points d'intérêts où il est possible de planter des graines. Les positions de ces éléments ne sont pas connues initialement. Il est donc possible de séparer le fonctionnement du robots en 2 phases successives. Un première phase de découverte de l'environnement puis un phase d'action.

 

On peut alors définir un plan d'action des robots jardiniers à travers les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol

 

On peut finalement reformuler ces actions sous forme d'un cahier des charges plus concis.
 
Robot 1 :
* Explorer un environnement
* Mesurer des paramètres expérimentaux
* Déterminer un environnement propice à l'ensemencement
* Enregistrer et communiquer un chemin

 

Robot 2 et 3 :
* Suivre un chemin
* Arroser / forer le sol

Les solutions techniques mises en place pour répondre à ces attentes seront détaillées par la suite. Il convient de noter que toutes ces fonctions n'ont cependant pas pu être réalisées.

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Également, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.

 

Ces groupes sont les suivants :
* Groupe 1 : Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots) : 6 étudiants
* Groupe 2 : Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1) : 3 étudiants
* Groupe 3 : Robot 3 (robot planteur qui suivra le chemin créé par le robot 1) : 3 étudiants

 

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes ont souvent travaillé ensemble.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.
 

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

 

Étant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continu à droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode, mais en inversant la droite et la gauche.

 

Voici un schéma explicatif de l'algorithme utilisé :
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra, au choix, refaire le même chemin en sens inverse (on retiendra chacun des mouvements), ou s'arrêter lorsque la coordonnée y du robot sera assez proche de celle de départ.
Ce schéma est assez simpliste, mais présente globalement la façon dont notre algorithme fonctionne. Il est également applicable sur certaines formes plus complexes (voir schéma ci-dessous)
[[Fichier:robot_algo_3.png|600px]] 
Pour faciliter la compréhension de l'algorithme, voici un schéma explicatif de ce dernier
[[Fichier:Schéma_stylé.png|1000px]]

 

Cet algorithme est assez simpliste mais sera capable de parcourir la plupart des terrains proposés de manière efficace. Il faudra malgré tout veiller à positionner le point de départ du robot sur le point le plus éloigné du mur en face possible.
Un problème de notre algorithme est que le robot peut rester coincé dans certaines configurations, cela aurait été évitable mais par manque de temps, nous ne pourrons pas palier à ce problème.

==Pseudo code estimé==
Voici une version de base du code de contrôle du robot, ce code a changé car nous n'effectuons plus d'interruptions. La prise de mesure des capteurs ultrasons est relevée dans la loop. On teste avant d'avancer s'il n'y a pas d'obstacle.
<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors, elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin, on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes donc nous n'avons pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs :
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

 

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors :
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises.

 

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.
 
== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple : la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Contraintes liés au capteur d'humidité du sol =
Le capteur d'humidité du sol comme son nom l’indique, prend une mesure de l’humidité d’un sol. Nous avons donc dû trouver une méthode pour planter la fourche sensoriel du capteur dans le sol à mesurer. Pour ce faire, nous avons imaginé trois méthodes :

* Utilisation d’un vérin
* Utilisation d’une visse sans fin
* utilisation d’un bras

Le vérin semblait être une bonne idée, cependant son coût ainsi que sa consommation d'énergie ne correspondait pas à nos attentes (30€ pour les moins chère et au minimum 12V d’alimentation).

La visse sans fin nous à paru être la meilleure option, elle nécessite uniquement un moteur, une visse et un écrou. Nous avions deux moteurs à disposition, l’un était rapide mais avec peu de couple et l’autre était lent avec plus de couple. Dans l’objectif d’enfoncer notre capteur dans le sol nous avons donc choisi d’utiliser le moteur lent avec du couple. En effet, il faut beaucoup de force pour enfoncer le capteur, de plus, le temps n’est pas une contrainte dans ce cas. Pour relier la visse au moteur, nous avons essayé de souder la visse au moteur : [[Fichier:Capture d’écran 2023-05-11 171145.png]]

Malheureusement, il nous à été trop difficile d'axer parfaitement la visse. De plus la vitesse du moteur (1/4 tour par seconde) ainsi que la forme de la visse on rendu cette méthode obsolète ( 1 minute pour descendre le capteur et 1 minute pour le remonter).

Nous avons finalement choisi la dernière méthode, qui consistait à fixer un bras sur le moteur avec notre capteur au bout. Cette méthode est assez facile à mettre en place cependant elle est également moins efficace pour planter un capteur, car elle développe moins de force. Pour la conception du bras, nous avons utilisé les outils et matériaux disponibles dans l’atelier. Au final voici à quoi ressemble le bras : [[Fichier:Capture d’écran 2023-05-11 171434.png]]

Concernant le moteur utilisé :
Nous avons utilisé un moteur 28BYJ ce moteur pas à pas est composé de 5 entrées, 4 bobinages et une alimentation. Pour le faire tourner, on va donc alimenter chaque bobinage l’un après l’autre, de façon à faire un cycle. On fera par la suite une boucle de descente et une boucle de monté du capteur en laissant un délai en bas pour prendre les mesures.
[[Fichier:Capture d’écran 2023-05-11 170600.png]]

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : ESP32 Thing et Teensy.

- ESP32 Thing : 
Nous avons choisi cette carte, car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5 VDC. Il s'alimente à l'aide d'une batterie de 9.6 V composée de 8 cellules Ni.Mh, la tension maximale est d'environ 10.7 V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2 V, ils consomment chacun à 0.5 A en fonctionnement à vide et jusqu'à 1.3 A en fonctionnement nominal (à un couple de 2 kg.cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9 V -> 3.3 V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni.Mh, qui délivre 9.6 V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
: Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

=Déplacement des robots=

==Robot 1==

===Contrôle des déplacements du robot===
Afin de contrôler les déplacements du robot, nous allons utiliser le code pour une plateforme holonome moteur.
La procédure à suivre pour vérifier et tester le fonctionnement des moteurs et de l'asservissement :

 

#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Tester les moteurs en envoyer les commandes suivantes :
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.
 
On peut tester le code grâce à une console série avec une vitesse de 115 200. On utilise alors le port sérié par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin(115200);</code>).
 
Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient un problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :
 
Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.
 
Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandées et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

 

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.
 
Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la Due utiliser (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

== Robot 2 et 3 ==

La première étape est de contrôler les moteurs avec la Teensy, pour cela, il faut utiliser le code suivant :[[Fichier:teensy_r_esp.zip]]
 
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes :
#La commande ahXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande ahXXX.
#Vous pouvez aussi tester les commandes AT et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

 

 Remarque: L'asservissement des moteurs n'est pas fonctionnel, le robot se déplace bien dans les directions qui ne nécessitent que la rotation de deux roues (ah000, ah120, ah240) mais pour le reste le robot dévie de la trajectoire désirée.

 

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela, vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas, nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes, nous avons donc utilisé Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

==Asservissement des déplacements==

Afin de pouvoir contrôler la distance parcourue par chaque, nous avons essayé de mettre en place un asservissement à l'aide d'une centrale inertielle. Pour cela, on utilise une centrale inertielle 10DOF équipée d'un MPU9250.

Pour avoir des mesures fiables, nous avons réaliser un étalonnage de l'accéléromètre sur ses trois axes. Ensuite, en utilisant une formule de dérivation numérique, on peut calculer la distance parcourue par chaque robot. Pour être sûr que cette méthode soit fiable, il faut avoir la fréquence de rafraichissement du capteur et la fréquence d'interruption, afin d'accorder la fréquence de calcul à notre problème.

On a déterminé les valeurs d'étalonnage suivantes:
Sensibilité: Sx=1.000085
Sy=0.99634
Sz=1.01619
Offset: Offx=0.034625
Offy=0.01245
Offz=0.04328

Cette méthode n'a cependant pas pu être mis en place et tester sur les robots.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.
 
La suite d'instruction permettant de guider les robots jusqu'au point d'intérêt est envoyée dans une seule chaîne de caractère, les ESP32 des robots 2 et 3 auront ensuite pour rôle de lire cette chaine par couple de caractère, chacun indiquant une instruction, celle-ci est ensuite traduite en une commande que la Teensy pourra comprendre. Les instructions envoyées par le robot 1 via la chaîne de caractère seront les suivantes : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.
* ac : Action : Planter/Arroser (selon le robot)

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code utiliser pour le Bluetooth : [Cliquer ici pour télécharger le fichier ] [[Fichier:Bluetooth.zip]]

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz.

 
Il existe deux méthodes de communication avec la bibliothèque ESP-NOW:
#La première est qu'une première carte (initiator) envoie des données à une autre carte (responder) précise via son adresse MAC.
#Le broadcast, cette méthode permet à l'initiator de communiquer avec toutes les responders à portée. Cela ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder.
 
Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. L'ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

Dans notre cas, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports Serial 3 deux fils vers Serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

Ici la carte envoie un message à l'ESP32 qui doit la transmettre à l'autre ESP32, c'était un test. Par la suite, ce message sera modifié en fonction du chemin parcouru par le robot 1.

 

Les ESP32 des robots 2&3 devront ensuite découper le message en instructions (couple de caractères), ces instructions sont ensuite traduites pour être comprises par la Teensy. Exemple: av --> ah000 et ho3, dr --> ah270 et ho3.
 

Voici donc les codes nécessaires pour cette communication:

 

Pour la ESP32 en mode Broadcast : [Cliquer ici pour télécharger le fichier] [[Fichier:Boradcast.ZIP]]

 
POur la ESP32 qui reçoit le message : [Cliquer ici pour télécharger le fichier] [[Fichier:Responder.ZIP]]

 

Comme dit précédemment les robots 2&3 ne sont pas bien asservis et ne peuvent donc pas reproduire le trajet demandé par le robot 1, ici un délai de 500ms a été mis pour chaque instruction (ex: av --> le robot avance tout droit pendant 500ms) tandis que pour le robot 1 chaque commande correspond à une durée de 0.5s. Cependant les robots ne vont pas à la même vitesse, il faudrait donc prendre en compte celles ci pour déterminer la durée de chaque instruction pour les robots 2&3.

=Implémentation des algorithme finaux=
==Implémentation de l'algorithme de déplacement du robot 1==
Le programme principal sera disponible ici :[[Fichier:Prog_principal.zip]]
Afin de simplifier la compréhension et la lisibilité du code, nous utiliserons 2 énumérations permettant de lier un entier à un texte utilisable dans le code.
<pre>
enum directions { AUCUNE,
AVANT,
ARRIERE,
DROITE,
GAUCHE };
enum action { RIEN,
PLANTE,
ARROSE,
LESDEUX };
</pre>
Notre programme est constitué de 3 fonctions principales:
*La '''boucle principale()''' permettant de faire rouler le robot et d'appeler les autres fonctions.
*La fonction '''capture()''' permettant de détecter si la zone doit être plantée, arrosée, ou aucun des deux
*La fonction '''Determine_direction()''' permettant de déterminer la prochaine direction
'''Fonction Capture()'''
<pre>
int capture() {
int act;
float temperature, humidite;
int moisture, uvi;
temperature = temp(); // fonction retournant la température
humidite = hum(); // fonction retournant l'humidité
moisture = mois(); fonction retournant l'humidité du sol
uvi = uv(); fonction retournant l'indice UV
act = RIEN;
// UV INDEX LIMIT : 40
// TEMPERATURE INDEX LIMIT: 25
if (humidite > 50 && moisture < 400) {
act = LESDEUX;
} else {
if (humidite > 50) { act = PLANTE; }
if (moisture < 400) { act = ARROSE; }
}
return act;
}
</pre>
'''Fonction determine_direction()''' 
Cette fonction est appelée toutes les 0.5 secondes et permet d'actualiser la direction du robot en fonction de son environnement.
à chaque incrément, on envoie la direction aux roues avec la fonction Serial2.print() en indiquant dans les parenthèses la direction souhaitée.
<pre>
void determine_direction() {
distance_av = ultrasonic_av.read();
distance_ar = ultrasonic_ar.read();
distance_d = ultrasonic_d.read();
distance_g = ultrasonic_g.read();
switch (direction) {
case AVANT:
if (distance_av > 50) {
Serial.println("Avance ");
Serial2.print("avd");
position_tab[tab_index].direction = AVANT;
y = y + 1;
} else {
depart = true;
direction = GAUCHE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case DROITE:
if (distance_d > 30) {
Serial.println("Droite ");
Serial2.print("dr");
position_tab[tab_index].direction = DROITE;
direction_prec = DROITE;
x = x + 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case GAUCHE:
if (distance_g > 30) {
Serial.println("Gauche ");
Serial2.print("ga");
position_tab[tab_index].direction = GAUCHE;
direction_prec = GAUCHE;
x = x - 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;

case ARRIERE:
if (distance_ar > 30) {
if (pas_arriere < 5) { // On recule sur des incréments de 5
pas_arriere++;
Serial.println("Arriere ");
Serial2.print("ard");
y = y - 1;
position_tab[tab_index].direction = ARRIERE;
} else {
position_tab[tab_index].direction = AUCUNE;

pas_arriere = 0;
if (direction_prec == DROITE) { // Balayer de gauche à droite
direction = GAUCHE;
} else {
direction = DROITE;
}
}
} else {
position_tab[tab_index].direction = AUCUNE;
if (direction_prec == DROITE) {
direction = GAUCHE;
} else {
direction = DROITE;
}
}
break;
default: break;
}
if (position_tab[tab_index].direction != AUCUNE) { j++; }
}
</pre>
'''Boucle principale''' 
Cette fonction est décomposée en 2 parties. Tout d'abord, on détecte si le programme est terminé. Si tel est le cas, on envoie les données aux autres robots en parcourant le tableau position_tab rempli dans les autres fonctions (données de direction et d'action). Sinon, on continue la boucle en déterminant la direction et en capturant tous les 5 incréments de temps
<pre>
void loop() {
if (!fin) {
if (depart && y <= 1) { // Lorsqu'on revient au point de départ, on s'arrête et on envoie les informations
Serial2.println("st");
// Amelioration possible, le faire revenir à x = 0
// ENVOI DES DONNEES
for (int i = 0; i < tab_index; i++) {
switch (position_tab[i].direction) {
case AVANT:
Serial3.print("av");
break;
case DROITE:
Serial3.print("dr");
break;
case GAUCHE:
Serial3.print("ga");
break;
case ARRIERE:
Serial3.print("ar");
break;
default:
break;
}
switch (position_tab[i].action) {
case PLANTE:
Serial3.print("pl");
break;
case ARROSE:
Serial3.print("wa");
break;
case LESDEUX:
Serial3.print("l2");
break;
default:
break;
}
}
fin = true;
} else {
determine_direction();
if (j == 5) { // On effectue une capture tous les 5 incréments
condition = capture();
switch (condition) {
case ARROSE:
Serial.println("On arrose");
position_tab[tab_index].action = ARROSE;
break;
case PLANTE:
Serial.println("On plante");
position_tab[tab_index].action = PLANTE;
break;
case LESDEUX:
Serial.println("Les deux");
position_tab[tab_index].action = LESDEUX;
break;
default:
position_tab[tab_index].action = RIEN;
break;
}
j = 0;
} else {
position_tab[tab_index].action = RIEN;
}
tab_index++;
}
delay(500); // On rafraichit la direction toutes les 0.5 secondes
}
}
</pre>
==Tests de l'algorithme du robot 1==
Plusieurs tests ont été effectués tout au long du projet pour tester nos algorithmes les premiers utilisaient seulement les capteurs à ultrasons mais au fur et à mesure, nous avons réussi a lier l'ensemble des composants, voici quelques vidéos montrant les tests effectués.
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=hlS6NtwyzBk
|alignment=left
|description=test du robot 1 immobile
}}
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=ECn0T1XQ3xc
|alignment=right
|description=test du robot 1 en conditions "réelles"
}}
 
Comme on voit sur la 2ème vidéo, puisque l'une des roues ne fonctionne pas dans un sens, il est impossible pour le robot d'aller à droite, et donc impossible de tester notre robot de façon réelle.

Robots jardiniers

2023-05-12T08:20:05Z

Emilie cnvt : /* Robot 1 */

=Missions des robots jardiniers=

 Comment concevoir un robot jardinier capable d’explorer son environnement, d’identifier les emplacements optimaux pour semer des graines et s’occuper des plants ? 

 

On dispose de 3 bases roulantes holonomes sur lesquels on peut monter une batterie de capteur qu'on appellera par la suite robot 1, 2 et 3. L'environnement de fonctionnement du robot est un terrain plat contenant des obstacles à éviter (type rochers), et des points d'intérêts où il est possible de planter des graines. Les positions de ces éléments ne sont pas connues initialement. Il est donc possible de séparer le fonctionnement du robots en 2 phases successives. Un première phase de découverte de l'environnement puis un phase d'action.

 

On peut alors définir un plan d'action des robots jardiniers à travers les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol

 

On peut finalement reformuler ces actions sous forme d'un cahier des charges plus concis.
 
Robot 1 :
* Explorer un environnement
* Mesurer des paramètres expérimentaux
* Déterminer un environnement propice à l'ensemencement
* Enregistrer et communiquer un chemin

 

Robot 2 et 3 :
* Suivre un chemin
* Arroser / forer le sol

Les solutions techniques mises en place pour répondre à ces attentes seront détaillées par la suite. Il convient de noter que toutes ces fonctions n'ont cependant pas pu être réalisées.

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Également, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.

 

Ces groupes sont les suivants :
* Groupe 1 : Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots) : 6 étudiants
* Groupe 2 : Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1) : 3 étudiants
* Groupe 3 : Robot 3 (robot planteur qui suivra le chemin créé par le robot 1) : 3 étudiants

 

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes ont souvent travaillé ensemble.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.
 

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

 

Étant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continu à droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode, mais en inversant la droite et la gauche.

 

Voici un schéma explicatif de l'algorithme utilisé :
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra, au choix, refaire le même chemin en sens inverse (on retiendra chacun des mouvements), ou s'arrêter lorsque la coordonnée y du robot sera assez proche de celle de départ.
Ce schéma est assez simpliste, mais présente globalement la façon dont notre algorithme fonctionne. Il est également applicable sur certaines formes plus complexes (voir schéma ci-dessous)
[[Fichier:robot_algo_3.png|600px]] 
Pour faciliter la compréhension de l'algorithme, voici un schéma explicatif de ce dernier
[[Fichier:Schéma_stylé.png|1000px]]

 

Cet algorithme est assez simpliste mais sera capable de parcourir la plupart des terrains proposés de manière efficace. Il faudra malgré tout veiller à positionner le point de départ du robot sur le point le plus éloigné du mur en face possible.
Un problème de notre algorithme est que le robot peut rester coincé dans certaines configurations, cela aurait été évitable mais par manque de temps, nous ne pourrons pas palier à ce problème.

==Pseudo code estimé==
Voici une version de base du code de contrôle du robot, ce code a changé car nous n'effectuons plus d'interruptions. La prise de mesure des capteurs ultrasons est relevée dans la loop. On teste avant d'avancer s'il n'y a pas d'obstacle.
<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors, elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin, on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes donc nous n'avons pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs :
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

 

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors :
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises.

 

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.
 
== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple : la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Contraintes liés au capteur d'humidité du sol =
Le capteur d'humidité du sol comme son nom l’indique, prend une mesure de l’humidité d’un sol. Nous avons donc dû trouver une méthode pour planter la fourche sensoriel du capteur dans le sol à mesurer. Pour ce faire, nous avons imaginé trois méthodes :

* Utilisation d’un vérin
* Utilisation d’une visse sans fin
* utilisation d’un bras

Le vérin semblait être une bonne idée, cependant son coût ainsi que sa consommation d'énergie ne correspondait pas à nos attentes (30€ pour les moins chère et au minimum 12V d’alimentation).

La visse sans fin nous à paru être la meilleure option, elle nécessite uniquement un moteur, une visse et un écrou. Nous avions deux moteurs à disposition, l’un était rapide mais avec peu de couple et l’autre était lent avec plus de couple. Dans l’objectif d’enfoncer notre capteur dans le sol nous avons donc choisi d’utiliser le moteur lent avec du couple. En effet, il faut beaucoup de force pour enfoncer le capteur, de plus, le temps n’est pas une contrainte dans ce cas. Pour relier la visse au moteur, nous avons essayé de souder la visse au moteur : [[Fichier:Capture d’écran 2023-05-11 171145.png]]

Malheureusement, il nous à été trop difficile d'axer parfaitement la visse. De plus la vitesse du moteur (1/4 tour par seconde) ainsi que la forme de la visse on rendu cette méthode obsolète ( 1 minute pour descendre le capteur et 1 minute pour le remonter).

Nous avons finalement choisi la dernière méthode, qui consistait à fixer un bras sur le moteur avec notre capteur au bout. Cette méthode est assez facile à mettre en place cependant elle est également moins efficace pour planter un capteur, car elle développe moins de force. Pour la conception du bras, nous avons utilisé les outils et matériaux disponibles dans l’atelier. Au final voici à quoi ressemble le bras : [[Fichier:Capture d’écran 2023-05-11 171434.png]]

Concernant le moteur utilisé :
Nous avons utilisé un moteur 28BYJ ce moteur pas à pas est composé de 5 entrées, 4 bobinages et une alimentation. Pour le faire tourner, on va donc alimenter chaque bobinage l’un après l’autre, de façon à faire un cycle. On fera par la suite une boucle de descente et une boucle de monté du capteur en laissant un délai en bas pour prendre les mesures.
[[Fichier:Capture d’écran 2023-05-11 170600.png]]

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : ESP32 Thing et Teensy.

- ESP32 Thing : 
Nous avons choisi cette carte, car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5 VDC. Il s'alimente à l'aide d'une batterie de 9.6 V composée de 8 cellules Ni.Mh, la tension maximale est d'environ 10.7 V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2 V, ils consomment chacun à 0.5 A en fonctionnement à vide et jusqu'à 1.3 A en fonctionnement nominal (à un couple de 2 kg.cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9 V -> 3.3 V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni.Mh, qui délivre 9.6 V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
: Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

=Déplacement des robots=

==Robot 1==

===Contrôle des déplacements du robot===
Afin de contrôler les déplacements du robot, nous allons utiliser le code pour une plateforme holonome moteur.
La procédure à suivre pour vérifier et tester le fonctionnement des moteurs et de l'asservissement :

 

#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Tester les moteurs en envoyer les commandes suivantes :
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.
 
On peut tester le code grâce à une console série avec une vitesse de 115 200. On utilise alors le port sérié par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin(115200);</code>).
 
Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient un problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :
 
Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.
 
Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandées et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

 

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.
 
Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la Due utiliser (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

== Robot 2 et 3 ==

La première étape est de contrôler les moteurs avec la Teensy, pour cela, il faut utiliser le code suivant :[[Fichier:teensy_r_esp.zip]]
 
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes :
#La commande ahXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande ahXXX.
#Vous pouvez aussi tester les commandes AT et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

 

 Remarque: L'asservissement des moteurs n'est pas fonctionnel, le robot se déplace bien dans les directions qui ne nécessitent que la rotation de deux roues (ah000, ah120, ah240) mais pour le reste le robot dévie de la trajectoire désirée.

 

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela, vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas, nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes, nous avons donc utilisé Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

==Asservissement des déplacements==

Afin de pouvoir contrôler la distance parcourue par chaque, nous avons essayé de mettre en place un asservissement à l'aide d'une centrale inertielle. Pour cela, on utilise une centrale inertielle 10DOF équipée d'un MPU9250.

Pour avoir des mesures fiables, nous avons réaliser un étalonnage de l'accéléromètre sur ses trois axes. Ensuite, en utilisant une formule de dérivation numérique, on peut calculer la distance parcourue par chaque robot. Pour être sûr que cette méthode soit fiable, il faut avoir la fréquence de rafraichissement du capteur et la fréquence d'interruption, afin d'accorder la fréquence de calcul à notre problème.

Cette méthode n'a cependant pas pu être mis en place et tester sur les robots.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.
 
La suite d'instruction permettant de guider les robots jusqu'au point d'intérêt est envoyée dans une seule chaîne de caractère, les ESP32 des robots 2 et 3 auront ensuite pour rôle de lire cette chaine par couple de caractère, chacun indiquant une instruction, celle-ci est ensuite traduite en une commande que la Teensy pourra comprendre. Les instructions envoyées par le robot 1 via la chaîne de caractère seront les suivantes : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.
* ac : Action : Planter/Arroser (selon le robot)

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code utiliser pour le Bluetooth : [Cliquer ici pour télécharger le fichier ] [[Fichier:Bluetooth.zip]]

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz.

 
Il existe deux méthodes de communication avec la bibliothèque ESP-NOW:
#La première est qu'une première carte (initiator) envoie des données à une autre carte (responder) précise via son adresse MAC.
#Le broadcast, cette méthode permet à l'initiator de communiquer avec toutes les responders à portée. Cela ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder.
 
Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. L'ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

Dans notre cas, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports Serial 3 deux fils vers Serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

Ici la carte envoie un message à l'ESP32 qui doit la transmettre à l'autre ESP32, c'était un test. Par la suite, ce message sera modifié en fonction du chemin parcouru par le robot 1.

 

Les ESP32 des robots 2&3 devront ensuite découper le message en instructions (couple de caractères), ces instructions sont ensuite traduites pour être comprises par la Teensy. Exemple: av --> ah000 et ho3, dr --> ah270 et ho3.
 

Voici donc les codes nécessaires pour cette communication:

 

Pour la ESP32 en mode Broadcast : [Cliquer ici pour télécharger le fichier] [[Fichier:Boradcast.ZIP]]

 
POur la ESP32 qui reçoit le message : [Cliquer ici pour télécharger le fichier] [[Fichier:Responder.ZIP]]

 

Comme dit précédemment les robots 2&3 ne sont pas bien asservis et ne peuvent donc pas reproduire le trajet demandé par le robot 1, ici un délai de 500ms a été mis pour chaque instruction (ex: av --> le robot avance tout droit pendant 500ms) tandis que pour le robot 1 chaque commande correspond à une durée de 0.5s. Cependant les robots ne vont pas à la même vitesse, il faudrait donc prendre en compte celles ci pour déterminer la durée de chaque instruction pour les robots 2&3.

=Implémentation des algorithme finaux=
==Implémentation de l'algorithme de déplacement du robot 1==
Le programme principal sera disponible ici :[[Fichier:Prog_principal.zip]]
Afin de simplifier la compréhension et la lisibilité du code, nous utiliserons 2 énumérations permettant de lier un entier à un texte utilisable dans le code.
<pre>
enum directions { AUCUNE,
AVANT,
ARRIERE,
DROITE,
GAUCHE };
enum action { RIEN,
PLANTE,
ARROSE,
LESDEUX };
</pre>
Notre programme est constitué de 3 fonctions principales:
*La '''boucle principale()''' permettant de faire rouler le robot et d'appeler les autres fonctions.
*La fonction '''capture()''' permettant de détecter si la zone doit être plantée, arrosée, ou aucun des deux
*La fonction '''Determine_direction()''' permettant de déterminer la prochaine direction
'''Fonction Capture()'''
<pre>
int capture() {
int act;
float temperature, humidite;
int moisture, uvi;
temperature = temp(); // fonction retournant la température
humidite = hum(); // fonction retournant l'humidité
moisture = mois(); fonction retournant l'humidité du sol
uvi = uv(); fonction retournant l'indice UV
act = RIEN;
// UV INDEX LIMIT : 40
// TEMPERATURE INDEX LIMIT: 25
if (humidite > 50 && moisture < 400) {
act = LESDEUX;
} else {
if (humidite > 50) { act = PLANTE; }
if (moisture < 400) { act = ARROSE; }
}
return act;
}
</pre>
'''Fonction determine_direction()''' 
Cette fonction est appelée toutes les 0.5 secondes et permet d'actualiser la direction du robot en fonction de son environnement.
à chaque incrément, on envoie la direction aux roues avec la fonction Serial2.print() en indiquant dans les parenthèses la direction souhaitée.
<pre>
void determine_direction() {
distance_av = ultrasonic_av.read();
distance_ar = ultrasonic_ar.read();
distance_d = ultrasonic_d.read();
distance_g = ultrasonic_g.read();
switch (direction) {
case AVANT:
if (distance_av > 50) {
Serial.println("Avance ");
Serial2.print("avd");
position_tab[tab_index].direction = AVANT;
y = y + 1;
} else {
depart = true;
direction = GAUCHE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case DROITE:
if (distance_d > 30) {
Serial.println("Droite ");
Serial2.print("dr");
position_tab[tab_index].direction = DROITE;
direction_prec = DROITE;
x = x + 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case GAUCHE:
if (distance_g > 30) {
Serial.println("Gauche ");
Serial2.print("ga");
position_tab[tab_index].direction = GAUCHE;
direction_prec = GAUCHE;
x = x - 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;

case ARRIERE:
if (distance_ar > 30) {
if (pas_arriere < 5) { // On recule sur des incréments de 5
pas_arriere++;
Serial.println("Arriere ");
Serial2.print("ard");
y = y - 1;
position_tab[tab_index].direction = ARRIERE;
} else {
position_tab[tab_index].direction = AUCUNE;

pas_arriere = 0;
if (direction_prec == DROITE) { // Balayer de gauche à droite
direction = GAUCHE;
} else {
direction = DROITE;
}
}
} else {
position_tab[tab_index].direction = AUCUNE;
if (direction_prec == DROITE) {
direction = GAUCHE;
} else {
direction = DROITE;
}
}
break;
default: break;
}
if (position_tab[tab_index].direction != AUCUNE) { j++; }
}
</pre>
'''Boucle principale''' 
Cette fonction est décomposée en 2 parties. Tout d'abord, on détecte si le programme est terminé. Si tel est le cas, on envoie les données aux autres robots en parcourant le tableau position_tab rempli dans les autres fonctions (données de direction et d'action). Sinon, on continue la boucle en déterminant la direction et en capturant tous les 5 incréments de temps
<pre>
void loop() {
if (!fin) {
if (depart && y <= 1) { // Lorsqu'on revient au point de départ, on s'arrête et on envoie les informations
Serial2.println("st");
// Amelioration possible, le faire revenir à x = 0
// ENVOI DES DONNEES
for (int i = 0; i < tab_index; i++) {
switch (position_tab[i].direction) {
case AVANT:
Serial3.print("av");
break;
case DROITE:
Serial3.print("dr");
break;
case GAUCHE:
Serial3.print("ga");
break;
case ARRIERE:
Serial3.print("ar");
break;
default:
break;
}
switch (position_tab[i].action) {
case PLANTE:
Serial3.print("pl");
break;
case ARROSE:
Serial3.print("wa");
break;
case LESDEUX:
Serial3.print("l2");
break;
default:
break;
}
}
fin = true;
} else {
determine_direction();
if (j == 5) { // On effectue une capture tous les 5 incréments
condition = capture();
switch (condition) {
case ARROSE:
Serial.println("On arrose");
position_tab[tab_index].action = ARROSE;
break;
case PLANTE:
Serial.println("On plante");
position_tab[tab_index].action = PLANTE;
break;
case LESDEUX:
Serial.println("Les deux");
position_tab[tab_index].action = LESDEUX;
break;
default:
position_tab[tab_index].action = RIEN;
break;
}
j = 0;
} else {
position_tab[tab_index].action = RIEN;
}
tab_index++;
}
delay(500); // On rafraichit la direction toutes les 0.5 secondes
}
}
</pre>
==Tests de l'algorithme du robot 1==
Plusieurs tests ont été effectués tout au long du projet pour tester nos algorithmes les premiers utilisaient seulement les capteurs à ultrasons mais au fur et à mesure, nous avons réussi a lier l'ensemble des composants, voici quelques vidéos montrant les tests effectués.
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=hlS6NtwyzBk
|alignment=left
|description=test du robot 1 immobile
}}
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=ECn0T1XQ3xc
|alignment=right
|description=test du robot 1 en conditions "réelles"
}}
 
Comme on voit sur la 2ème vidéo, puisque l'une des roues ne fonctionne pas dans un sens, il est impossible pour le robot d'aller à droite, et donc impossible de tester notre robot de façon réelle.

Robots jardiniers

2023-05-11T12:22:03Z

Emilie cnvt : /* Pseudo code estimé */

=Missions des robots jardiniers=

 Comment concevoir un robot jardinier capable d’explorer son environnement, d’identifier les emplacements optimaux pour semer des graines et s’occuper des plants ? 

 

On dispose de 3 bases roulantes holonomes sur lesquels on peut monter une batterie de capteur qu'on appellera par la suite robot 1, 2 et 3. L'environnement de fonctionnement du robot est un terrain plat contenant des obstacles à éviter (type rochers), et des points d'intérêts où il est possible de planter des graines. Les positions de ces éléments ne sont pas connues initialement. Il est donc possible de séparer le fonctionnement du robots en 2 phases successives. Un première phase de découverte de l'environnement puis un phase d'action.

 

On peut alors définir un plan d'action des robots jardiniers à travers les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol

 

On peut finalement reformuler ces actions sous forme d'un cahier des charges plus concis.
 
Robot 1 :
* Explorer un environnement
* Mesurer des paramètres expérimentaux
* Déterminer un environnement propice à l'ensemencement
* Enregistrer et communiquer un chemin

 

Robot 2 et 3 :
* Suivre un chemin
* Arroser / forer le sol

Les solutions techniques mises en place pour répondre à ces attentes seront détaillées par la suite. Il convient de noter que toutes ces fonctions n'ont cependant pas pu être réalisées.

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Également, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.

 

Ces groupes sont les suivants :
* Groupe 1 : Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots) : 6 étudiants
* Groupe 2 : Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1) : 3 étudiants
* Groupe 3 : Robot 3 (robot planteur qui suivra le chemin créé par le robot 1) : 3 étudiants

 

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes ont souvent travaillé ensemble.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.
 

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

 

Étant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continu à droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode, mais en inversant la droite et la gauche.

 

Voici un schéma explicatif de l'algorithme utilisé :
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra, au choix, refaire le même chemin en sens inverse (on retiendra chacun des mouvements), ou s'arrêter lorsque la coordonnée y du robot sera assez proche de celle de départ.
Ce schéma est assez simpliste, mais présente globalement la façon dont notre algorithme fonctionne. Il est également applicable sur certaines formes plus complexes (voir schéma ci-dessous)
[[Fichier:robot_algo_3.png|600px]] 
Pour faciliter la compréhension de l'algorithme, voici un schéma explicatif de ce dernier
[[Fichier:Schéma_stylé.png|1000px]]

 

Cet algorithme est assez simpliste mais sera capable de parcourir la plupart des terrains proposés de manière efficace. Il faudra malgré tout veiller à positionner le point de départ du robot sur le point le plus éloigné du mur en face possible.
Un problème de notre algorithme est que le robot peut rester coincé dans certaines configurations, cela aurait été évitable mais par manque de temps, nous ne pourrons pas palier à ce problème.

==Pseudo code estimé==
Voici une version de base du code de contrôle du robot, ce code a changé car nous n'effectuons plus d'interruptions. La prise de mesure des capteurs ultrasons est relevée dans la loop. On teste avant d'avancer s'il n'y a pas d'obstacle.
<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors, elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin, on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes donc nous n'avons pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs :
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

 

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors :
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises.

 

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.
 
== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple : la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Contraintes liés au capteur d'humidité du sol =
Le capteur d'humidité du sol comme son nom l’indique, prend une mesure de l’humidité d’un sol. Nous avons donc dû trouver une méthode pour planter la fourche sensoriel du capteur dans le sol à mesurer. Pour ce faire, nous avons imaginé trois méthodes :

* Utilisation d’un vérin
* Utilisation d’une visse sans fin
* utilisation d’un bras

Le vérin semblait être une bonne idée, cependant son coût ainsi que sa consommation d'énergie ne correspondait pas à nos attentes (30€ pour les moins chère et au minimum 12V d’alimentation).

La visse sans fin nous à paru être la meilleure option, elle nécessite uniquement un moteur, une visse et un écrou. Nous avions deux moteurs à disposition, l’un était rapide mais avec peu de couple et l’autre était lent avec plus de couple. Dans l’objectif d’enfoncer notre capteur dans le sol nous avons donc choisi d’utiliser le moteur lent avec du couple. En effet, il faut beaucoup de force pour enfoncer le capteur, de plus, le temps n’est pas une contrainte dans ce cas. Pour relier la visse au moteur, nous avons essayé de souder la visse au moteur :

Malheureusement, il nous à été trop difficile d'axer parfaitement la visse. De plus la vitesse du moteur (1/4 tour par seconde) ainsi que la forme de la visse on rendu cette méthode obsolète ( 1 minute pour descendre le capteur et 1 minute pour le remonter).

Nous avons finalement choisi la dernière méthode, qui consistait à fixer un bras sur le moteur avec notre capteur au bout. Cette méthode est assez facile à mettre en place cependant elle est également moins efficace pour planter un capteur, car elle développe moins de force. Pour la conception du bras, nous avons utilisé les outils et matériaux disponibles dans l’atelier. Au final voici à quoi ressemble le bras :

Concernant le moteur utilisé :
Nous avons utilisé un moteur 28BYJ ce moteur pas à pas est composé de 5 entrées, 4 bobinages et une alimentation. Pour le faire tourner, on va donc alimenter chaque bobinage l’un après l’autre, de façon à faire un cycle. On va donc faire une boucle de descente et une boucle de monté du capteur en laissant un délai en bas pour prendre les mesures.

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : ESP32 Thing et Teensy.

- ESP32 Thing : 
Nous avons choisi cette carte, car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5 VDC. Il s'alimente à l'aide d'une batterie de 9.6 V composée de 8 cellules Ni.Mh, la tension maximale est d'environ 10.7 V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2 V, ils consomment chacun à 0.5 A en fonctionnement à vide et jusqu'à 1.3 A en fonctionnement nominal (à un couple de 2 kg.cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9 V -> 3.3 V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni.Mh, qui délivre 9.6 V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
: Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino, car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due parce que la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.

 

 Teensy : 

Nous avons choisi la Teensy comme carte motrice, car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 
 
Les deux cartes sont connectées par une liaison série pour communiquer.

=Déplacement des robots=

==Robot 1==

===Contrôle des déplacements du robot===
Afin de contrôler les déplacements du robot, nous allons utiliser le code pour une plateforme holonome moteur.
La procédure à suivre pour vérifier et tester le fonctionnement des moteurs et de l'asservissement :

 

#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Tester les moteurs en envoyer les commandes suivantes :
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.
 
On peut tester le code grâce à une console série avec une vitesse de 115 200. On utilise alors le port sérié par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin(115200);</code>).
 
Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient un problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :
 
Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.
 
Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandées et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

 

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.
 
Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la Due utiliser (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

== Robot 2 et 3 ==
La première étape est de contrôler les moteurs avec la Teensy, pour cela, il faut utiliser le code suivant :
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes :
#La commande ahXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande ahXXX.
#Vous pouvez aussi tester les commandes AT et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

 

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela, vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas, nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes, nous avons donc utilisé Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.
 
La suite d'instruction permettant de guider les robots jusqu'au point d'intérêt est envoyée dans une seule chaîne de caractère, les ESP32 des robots 2 et 3 auront ensuite pour rôle de lire cette chaine par couple de caractère, chacun indiquant une instruction, celle-ci est ensuite traduite en une commande que la Teensy pourra comprendre. Les instructions envoyées par le robot 1 via la chaîne de caractère seront les suivantes : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.
* ac : Action : Planter/Arroser (selon le robot)

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code utiliser pour le Bluetooth : [Cliquer ici pour télécharger le fichier ] [[Fichier:Bluetooth.zip]]

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz. Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. L'ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

 
Il existe deux méthodes de communication avec la bibliothèque ESP-NOW:
#La première est qu'une première carte (initiator) envoie des données à une autre carte (responder) précise via son adresse MAC.
#Le broadcast, cette méthode permet à l'initiator de communiquer avec tous es responder à portée, cela ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder.
Dans notre cas, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports Serial 3 deux fils vers Serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

Ici la carte envoie un message à l'ESP32 qui doit la transmettre à l'autre ESP32, c'était un test. Par la suite, ce message sera modifié en fonction du chemin parcouru par le robot 1.

 

Pour la ESP32 en mode Broadcast : [Cliquer ici pour télécharger le fichier] [[Fichier:Boradcast.ZIP]]

 
POur la ESP32 qui reçoit le message : [Cliquer ici pour télécharger le fichier] [[Fichier:Responder.ZIP]]

 

A noté que ici, on découpe le message reçu en chaines de caractères de longueur 2 qui correspondent directement aux ordres à donner au robot pour qu'il avance/recule/tourne.

=Implémentation des algorithme finaux=
==Implémentation de l'algorithme de déplacement du robot 1==
Le programme principal sera disponible ici :[[Fichier:Prog_principal.zip]]
Afin de simplifier la compréhension et la lisibilité du code, nous utiliserons 2 énumérations permettant de lier un entier à un texte utilisable dans le code.
<pre>
enum directions { AUCUNE,
AVANT,
ARRIERE,
DROITE,
GAUCHE };
enum action { RIEN,
PLANTE,
ARROSE,
LESDEUX };
</pre>
Notre programme est constitué de 3 fonctions principales:
*La '''boucle principale()''' permettant de faire rouler le robot et d'appeler les autres fonctions.
*La fonction '''capture()''' permettant de détecter si la zone doit être plantée, arrosée, ou aucun des deux
*La fonction '''Determine_direction()''' permettant de déterminer la prochaine direction
'''Fonction Capture()'''
<pre>
int capture() {
int act;
float temperature, humidite;
int moisture, uvi;
temperature = temp(); // fonction retournant la température
humidite = hum(); // fonction retournant l'humidité
moisture = mois(); fonction retournant l'humidité du sol
uvi = uv(); fonction retournant l'indice UV
act = RIEN;
// UV INDEX LIMIT : 40
// TEMPERATURE INDEX LIMIT: 25
if (humidite > 50 && moisture < 400) {
act = LESDEUX;
} else {
if (humidite > 50) { act = PLANTE; }
if (moisture < 400) { act = ARROSE; }
}
return act;
}
</pre>
'''Fonction determine_direction()''' 
Cette fonction est appelée toutes les 0.5 secondes et permet d'actualiser la direction du robot en fonction de son environnement.
à chaque incrément, on envoie la direction aux roues avec la fonction Serial2.print() en indiquant dans les parenthèses la direction souhaitée.
<pre>
void determine_direction() {
distance_av = ultrasonic_av.read();
distance_ar = ultrasonic_ar.read();
distance_d = ultrasonic_d.read();
distance_g = ultrasonic_g.read();
switch (direction) {
case AVANT:
if (distance_av > 50) {
Serial.println("Avance ");
Serial2.print("avd");
position_tab[tab_index].direction = AVANT;
y = y + 1;
} else {
depart = true;
direction = GAUCHE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case DROITE:
if (distance_d > 30) {
Serial.println("Droite ");
Serial2.print("dr");
position_tab[tab_index].direction = DROITE;
direction_prec = DROITE;
x = x + 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;
case GAUCHE:
if (distance_g > 30) {
Serial.println("Gauche ");
Serial2.print("ga");
position_tab[tab_index].direction = GAUCHE;
direction_prec = GAUCHE;
x = x - 1;
} else {
direction = ARRIERE;
position_tab[tab_index].direction = AUCUNE;
}
break;

case ARRIERE:
if (distance_ar > 30) {
if (pas_arriere < 5) { // On recule sur des incréments de 5
pas_arriere++;
Serial.println("Arriere ");
Serial2.print("ard");
y = y - 1;
position_tab[tab_index].direction = ARRIERE;
} else {
position_tab[tab_index].direction = AUCUNE;

pas_arriere = 0;
if (direction_prec == DROITE) { // Balayer de gauche à droite
direction = GAUCHE;
} else {
direction = DROITE;
}
}
} else {
position_tab[tab_index].direction = AUCUNE;
if (direction_prec == DROITE) {
direction = GAUCHE;
} else {
direction = DROITE;
}
}
break;
default: break;
}
if (position_tab[tab_index].direction != AUCUNE) { j++; }
}
</pre>
'''Boucle principale''' 
Cette fonction est décomposée en 2 parties. Tout d'abord, on détecte si le programme est terminé. Si tel est le cas, on envoie les données aux autres robots en parcourant le tableau position_tab rempli dans les autres fonctions (données de direction et d'action). Sinon, on continue la boucle en déterminant la direction et en capturant tous les 5 incréments de temps
<pre>
void loop() {
if (!fin) {
if (depart && y <= 1) { // Lorsqu'on revient au point de départ, on s'arrête et on envoie les informations
Serial2.println("st");
// Amelioration possible, le faire revenir à x = 0
// ENVOI DES DONNEES
for (int i = 0; i < tab_index; i++) {
switch (position_tab[i].direction) {
case AVANT:
Serial3.print("av");
break;
case DROITE:
Serial3.print("dr");
break;
case GAUCHE:
Serial3.print("ga");
break;
case ARRIERE:
Serial3.print("ar");
break;
default:
break;
}
switch (position_tab[i].action) {
case PLANTE:
Serial3.print("pl");
break;
case ARROSE:
Serial3.print("wa");
break;
case LESDEUX:
Serial3.print("l2");
break;
default:
break;
}
}
fin = true;
} else {
determine_direction();
if (j == 5) { // On effectue une capture tous les 5 incréments
condition = capture();
switch (condition) {
case ARROSE:
Serial.println("On arrose");
position_tab[tab_index].action = ARROSE;
break;
case PLANTE:
Serial.println("On plante");
position_tab[tab_index].action = PLANTE;
break;
case LESDEUX:
Serial.println("Les deux");
position_tab[tab_index].action = LESDEUX;
break;
default:
position_tab[tab_index].action = RIEN;
break;
}
j = 0;
} else {
position_tab[tab_index].action = RIEN;
}
tab_index++;
}
delay(500); // On rafraichit la direction toutes les 0.5 secondes
}
}
</pre>
==Tests de l'algorithme du robot 1==
Plusieurs tests ont été effectués tout au long du projet pour tester nos algorithmes les premiers utilisaient seulement les capteurs à ultrasons mais au fur et à mesure, nous avons réussi a lier l'ensemble des composants, voici quelques vidéos montrant les tests effectués.
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=hlS6NtwyzBk
|alignment=left
|description=test du robot 1 immobile
}}
{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=ECn0T1XQ3xc
|alignment=right
|description=test du robot 1 en conditions "réelles"
}}
 
Comme on voit sur la 2ème vidéo, puisque l'une des roues ne fonctionne pas dans un sens, il est impossible pour le robot d'aller à droite, et donc impossible de tester notre robot de façon réelle.

Robots jardiniers

2023-05-05T14:25:34Z

Emilie cnvt : /* Algorithme */

=Missions des robots jardiniers=
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé:
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra refaire le même chemin en sens inverse, on retiendra chacun des mouvements.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes ainsi nous n'aurions pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors:
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple: la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Nous avons choisi la Teensy comme carte motrice car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

Les deux cartes sont connectées par une liaison série pour communiquer.

=Déplacement des robots=

==Robot 1==

Afin de Controller les déplacements du robot, on va utiliser le code pour une plateforme holonome moteurs.
La procédure à suivre afin de vérifier et tester le fonctionnement des moteurs et de l'asservissement:
#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Téléverser
#
#Tester les moteurs en envoyer les commandes suivantes:
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.

On peut tester le code grâce à une console série avec une vitesse de 115200. On utilise alors le port série par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin( 115200);</code>).

Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :

Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.

Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandés et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.

Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la due utilisé (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

== Robot 2 et 3 ==

Ces robots utilisent les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE et un module WiFi.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

La première étape est de contrôler les moteurs avec la teensy, pour cela il faut utiliser le code suivant:
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes:
#La commande avXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande avXXX.
#Vous pouvez aussi tester les commandes at et et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes nous avons donc utiliser Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

Les instructions seront envoyées comme suit : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code pour initier la connexion :

 

Code Maitre : (ici sous arduino UNO)

<pre>
#include <SoftwareSerial.h> // Software Serial Port

#define RxD 7
#define TxD 6

#define DEBUG_ENABLED 1

SoftwareSerial blueToothSerial(RxD,TxD);

void setup()
{
Serial.begin(9600);
pinMode(RxD, INPUT);
pinMode(TxD, OUTPUT);

blueToothSerial.begin(9600);

Serial.println("AT : ");
blueToothSerial.print("AT");
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+Version : ");
blueToothSerial.print("AT+VERSION"); // Restore all setup value to factory setup
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+Default : ");
blueToothSerial.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+NAMESeeedMaster0 : ");
blueToothSerial.print("AT+NAMESeeedMaster0"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+ROLEM : ");
blueToothSerial.print("AT+ROLEM"); // set the bluetooth work in master mode
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+AUTH1 : ");
blueToothSerial.print("AT+AUTH1");
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+CLEAR : ");
blueToothSerial.print("AT+CLEAR"); // Clear connected device mac address
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+PIN1111 : ");
blueToothSerial.print("AT+PIN1111");

delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

//wait 1s and flush the serial buffer
delay(1000);
Serial.flush();
blueToothSerial.flush();

Serial.println("Debut de la communication");
}

</pre>

 

Voici les réponses aux commandes AT :

[[Fichier:Réponse_commandes_AT.JPG]]

 
Code Esclave : (ici avec une DUE, donc pas besoin de SoftwareSerial)

<pre>
#define DEBUG_ENABLED 1

void setup()
{
Serial.begin(9600);
Serial3.begin(9600);

Serial.println("AT");
Serial3.print("AT");

delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+Default");
Serial3.print("AT+DEFAULT");
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+NAMESeeedSlave0");
Serial3.print("AT+NAMESeeedSlave0"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+PIN1111");
Serial3.print("AT+PIN1111");
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}

delay(400);
Serial.println("AT+AUTH1");
Serial3.print("AT+AUTH1");
if(Serial3.available()){
Serial.print(lnSerial3.readStringUntil('\n'));
}

//wait 1s and flush the serial buffer
delay(1000);
Serial.flush();
Serial3.flush();

Serial.println("Debut de la communication");
}
</pre>

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz. Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. Le ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

 
Cette méthode ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder. Cependant, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports serial 3 deux fils vers serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

 

Pour la ESP32 en mode Broadcast :

 

<pre>
// Include Libraries
#include <WiFi.h>
#include <esp_now.h>

//Message to send
String recv;

void formatMacAddress(const uint8_t *macAddr, char *buffer, int maxLength)
// Formats MAC Address
{
snprintf(buffer, maxLength, "%02x:%02x:%02x:%02x:%02x:%02x", macAddr[0], macAddr[1], macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
}

void receiveCallback(const uint8_t *macAddr, const uint8_t *data, int dataLen)
// Called when data is received
{
// Only allow a maximum of 250 characters in the message + a null terminating byte
char buffer[ESP_NOW_MAX_DATA_LEN + 1];
int msgLen = min(ESP_NOW_MAX_DATA_LEN, dataLen);
strncpy(buffer, (const char *)data, msgLen);

// Make sure we are null terminated
buffer[msgLen] = 0;

// Format the MAC address
char macStr[18];
formatMacAddress(macAddr, macStr, 18);

// Send Debug log message to the serial port
Serial.printf("Received message from: %s - %s\n", macStr, buffer);

}

void sentCallback(const uint8_t *macAddr, esp_now_send_status_t status)
// Called when data is sent
{
char macStr[18];
formatMacAddress(macAddr, macStr, 18);
Serial.print("Last Packet Sent to: ");
Serial.println(macStr);
Serial.print("Last Packet Send Status: ");
Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

void broadcast(const String &message){
// Emulates a broadcast
// Broadcast a message to every device in range
uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
esp_now_peer_info_t peerInfo = {};
memcpy(&peerInfo.peer_addr, broadcastAddress, 6);
if (!esp_now_is_peer_exist(broadcastAddress))
{
esp_now_add_peer(&peerInfo);
}
// Send message
esp_err_t result = esp_now_send(broadcastAddress, (const uint8_t *)message.c_str(), message.length());

// Print results to serial monitor
if (result == ESP_OK)
{
Serial.println("Broadcast message success");
}
else if (result == ESP_ERR_ESPNOW_NOT_INIT)
{
Serial.println("ESP-NOW not Init.");
}
else if (result == ESP_ERR_ESPNOW_ARG)
{
Serial.println("Invalid Argument");
}
else if (result == ESP_ERR_ESPNOW_INTERNAL)
{
Serial.println("Internal Error");
}
else if (result == ESP_ERR_ESPNOW_NO_MEM)
{
Serial.println("ESP_ERR_ESPNOW_NO_MEM");
}
else if (result == ESP_ERR_ESPNOW_NOT_FOUND)
{
Serial.println("Peer not found.");
}
else
{
Serial.println("Unknown error");
}
}

void setup()
{

// Set up Serial Monitor
Serial.begin(115200);
Serial2.begin(115200);

// Set ESP32 in STA mode to begin with
WiFi.mode(WIFI_STA);
Serial.println("ESP-NOW Broadcast Demo");

// Print MAC address
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());

// Initialize ESP-NOW
if (esp_now_init() == ESP_OK)
{
Serial.println("ESP-NOW Init Success");
esp_now_register_recv_cb(receiveCallback);
esp_now_register_send_cb(sentCallback);
}
else
{
Serial.println("ESP-NOW Init Failed");
delay(3000);
ESP.restart();
}

}

void loop() {

//if(Serial2.available()){
//recv=Serial2.readStringUntil('\n');
recv="avavardrgaalal";
broadcast(recv);
//}

delay(5000);

}
</pre>

Pour les ESP32 en mode responder :

<pre>

#include <esp_now.h>
#include <WiFi.h>

char msg[32];
char sous_chaine[3]; // Tableau de char pour stocker les sous-chaînes
int i=0;
// Create a structured object

// Callback function executed when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
memcpy(&msg, incomingData, sizeof(msg));
Serial.print("Message received: ");
Serial.println(msg);
for(i=0;i<strlen(msg);i+=2){
sous_chaine[0] = msg[i];
sous_chaine[1] = msg[i+1];
sous_chaine[2] = '\0'; // Ajoute un caractère nul à la fin de la sous-chaîne
Serial.println(sous_chaine); // Affiche la sous-chaîne dans le moniteur série

}
}

void setup() {
// Set up Serial Monitor
Serial.begin(115200);

// Set ESP32 as a Wi-Fi Station
WiFi.mode(WIFI_STA);

// Initilize ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}

// Register callback function
esp_now_register_recv_cb(OnDataRecv);
}

void loop() {

}

</pre>

 

A noté que ici, on découpe le message reçu en chaines de caractères de longueur 2 qui correspondent directement aux ordres à donner au robot pour qu'il avance/recule/tourne.

Robots jardiniers

2023-05-05T14:25:19Z

Emilie cnvt : /* Moteurs */

=Missions des robots jardiniers=
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé:
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra refaire le même chemin en sens inverse, on retiendra chacun des mouvements.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes ainsi nous n'aurions pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors:
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple: la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Nous avons choisi la Teensy comme carte motrice car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

Les deux cartes sont connectées par une liaison série pour communiquer.

=Déplacement des robots=

==Robot 1==

Afin de Controller les déplacements du robot, on va utiliser le code pour une plateforme holonome moteurs.
La procédure à suivre afin de vérifier et tester le fonctionnement des moteurs et de l'asservissement:
#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Téléverser
#
#Tester les moteurs en envoyer les commandes suivantes:
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.

On peut tester le code grâce à une console série avec une vitesse de 115200. On utilise alors le port série par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin( 115200);</code>).

Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :

Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.

Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandés et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.

Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la due utilisé (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

===Algorithme===
== Robot 2 et 3 ==

Ces robots utilisent les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE et un module WiFi.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

La première étape est de contrôler les moteurs avec la teensy, pour cela il faut utiliser le code suivant:
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes:
#La commande avXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande avXXX.
#Vous pouvez aussi tester les commandes at et et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes nous avons donc utiliser Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

Les instructions seront envoyées comme suit : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code pour initier la connexion :

 

Code Maitre : (ici sous arduino UNO)

<pre>
#include <SoftwareSerial.h> // Software Serial Port

#define RxD 7
#define TxD 6

#define DEBUG_ENABLED 1

SoftwareSerial blueToothSerial(RxD,TxD);

void setup()
{
Serial.begin(9600);
pinMode(RxD, INPUT);
pinMode(TxD, OUTPUT);

blueToothSerial.begin(9600);

Serial.println("AT : ");
blueToothSerial.print("AT");
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+Version : ");
blueToothSerial.print("AT+VERSION"); // Restore all setup value to factory setup
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+Default : ");
blueToothSerial.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+NAMESeeedMaster0 : ");
blueToothSerial.print("AT+NAMESeeedMaster0"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+ROLEM : ");
blueToothSerial.print("AT+ROLEM"); // set the bluetooth work in master mode
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+AUTH1 : ");
blueToothSerial.print("AT+AUTH1");
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+CLEAR : ");
blueToothSerial.print("AT+CLEAR"); // Clear connected device mac address
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+PIN1111 : ");
blueToothSerial.print("AT+PIN1111");

delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

//wait 1s and flush the serial buffer
delay(1000);
Serial.flush();
blueToothSerial.flush();

Serial.println("Debut de la communication");
}

</pre>

 

Voici les réponses aux commandes AT :

[[Fichier:Réponse_commandes_AT.JPG]]

 
Code Esclave : (ici avec une DUE, donc pas besoin de SoftwareSerial)

<pre>
#define DEBUG_ENABLED 1

void setup()
{
Serial.begin(9600);
Serial3.begin(9600);

Serial.println("AT");
Serial3.print("AT");

delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+Default");
Serial3.print("AT+DEFAULT");
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+NAMESeeedSlave0");
Serial3.print("AT+NAMESeeedSlave0"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+PIN1111");
Serial3.print("AT+PIN1111");
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}

delay(400);
Serial.println("AT+AUTH1");
Serial3.print("AT+AUTH1");
if(Serial3.available()){
Serial.print(lnSerial3.readStringUntil('\n'));
}

//wait 1s and flush the serial buffer
delay(1000);
Serial.flush();
Serial3.flush();

Serial.println("Debut de la communication");
}
</pre>

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz. Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. Le ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

 
Cette méthode ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder. Cependant, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports serial 3 deux fils vers serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

 

Pour la ESP32 en mode Broadcast :

 

<pre>
// Include Libraries
#include <WiFi.h>
#include <esp_now.h>

//Message to send
String recv;

void formatMacAddress(const uint8_t *macAddr, char *buffer, int maxLength)
// Formats MAC Address
{
snprintf(buffer, maxLength, "%02x:%02x:%02x:%02x:%02x:%02x", macAddr[0], macAddr[1], macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
}

void receiveCallback(const uint8_t *macAddr, const uint8_t *data, int dataLen)
// Called when data is received
{
// Only allow a maximum of 250 characters in the message + a null terminating byte
char buffer[ESP_NOW_MAX_DATA_LEN + 1];
int msgLen = min(ESP_NOW_MAX_DATA_LEN, dataLen);
strncpy(buffer, (const char *)data, msgLen);

// Make sure we are null terminated
buffer[msgLen] = 0;

// Format the MAC address
char macStr[18];
formatMacAddress(macAddr, macStr, 18);

// Send Debug log message to the serial port
Serial.printf("Received message from: %s - %s\n", macStr, buffer);

}

void sentCallback(const uint8_t *macAddr, esp_now_send_status_t status)
// Called when data is sent
{
char macStr[18];
formatMacAddress(macAddr, macStr, 18);
Serial.print("Last Packet Sent to: ");
Serial.println(macStr);
Serial.print("Last Packet Send Status: ");
Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

void broadcast(const String &message){
// Emulates a broadcast
// Broadcast a message to every device in range
uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
esp_now_peer_info_t peerInfo = {};
memcpy(&peerInfo.peer_addr, broadcastAddress, 6);
if (!esp_now_is_peer_exist(broadcastAddress))
{
esp_now_add_peer(&peerInfo);
}
// Send message
esp_err_t result = esp_now_send(broadcastAddress, (const uint8_t *)message.c_str(), message.length());

// Print results to serial monitor
if (result == ESP_OK)
{
Serial.println("Broadcast message success");
}
else if (result == ESP_ERR_ESPNOW_NOT_INIT)
{
Serial.println("ESP-NOW not Init.");
}
else if (result == ESP_ERR_ESPNOW_ARG)
{
Serial.println("Invalid Argument");
}
else if (result == ESP_ERR_ESPNOW_INTERNAL)
{
Serial.println("Internal Error");
}
else if (result == ESP_ERR_ESPNOW_NO_MEM)
{
Serial.println("ESP_ERR_ESPNOW_NO_MEM");
}
else if (result == ESP_ERR_ESPNOW_NOT_FOUND)
{
Serial.println("Peer not found.");
}
else
{
Serial.println("Unknown error");
}
}

void setup()
{

// Set up Serial Monitor
Serial.begin(115200);
Serial2.begin(115200);

// Set ESP32 in STA mode to begin with
WiFi.mode(WIFI_STA);
Serial.println("ESP-NOW Broadcast Demo");

// Print MAC address
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());

// Initialize ESP-NOW
if (esp_now_init() == ESP_OK)
{
Serial.println("ESP-NOW Init Success");
esp_now_register_recv_cb(receiveCallback);
esp_now_register_send_cb(sentCallback);
}
else
{
Serial.println("ESP-NOW Init Failed");
delay(3000);
ESP.restart();
}

}

void loop() {

//if(Serial2.available()){
//recv=Serial2.readStringUntil('\n');
recv="avavardrgaalal";
broadcast(recv);
//}

delay(5000);

}
</pre>

Pour les ESP32 en mode responder :

<pre>

#include <esp_now.h>
#include <WiFi.h>

char msg[32];
char sous_chaine[3]; // Tableau de char pour stocker les sous-chaînes
int i=0;
// Create a structured object

// Callback function executed when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
memcpy(&msg, incomingData, sizeof(msg));
Serial.print("Message received: ");
Serial.println(msg);
for(i=0;i<strlen(msg);i+=2){
sous_chaine[0] = msg[i];
sous_chaine[1] = msg[i+1];
sous_chaine[2] = '\0'; // Ajoute un caractère nul à la fin de la sous-chaîne
Serial.println(sous_chaine); // Affiche la sous-chaîne dans le moniteur série

}
}

void setup() {
// Set up Serial Monitor
Serial.begin(115200);

// Set ESP32 as a Wi-Fi Station
WiFi.mode(WIFI_STA);

// Initilize ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}

// Register callback function
esp_now_register_recv_cb(OnDataRecv);
}

void loop() {

}

</pre>

 

A noté que ici, on découpe le message reçu en chaines de caractères de longueur 2 qui correspondent directement aux ordres à donner au robot pour qu'il avance/recule/tourne.

Robots jardiniers

2023-05-05T14:24:37Z

Emilie cnvt : /* Déplacement des robots */

=Missions des robots jardiniers=
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile. Les autres robots auront seulement besoin de reproduire les déplacements du robot 1.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé:
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra refaire le même chemin en sens inverse, on retiendra chacun des mouvements.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes ainsi nous n'aurions pas pu effectuer une simulation concrète de notre algorithme. La simulation et la création d'un nouveau robot auraient pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation même si cette dernière aurait été très intéressante pour tester notre algorithme.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors:
== Capteur UV ==
Pour capter la luminosité, nous utilisons le capteur d'UV de Grove "Grove UV sensor" 
[[Fichier:grove_uv_sensor.jpg|500px]] 
Ce capteur retourne une tension de l'ordre du mV qu'on transformera en indice UV grâce à une fonction qu'on retrouvera dans la '''[https://wiki.seeedstudio.com/Grove-UV_Sensor/ Documentation]'''.
On utilisera cet indice UV pour détecter si la zone est bien éclairée, donc s'il faut planter au point ou les mesures sont prises

== Capteur humidité et température ==
Pour détecter les conditions idéales de plantation et d'arrosage des plantes, nous avons utilisé un capteur combinant la détection de température et d'humidité de l'air, il s'agit du "Grove humidity and temperature sensor"
 
[[File:grove_humidity_temperature.jpg|300px]]
 
Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la [https://wiki.seeedstudio.com/Grove-TemperatureAndHumidity_Sensor/ Documentation] de récupérer le taux d'humidité de l'air et la température en degrés

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles. 
Ce capteur est également doté d'un module additionnel d'analyse permettant de recevoir en entrée de la carte une information simple: la présence de gouttes de pluies, on recevra alors un signal booléen permettant de savoir si il pleut. Si tel est le cas, on ordonnera au robot 1 de rentrer à la base.

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Tout d'abbord, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs. Elles possède aussi des avantages comme sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle est dotée d'une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]
# Les cartes sont alimentées par des batteries externes de 5V

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Nous avons choisi la Teensy comme carte motrice car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

Les deux cartes sont connectées par une liaison série pour communiquer.

=Déplacement des robots=

==Robot 1==

===Moteurs===
Afin de Controller les déplacements du robot, on va utiliser le code pour une plateforme holonome moteurs.
La procédure à suivre afin de vérifier et tester le fonctionnement des moteurs et de l'asservissement:
#Téléverser ce code dans la carte Teensy. La vitesse maximale est définie par le paramètre paramVitesse dans le début du code.
#Téléverser
#
#Tester les moteurs en envoyer les commandes suivantes:
#:-<code>av1</code> pour démarrer le moteur 1 à pleine vitesse
#:-<code>am1</code> pour démarrer le moteur 1 à demi vitesse
#:-<code>st</code> pour stopper tous les moteurs
#Tester les déplacements en entiers
#:-<code>avd</code> pour que le robot avance : on active simultanément les moteurs 1 et 3.
#:-<code>avg</code> pour que le robot se déplace à gauche : on active simultanément les moteurs 2 et 4.
#:-<code>rg</code> pour que le robot fasse une rotation dans le sens trigonométrique : on active simultanément les moteurs 1,2,3 et 4.

On peut tester le code grâce à une console série avec une vitesse de 115200. On utilise alors le port série par défaut de la carte, il faut donc penser à l'ouvrir (<code>Serial.begin( 115200);</code>).

Lors des premiers essais de déplacement, nous avons eu quelques problèmes concernant l'asservissement. En effet, on a remarqué au début du projet que la roue 1 avait une vitesse de rotation très importante comparée aux autres et que le moteur 2 ne tournait que dans un sens. Ces difficultés posaient problème pour le déplacement du robot. On a donc test toute la chaine en partant de la Teensy jusqu'aux moteurs :

Premièrement, concernant le moteur qui ne tourne que dans un sens, le problème vient du pont en H qui ne fait pas circuler le courant dans un sens. Ce pont est à changer l'année prochaine.

Deuxièmement, en étudiant le moteur 1, nous avons remarqué qu'il ne répondait pas aux consignes demandés et en particulier l'asservissement. Il semblerait effectivement que les branchements de l'asservissement sur la Teensy sur le schéma électrique fourni ne sont plus d'actualités. Les ports de la Teensy n'étaient donc pas les bons ports dans le code de l'Arduino. Après vérification, voici les bons ports :

M1Out1 = 16;

M1Out0 = 17;

M2Out1 = 14;

M2Out0 = 15;

M3Out1 = 11;

M3Out0 = 12;

M4Out1 = 9;

M4Out0 = 10;

Une fois les ports correctement associés, l'asservissement de la roue 1 fonctionne correctement et les roues tournent toutes à la même vitesse.

Pour effectuer les opérations de déplacement à l'aide de l'Arduino Due, il faut connecter les deux cartes à l'aide des ports séries en croisant le Tx et le Rx. Il faut également ouvrir le port série de la due utilisé (<code>SerialX.begin(115200);</code>) pour le port série X. Finalement, ne pas oublier de relier les masses de la Teensy et de la Due ensemble.

===Algorithme===
== Robot 2 et 3 ==

Ces robots utilisent les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE et un module WiFi.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

La première étape est de contrôler les moteurs avec la teensy, pour cela il faut utiliser le code suivant:
Les déplacements des robots 2 et 3 sont gérés avec les commandes suivantes:
#La commande avXXX permet d'indiquer la direction, sous forme d'angle en degrés (ex XXX = 120), dans laquelle le robot va se déplacer (cette commande ne fait pas bouger le robot).
#La commande ho3 entraîne le déplacement du robot dans la direction indiquée avec la commande avXXX.
#Vous pouvez aussi tester les commandes at et et permettant respectivement d'allumer et d'éteindre la led de la Teensy.

Ensuite, il faut établir une liaison série entre l'ESP32 et la Teensy, l'objectif est de contrôler le robot depuis l'ESP32 car c'est cette carte qui recevra les informations du robot 1, pour cela vous pouvez commencer par utiliser ce code simple permettant de faire clignoter la LED de la Teensy. Dans notre cas nous avons utilisé les ports 16 et 17 de l'ESP32 qui correspondent à UART2, pour envoyer les commandes nous avons donc utiliser Serial2.

<pre>
void setup() {

Serial2.begin(115200); // Initialize serial communication at 115200 baud

}

void loop() {

Serial2.print("al"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

Serial2.print("et"); // Send "Blink" command to Teensy

delay(1000); // Wait for 1 second

}
</pre>

Il faut ensuite modifier le code pour envoyer les commandes permettant au robot de se déplacer.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

Les instructions seront envoyées comme suit : 

 
* av : Avance tout droit de 10 cm
* dr : Tourne à droite et avance de 10 cm
* ga : Tourne à gauche et avance de 10 cm
* ar : Recule de 10 cm.

=== 1ère tentative : Bluetooth (ECHEC)===

[[Fichier:bluetooth2.jpg|800px]]

 

Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01.

[[Fichier:IMG_5040.jpg|300px]]

 

Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Pour plus d'information sur les commandes AT, voici le site officiel de Seedstudio :
[https://wiki.seeedstudio.com/Bluetooth_Bee_v2.0/]. Si le module est connecté, la petite LED verte de celui-ci s'arrête de clignoter. Pour voir un exemple d'utilisation dont nous sommes fortement inspirés, consulter le site suivant :[https://wiki.seeedstudio.com/Grove-Serial_Bluetooth_v3.0/]

Voici le code pour initier la connexion :

 

Code Maitre : (ici sous arduino UNO)

<pre>
#include <SoftwareSerial.h> // Software Serial Port

#define RxD 7
#define TxD 6

#define DEBUG_ENABLED 1

SoftwareSerial blueToothSerial(RxD,TxD);

void setup()
{
Serial.begin(9600);
pinMode(RxD, INPUT);
pinMode(TxD, OUTPUT);

blueToothSerial.begin(9600);

Serial.println("AT : ");
blueToothSerial.print("AT");
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+Version : ");
blueToothSerial.print("AT+VERSION"); // Restore all setup value to factory setup
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+Default : ");
blueToothSerial.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+NAMESeeedMaster0 : ");
blueToothSerial.print("AT+NAMESeeedMaster0"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+ROLEM : ");
blueToothSerial.print("AT+ROLEM"); // set the bluetooth work in master mode
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

delay(400);

Serial.println("AT+AUTH1 : ");
blueToothSerial.print("AT+AUTH1");
delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+CLEAR : ");
blueToothSerial.print("AT+CLEAR"); // Clear connected device mac address
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+PIN1111 : ");
blueToothSerial.print("AT+PIN1111");

delay(400);
if(blueToothSerial.available()){
Serial.println(blueToothSerial.readStringUntil('\n'));
}

//wait 1s and flush the serial buffer
delay(1000);
Serial.flush();
blueToothSerial.flush();

Serial.println("Debut de la communication");
}

</pre>

 

Voici les réponses aux commandes AT :

[[Fichier:Réponse_commandes_AT.JPG]]

 
Code Esclave : (ici avec une DUE, donc pas besoin de SoftwareSerial)

<pre>
#define DEBUG_ENABLED 1

void setup()
{
Serial.begin(9600);
Serial3.begin(9600);

Serial.println("AT");
Serial3.print("AT");

delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+Default");
Serial3.print("AT+DEFAULT");
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+NAMESeeedSlave0");
Serial3.print("AT+NAMESeeedSlave0"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}
delay(400);

Serial.println("AT+PIN1111");
Serial3.print("AT+PIN1111");
delay(400);
if(Serial3.available()){
Serial.println(Serial3.readStringUntil('\n'));
}

delay(400);
Serial.println("AT+AUTH1");
Serial3.print("AT+AUTH1");
if(Serial3.available()){
Serial.print(lnSerial3.readStringUntil('\n'));
}

//wait 1s and flush the serial buffer
delay(1000);
Serial.flush();
Serial3.flush();

Serial.println("Debut de la communication");
}
</pre>

=== Mode de communication retenu : WiFi===

Nous nous aidons de la bibliothèque ESP-NOW. Pour avoir toutes les méthodes et fonction de la bibliothèque : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/network/esp_now.html#_CPPv416esp_now_add_peerPK19esp_now_peer_info_t. Pour avoir un exemple dont nous sommes inspirés : https://dronebotworkshop.com/esp-now/.

On souhaite établir une communication entre les robots, via ESP32. On utilise alors ESP-NOW. Il s'agit d'un protocole de communication unique aux ESP32. Le protocole utilise la bande de fréquence 2.4 GHz. Dans le cadre de ce projet, le mode opératoire est appelé broadcast, c'est-à-dire que toutes les cartes ESP32 recevront le message envoyé. Le ESP32 du robot 1 joue le rôle d'initiateur (initiator) et les ESP32 des robots 2 et 3 jouent le rôle de récepteur (responder).

 

[[Fichier:Esp-now bb.jpg|700px]]

 
Cette méthode ne nécessite pas de connaître les adresses MAC des ESP32 qui auront le rôle de responder. Cependant, nous avons d'abord essayé de communiquer en point à point avec les adresses MAC. Celle-ci peuvent être obtenue facilement avec ce code :

Il faut bien noter les adresses obtenues pour éviter de le refaire plusieurs fois.

 
<pre>

// Include WiFi Library
#include "WiFi.h"

void setup() {

// Setup Serial Monitor
Serial.begin(115200);

// Put ESP32 into Station mode
WiFi.mode(WIFI_MODE_STA);

// Print MAC Address to Serial monitor
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());
}

void loop() {

}

</pre>
 

Comme notre carte principale est la Arduino Due , on connecte sur les ports serial 3 deux fils vers serial 2 (en inverser) de la ESP32. C'est la Due qui enverra les messages à envoyer.

Voici le code utilisé pour envoyer les données en mode broadcast :

 

Pour la Due :

 

<pre>
String mvt="avavavdrdrgaalalav";
void setup() {

Serial.begin(115200);
Serial3.begin(115200);

}

void loop() {
Serial3.print(mvt);
delay(1000);
}

</pre>

 

Pour la ESP32 en mode Broadcast :

 

<pre>
// Include Libraries
#include <WiFi.h>
#include <esp_now.h>

//Message to send
String recv;

void formatMacAddress(const uint8_t *macAddr, char *buffer, int maxLength)
// Formats MAC Address
{
snprintf(buffer, maxLength, "%02x:%02x:%02x:%02x:%02x:%02x", macAddr[0], macAddr[1], macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
}

void receiveCallback(const uint8_t *macAddr, const uint8_t *data, int dataLen)
// Called when data is received
{
// Only allow a maximum of 250 characters in the message + a null terminating byte
char buffer[ESP_NOW_MAX_DATA_LEN + 1];
int msgLen = min(ESP_NOW_MAX_DATA_LEN, dataLen);
strncpy(buffer, (const char *)data, msgLen);

// Make sure we are null terminated
buffer[msgLen] = 0;

// Format the MAC address
char macStr[18];
formatMacAddress(macAddr, macStr, 18);

// Send Debug log message to the serial port
Serial.printf("Received message from: %s - %s\n", macStr, buffer);

}

void sentCallback(const uint8_t *macAddr, esp_now_send_status_t status)
// Called when data is sent
{
char macStr[18];
formatMacAddress(macAddr, macStr, 18);
Serial.print("Last Packet Sent to: ");
Serial.println(macStr);
Serial.print("Last Packet Send Status: ");
Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

void broadcast(const String &message){
// Emulates a broadcast
// Broadcast a message to every device in range
uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
esp_now_peer_info_t peerInfo = {};
memcpy(&peerInfo.peer_addr, broadcastAddress, 6);
if (!esp_now_is_peer_exist(broadcastAddress))
{
esp_now_add_peer(&peerInfo);
}
// Send message
esp_err_t result = esp_now_send(broadcastAddress, (const uint8_t *)message.c_str(), message.length());

// Print results to serial monitor
if (result == ESP_OK)
{
Serial.println("Broadcast message success");
}
else if (result == ESP_ERR_ESPNOW_NOT_INIT)
{
Serial.println("ESP-NOW not Init.");
}
else if (result == ESP_ERR_ESPNOW_ARG)
{
Serial.println("Invalid Argument");
}
else if (result == ESP_ERR_ESPNOW_INTERNAL)
{
Serial.println("Internal Error");
}
else if (result == ESP_ERR_ESPNOW_NO_MEM)
{
Serial.println("ESP_ERR_ESPNOW_NO_MEM");
}
else if (result == ESP_ERR_ESPNOW_NOT_FOUND)
{
Serial.println("Peer not found.");
}
else
{
Serial.println("Unknown error");
}
}

void setup()
{

// Set up Serial Monitor
Serial.begin(115200);
Serial2.begin(115200);

// Set ESP32 in STA mode to begin with
WiFi.mode(WIFI_STA);
Serial.println("ESP-NOW Broadcast Demo");

// Print MAC address
Serial.print("MAC Address: ");
Serial.println(WiFi.macAddress());

// Initialize ESP-NOW
if (esp_now_init() == ESP_OK)
{
Serial.println("ESP-NOW Init Success");
esp_now_register_recv_cb(receiveCallback);
esp_now_register_send_cb(sentCallback);
}
else
{
Serial.println("ESP-NOW Init Failed");
delay(3000);
ESP.restart();
}

}

void loop() {

//if(Serial2.available()){
//recv=Serial2.readStringUntil('\n');
recv="avavardrgaalal";
broadcast(recv);
//}

delay(5000);

}
</pre>

Pour les ESP32 en mode responder :

<pre>

#include <esp_now.h>
#include <WiFi.h>

char msg[32];
char sous_chaine[3]; // Tableau de char pour stocker les sous-chaînes
int i=0;
// Create a structured object

// Callback function executed when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
memcpy(&msg, incomingData, sizeof(msg));
Serial.print("Message received: ");
Serial.println(msg);
for(i=0;i<strlen(msg);i+=2){
sous_chaine[0] = msg[i];
sous_chaine[1] = msg[i+1];
sous_chaine[2] = '\0'; // Ajoute un caractère nul à la fin de la sous-chaîne
Serial.println(sous_chaine); // Affiche la sous-chaîne dans le moniteur série

}
}

void setup() {
// Set up Serial Monitor
Serial.begin(115200);

// Set ESP32 as a Wi-Fi Station
WiFi.mode(WIFI_STA);

// Initilize ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}

// Register callback function
esp_now_register_recv_cb(OnDataRecv);
}

void loop() {

}

</pre>

 

A noté que ici, on découpe le message reçu en chaines de caractères de longueur 2 qui correspondent directement aux ordres à donner au robot pour qu'il avance/recule/tourne.

Robots jardiniers

2023-05-02T06:58:48Z

Emilie cnvt : /* Simulation */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé:
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra refaire le même chemin en sens inverse, on retiendra chacun des mouvements.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin on fait demi-tour
</pre>

=Simulation=

La simulation de robot permet de vérifier que le comportement du robot est adéquat avec les fonctionnalités recherchés.

[[File:webots_jardin.png|800px|Fenetre de simulation Webots]]

Nous avons essayé de simuler avec le logiciel Webots. Nous avons commencer par modéliser le terrain, c'est à dire un carré d'herbe avec des objets qu'on pourrait trouver dans un jardin. Cependant, nous n'avons pas réussi à trouver un robot avec des roues holonomes ainsi nous n'aurions pas pu effectuer une simulation concrète de notre algorithme. La simulation aurait pris beaucoup de temps par rapport à celui dont on dispose, nous avons choisi de ne pas finir la simulation.

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles

Nous avons alors décidé d'utiliser les différents capteurs disponibles à Télécom car ils remplissaient les fonctions demandées, nous utiliserons alors:
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles.

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-05-02T06:36:51Z

Emilie cnvt : /* Simulation */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé:
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra refaire le même chemin en sens inverse, on retiendra chacun des mouvements.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin on fait demi-tour
</pre>

=Simulation=
[[File:webots_jardin.png|800px|fenetre de simulation webots]]

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles.

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-05-02T06:36:40Z

Emilie cnvt : /* Simulation */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé:
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra refaire le même chemin en sens inverse, on retiendra chacun des mouvements.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin on fait demi-tour
</pre>

=Simulation=
[[File:webots_jardin.png|800px|left|fenetre de simulation webots]]

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles.

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-05-02T06:36:14Z

Emilie cnvt :

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé:
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra refaire le même chemin en sens inverse, on retiendra chacun des mouvements.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin on fait demi-tour
</pre>

=Simulation=
[[File:webots_jardin.png|432px|thumb|left|fenetre de simulation webots]]

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Un capteur de gouttes de pluie, ou capteur de détection de gouttes de pluie, est utilisé pour détecter s'il pleut ou non, ainsi que les précipitations. Il est largement utilisé dans des systèmes d'essuie-glace automatique, des systèmes d'éclairages intelligents et de toits ouvrants d'automobiles.

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Fichier:Webots jardin.png

2023-05-02T06:35:07Z

Emilie cnvt :

Robots jardiniers

2023-05-02T06:34:18Z

Emilie cnvt :

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé:
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
Pour le retour, il faudra refaire le même chemin en sens inverse, on retiendra chacun des mouvements.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm (voir les schémas ci-dessus)
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arrive en bas du jardin on fait demi-tour
</pre>

=Simulation=

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor". '''[https://wiki.seeedstudio.com/Grove-Moisture_Sensor/ Documentation]'''
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==
[[File:raindrop.jpg]] 
'''[https://docs.sunfounder.com/projects/sensorkit-v2-arduino/en/latest/lesson_34.html Documentation]'''
Capteur détecteur de gouttes de pluie

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-04-07T12:36:47Z

Emilie cnvt : /* Pseudo code */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

Voici un schéma explicatif de l'algorithme utilisé
[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm voir les schémas ci-dessus
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arriv en bas du jardin on fait demi-tour
</pre>

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor".
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-04-07T12:34:13Z

Emilie cnvt : /* Choix de l'algorithme de déplacement */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
 
 
 
 

[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
 
 
 

 
==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm voir le schéma associé
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arriv en bas du jardin on fait demi-tour
</pre>

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor".
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-04-07T12:33:44Z

Emilie cnvt : /* Pseudo code */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
 
 
 
 

[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]
 
 
 
 

 ==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm voir le schéma associé
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arriv en bas du jardin on fait demi-tour
</pre>

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor".
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-04-07T12:33:17Z

Emilie cnvt : /* Pseudo code */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

[[File:chemin_robot.png|432px|thumb|left|chemin normal du robot]]
[[File:chemin_robot_obstacle.png|432px|thumb|right|chemin du robot avec obstacle détecté]]

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement) //suivant le déplacement qu'on a choisi
case 1:
moteur_avant(); //on avance le moteur correspondant
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10); //le robot descend seulement de 10cm voir le schéma associé
if (direction==2) //si la direction était gauche alors elle devient droite et inversement
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av() // dès que le capteur avant détecte une détection, on veut se déplacer à droite

if (capteur_droite != 1) //s'il n'y a pas d'obstacle à droite
deplacement=3; //on se déplace à droite
else //sinon
fin interruption // on quitte l'interruption capteur avant pour aller dans l'interruption capteur droite

- capteur_droite() ou capteur_gauche()

deplacement=4; // lorsque qu'un mur ou un obstacle est détecté, on veut descendre

-capteur_ar()
deplacement=1; //dès qu'on arriv en bas du jardin on fait demi-tour
</pre>

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor".
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-04-07T12:27:20Z

Emilie cnvt : /* Pseudo code */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles.

Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
Le projet consiste à avancer jusqu'au fond du terrain (on considère ici que le terrain est un rectangle).
Le robot avance jusqu'à détecter un objet puis on se dirige vers la droite. Ensuite, le robot continue a droite jusqu'à détecter un objet, ce qui nous fera aller vers l'arrière. Le robot roulera vers l'arrière pendant quelques centimètres puis ira à gauche.
Lors de la prochaine détection d'un objet, le robot réutilisera la même méthode mais en inversant la droite et la gauche.

==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement)
case 1:
moteur_avant();
break;
case2:
moteur_gauche();
break;
case 3:
moteur_droite();
break;
default :
moteur_arriere(10);
if (direction==2)
deplacement=3;
else
deplacement=2;

break;

Interruptions :

- capteur_av()

if (capteur_droite != 1)
deplacement=3;
else
fin interruption

- capteur_droite() ou capteur_gauche()

deplacement=4;

-capteur_ar()
deplacement=1;
</pre>

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor".
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-04-07T12:21:00Z

Emilie cnvt : /* Pseudo code */

=Présentation=

==Objectifs pédagogiques==
Les objectifs pédagogiques de l'option Robotique sont les suivantes :
* découvrir la robotique en s'appuyant sur une démarche pratique et concrète ;
* savoir mettre en œuvre des capteurs analogiques et numériques ;
* acquérir des notions sur la commande des moteurs et leur asservissement ;
* maîtriser les spécificités des interfaces de puissance à base de commutation (hacheurs, pont en H) ;
* prendre conscience des difficultés pratiques et technologiques de mise en œuvre de robots ;
* mettre en œuvre une démarche de ''reverse-engineering'' pour la prise en main du matériel ;
* mettre en œuvre une démarche DD-RSE, afin d'évaluer la réparabilité des plateformes robotiques utilisées ;
* savoir programmer des scénarios de comportement prenant en compte l’environnement ;
* bonne pratique de programmation C ou Python : commentaires, noms intelligibles de variables ou fonctions, utilisation d'un dépôt Git...
* méthodologie de gestion de projet, en groupe : gestion des ressources, gestion du temps, plan de tests...
* s’initier à une démarche de ''Design Thinking'' pour la conception de projet.

==Modalités d'évaluation==
Les modalités d'évaluation du module seront :
* avancée du projet : intérêt porté au projet, travail pendant et en dehors des séances, efficacité du travail en groupe...
* utilisation des outils et notamment mise à jour du Wiki ;
* présentation + démonstration technique finale du projet ;
* examen écrit (QCM, sans document) - jeudi 4 mai ;

==Outils à utiliser==
# wiki : explication et documentation du projet ;
# projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents codes ;
# ''ToDoList'' avec les missions de chaque étudiant, au fur et à mesure des séances ;

==Missions des robots jardiniers==
Les robots jardiniers devront réaliser les actions suivantes :
# départ de la base du robot 1 ;
# exploration de l'environnement en évitant les obstacles ;
# évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
# si détection de paramètres propices, communication vers les robots 2 et 3 ;
# cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
# action des robots 2 et 3 au point cible : arrosage, forage du sol\ldots

=Décomposition initiale du travail=
Pour le début de ce projet, nous avons décidé de décomposer le groupe en plusieurs sous-groupes de travail, chacun constitué d'un chef. Egalement, nous avons décidé d'inclure un chef global de groupe qui permettra de faciliter la communication entre les groupes en gardant un œil sur les différents groupes.
Ces groupes sont les suivants :
* Groupe 1: Robot 1 (robot détecteur équipé de plusieurs capteurs permettant de créer une carte à suivre pour les autres robots): 6 étudiants
* Groupe 2: Robot 2 (robot arroseur qui suivra le chemin créé par le robot 1): 3 étudiants
* Groupe 3: Robot 3 (robot planteur qui suivra le chemin créé par le robot 1): 3 étudiants

Cette composition sera très vite amenée à changer, étant donné que les robots 2 et 3 sont très similaires, les étudiants de ces 2 groupes travailleront souvent ensembles.

=Algorithmes des robots=

Pour déplacer le Robot 1, nous avons retenu le choix de discrétiser l'espace en 10 cm. Chaque mouvement effectué fera donc 10 cm, nous avons des capteurs à ultrasons qui transmettront au robot s'il est capable d'avancer de 10 cm sans rentrer dans un obstacle. Comme le Robot 1 ne tourne pas (il n'y pas vraiment de gauche ou de droite avec les roues holonomes) cela rend la tâche plus facile.

==Choix de l'algorithme de déplacement==
Nous avons choisi un algorithme simple permettant de parcourir une grande distance et d'éviter la plupart des obstacles. Etant donné la durée du projet assez courte, faire un algorithme trop complexe aurait été assez contraignant.
==Pseudo code==

<pre>
int deplacement ; //1=avant 2=gauche 3= droite 4= arrière
int direction; //2= gauche 3= droite

switch(deplacement)
\t case 1:

case2:

case 3:
defaut :
</pre>

=Choix des capteurs=

Afin de pouvoir mesurer au mieux les caractéristiques du terrain pour déterminer où il devra planter et où il devra arroser, notre robot aura besoin de plusieurs capteurs:
* Un capteur à UV pour la luminosité
* Un capteur d'humidité de l'air
* Un capteur de température
* Un capteur pour mesurer d'humidité du sol
* 4 capteurs de proximité à ultrason pour détecter les obstacles
== Capteur UV ==

== Capteur humidité et température ==

== Capteur humidité du sol ==
Après étude, nous avons choisi d'utiliser le capteur "Grove moisture sensor".
Sa forme de fourche lui permet de se planter dans le sol plus facilement. Son fonctionnement est simple, plus le sol est humide, plus le courant pourra passer entre les 2 dents de la fourche 

[[Fichier:sol_sec.jpg|300px|center]]
<div style='text-align: center;'>Prise du capteur d'humidité du sol dans un sol sec</div>
 

{| class="wikitable" style="margin:auto"
|+ Tableau récapitulatif des mesures du sol (prises à Télécom un lendemain de jour de pluie et un jour sec)
|-
! Etat du sol !! Valeur mesurée par le capteur
|-
| Terre sèche|| 300
|-
| Terre sèche avec herbe || 350
|-
| Terre avec herbe (pluie la veille) || 600
|-
| Terre sèche après avoir été humidifiée || 650
|-

| Terre trempée|| 720
|}

Ces mesures nous permettent alors de déterminer les valeurs pour lesquelles le sol a besoin d'être arrosé ou non. On détermine alors que lorsque le sol a besoin d'être arrosées, nos valeurs de retour seront inférieures à 400, et lorsque le seuil a été arrosé récemment, nos valeurs seront supérieures à 400. 
On décide alors de fixer le seuil du capteur à '''400 '''.

== Capteur de gouttes de pluie ==

= Choix des cartes =

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

- Esp32 Thing : 
Nous avons choisi cette carte car elle possède une communication BLE et une faible consommation.

- Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précédemment.

== Robot 3 ==

Ce robot utilise les cartes de développement Esp32 Thing et Teensy pour les mêmes raisons que précédemment.

=Prise en main des plateformes=

==Alimentation==
*Le robot maître :
# Il possède un convertisseur de tension 9-18 à 5VDC. Il s'alimente à l'aide d'une batterie de 9.6V composée de 8 cellules Ni-Mh, la tension maximale est d'environ 10.7V.
# Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun à 0.5A en fonctionnement à vide et jusqu'à 1.3A en fonctionnement nominal (à un couple de 2 kgf-cm) : [https://bacasable.arpitania.eu//index.php?title=Fichier:Doc_HG37D670WE12_motor.pdf Documentation du moteur]

*Les robots esclaves ont deux sources d'alimentation :
# La partie logique est alimentée par une pile 9V au travers d'une carte TRACO POWER (4.5-9V -> 3.3V). Celle-ci alimente la carte Teensy et la carte Sparkfun ESP32 Thing.
# La partie puissance est alimentée par un ensemble de 8 piles Ni-Mh, qui délivre 9.6V. Elles sont connectées au port Pvex1 (et à la masse juste en dessous) d'après cette [https://mootse.telecom-st-etienne.fr/pluginfile.php/65110/mod_resource/content/1/PCB_Robot4Voies.PDF représentation du PCB].
:Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du connecteur d'alimentation.

== Robot 1 ==

Ce robot utilise les cartes de développement suivantes : Arduino Due et Teensy.

 Arduino Due : 
Nous avons choisi une carte Arduino car nous trouvons que la programmation est plus facile.
Nous avons pris le modèle Due car la Arduino Uno ne possédait pas assez de ports d'interruptions (seulement 2).
L'inconvénient est que la carte est grande par rapport à notre robot.
 

 Teensy : 

Premièrement, nous avons choisi la Teensy car c'est la carte utilisée par les années précédentes. Ainsi, nous disposons de tous les codes pour faire tourner les moteurs.
Ses avantages sont sa polyvalence et sa petite taille. 

== Robot 2 ==

Ce robot utilise les cartes de développement suivantes : Esp32 Thing et Teensy.

 Esp32 Thing : 
Nous avons choisi cette carte, car elle possède une communication BLE.

 Teensy : 

Nous avons choisi la Teensy pour les mêmes raisons que précedemment.

=Communication entre les robots=

Pour communiquer entre les robots, nous avons choisi le protocole suivant : Le robot se déplace et prend plusieurs mesures, il les enregistre et au choisi le meilleur point pour planter des choux. Le chemin qu'il a parcouru est stocké en mémoire, il envoie donc les instructions de se déplacer jusqu'à ce point au robot 2 puis au 3. Les robots 2 et 3 reproduisent le même parcours que le robot 1, certes ce n'est pas le chemin le plus court, mais c'est la solution la plus facile.

 

Le mode de communication retenu est le Bluetooth. Les instructions seront envoyées comme suit : 

 

* 1 bit de start, 1 bit de stop
* 00 : Avance tout droit de 10 cm
* 01 : Tourne à droite et avance de 10 cm
* 10 : Tourne à gauche et avance de 10 cm
* 11 : Recule de 10 cm.

 

Pour utiliser le protocole Bluetooth, on utilise le module série Bluetooth v3.01 . Pour utiliser le protocole Bluetooth, on utilise des commandes AT pour initialiser la communication entre le maitre (Robot 1) et l'esclave (Robot 2 et 3). Voici le code pour initier la connexion :

 

Code Maitre :
<pre>
Serial3.begin(9600);

Serial3.print("AT");
delay(400);

Serial3.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial3.print("AT+NAMESeeedMaster"); // set the bluetooth name as "SeeedMaster" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial3.print("AT+ROLEM"); // set the bluetooth work in slave mode
delay(400);

Serial3.print("AT+AUTH1");
delay(400);

Serial3.print("AT+CLEAR"); // Clear connected device mac address
delay(400);

Serial3.flush();
//wait 1s and flush the serial buffer
delay(1000);
Serial3.flush();

</pre>

 

Code Esclave :

<pre>
Serial1.begin(9600);
Serial1.print("AT");
delay(400);

Serial1.print("AT+DEFAULT"); // Restore all setup value to factory setup
delay(2000);

Serial1.print("AT+NAMESeeedBTSlave"); // set the bluetooth name as "SeeedBTSlave" ,the length of bluetooth name must less than 12 characters.
delay(400);

Serial1.print("AT+PIN0000"); // set the pair code to connect
delay(400);

Serial1.print("AT+AUTH1");
delay(400);

Serial1.flush();
</pre>

Robots jardiniers

2023-04-07T07:30:22Z

Emilie cnvt : /* Robot 2 */

Robots jardiniers

2023-04-07T07:24:25Z

Emilie cnvt : /* Robot 2 */

Robots jardiniers

2023-04-07T07:23:50Z

Emilie cnvt : /* Robot 1 */

Robots jardiniers

2023-04-07T07:23:31Z

Emilie cnvt : /* Programmation des cartes */

Robots jardiniers

2023-04-07T07:12:13Z

Emilie cnvt : /* Robot 1 */

Robots jardiniers

2023-04-07T07:11:12Z

Emilie cnvt : /* Choix des cartes */

Robots jardiniers

2023-04-07T07:02:21Z

Emilie cnvt :

Robots jardiniers

2023-04-05T16:05:25Z

Emilie cnvt : /* Capteur Gouttes de pluie */

Robots jardiniers

2023-04-05T16:05:13Z

Emilie cnvt : /* Choix des capteurs */

Robots jardiniers

2023-04-05T16:03:29Z

Emilie cnvt :