Robots jardiniers

Missions des robots jardiniers

Les robots jardiniers devront réaliser les actions suivantes :

1. départ de la base du robot 1 ;
2. exploration de l'environnement en évitant les obstacles ;
3. évaluation des paramètres environnementaux : lumière, UV, température, humidité, humidité du sol\ldots
4. si détection de paramètres propices, communication vers les robots 2 et 3 ;
5. cheminement des robots 2 et 3 jusqu'au point de sinistre, à partir des informations fournies par le robot 1 ;
6. 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é:

chemin normal du robot

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

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

Simulation

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

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"

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 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"

Ce capteur nous retournera un signal en mV qui nous permettra via un rapide programme présent dans la 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". 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

Prise du capteur d'humidité du sol dans un sol sec

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

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 :

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

1. 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.
2. 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) : Documentation du moteur

• Les robots esclaves ont deux sources d'alimentation :

1. 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.
2. 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 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). 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.

Voici le code pour initier la connexion :

Code Maitre : (ici sous arduino UNO)

  #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");
}

Voici les réponses aux commandes AT :

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

  #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");
}