Robots pompiers

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 ;
• 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 demandés...
• utilisation des outils et notamment mise à jour du Wiki ;
• présentation + démonstration technique finale du projet ;
• examen écrit (QCM, sans document) - jeudi 12 mai ;

Outils à utiliser

1. wiki : explication et documentation du projet ;
2. projet GitLab (serveur de TSE) : sauvegarde et suivi de version des différents code ;
3. ToDoList avec les missions de chaque étudiant, au fur et à mesure des séances ;

Missions des robots pompiers

Les robots pompiers 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 : taux de CO₂, température, rayonnement UV...
4. si détection de paramètres anormaux, 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 ;

En fonction de l'avancée du projet, d'autres types d'action pourront être ajoutés.

Décomposition initiale du travail

Première partie :

1. S'approprier les plateformes (Maître et esclave) : batteries, test moteurs, communication UART entre PC et Teensy
2. Programmation Raspberry + Caméra
3. Définir précisément quels capteurs utiliser (en fonction du matériel mis à disposition)

Prise en main des plateformes

Alimentation

• Le robot maitre :

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 étant 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. Elle est connectée au PCB à l'aide du connecteur d'alimentation situé dans l'angle inférieur gauche.

Les deux parties sont séparées sur le PCB à l'aide du cavalier placé du côté du coté du connecteur d'alimentation.

Programmation des cartes

• ESP32 :

- Ajouter le support de la carte dans l'IDE Arduino en insérant ce lien dans Fichier → Préférences → URL de gestionnaire de carte supplémentaire : https://dl.espressif.com/dl/package_esp32_index.json

- Dans Outils → Type de carte → Gestionnaire de cartes, rechercher et installer ESP32

- Dans Outils → Type de carte sélectionner la carte ESP32

• Teensy :

- Installer le support de la carte dans l'IDE Arduino via ce lien

Déplacement du robot

• Pour gérer le déplacement via le terminal on a utilisé le code pour une plateforme holonome 4 moteurs.
• Procédure de test de la chaine d'alimentation, contrôle et asservissement :

1. Téléverser ce code fourni sur la carte teensy. La pleine vitesse citée plus tard est définie par paramVitesse dans les paramètres globaux en début de code.
2. Téléverser un programme vide dans l'ESP32 thing
3. Connecter les pin RX de la teensy sur le pin RX de l'ESP32, respectivement pour TX. En effet, les deux cartes sont branchées en parallèle, la carte ESP32 étant logiquement transparente, elle nous permet simplement d'envoyer des commandes série sur la teensy
4. Connecter un pc à la carte ESP32 via le port micro USB
5. Ouvrir une console série (par exemple la série arduino) sur le port concerné et tester les moteurs avec les commandes suivantes :

   - av1 pour démarrer le moteur 1 à pleine vitesse, (resp. av2, ...)

   - am1 pour démarrer le moteur 1 à demi vitesse, (resp. am2, ...)

   - st pour stopper tous les moteurs

6. Tester les mouvements entiers :

   • Robot 4 moteurs :

   - avd pour faire avancer le robot tout droit à pleine vitesse

   - amd pour faire avancer le robot tout droit à demi vitesse

   - rd pour faire tourner le robot sur lui même dans le sens horaire

   - rg pour faire tourner le robot sur lui même dans le sens trigo

   • Robot 3 moteurs :

   - amXXX pour définir la direction XXX (en degrés) de déplacement du robot

   - ho3 pour avancer dans la direction définie précédemment

Synthèse des commandes pour communiquer à la teensy via l'uart :

	Commande
Stop	st
Avant	avd
Avant à demi vitesse	amd
Arrière	ard
Rotation à droite	rd
Rotation à gauche	rg

Odométrie robot maître

On utilise deux informations couplées : calcul de la position depuis les capteurs des moteurs et en parallèle un accéléromètre et un gyroscope contenus dans la centrale à inertie.

Utilisation d'une centrale à inertie pour le calcul du déplacement effectué par le robot maître : MPU9250 10dof. Cette centrale à inertie est composée d'un gyroscope, d'un accéléromètre, d'un magnétomètre et d'un baromètre. La communication se fait en I2C.

Le reste de la documentation est disponible sur https://cdn.sparkfun.com/assets/learn_tutorials/5/5/0/MPU-9250-Register-Map.pdf.

Programmation carte Raspberry Pi 3

Installation d'un système d'exploitation

1. Téléchargement de l’image sur le site de Raspbian
2. Utilisation de Balenaetcher pour flasher l’image sur la carte S
3. Premier boot du Raspberry Pi : configuration initiale

Utilisation de la caméra

1. Si la liaison de la Raspbery avec un écran en hdmi ne se fait pas, il faut modifier le fichier config.txt (hdmi_group et hdmi_mode) de la carte micro SD de la Raspberry, pour forcer l'envoi sur le port hdmi même si rien n'est détecté à l'autre bout du câble.
2. Mettre à jour le système et activer la caméra avec le menu "Configuration du Raspberry Pi"
3. Premiers tests en local avec : raspistill -o photo.jpg (enregistrement d’une photo avec retardateur de 5sec), puis raspivid -o video.h264 vidéo)
4. Premier stream avec : raspivid -o - -t 0 -w 800 -h 600 -fps 12 | cvlc -vvv stream:///dev/stdin --sout '#rtp{sdp=rtsp://:8080/}' :demux=h264 sur Raspberry, et avec VLC sur PC : menu Ouvrir un flux réseau, y mettre : rtsp://@IPpi:8080/
   

   streaming de la caméra sur un PC connecté au même réseau wifi
5. Installation de Mjpg-Streamer :

sudo apt-get install libjpeg9-dev
git clone https://github.com/jacksonliam/mjpg-streamer.git

sudo apt-get install cmake
CFLAGS+="-Ofast -mfpu=vfp -mfloat-abi=hard -march=armv6zk -mtune=arm1176jzf-s" make
sudo make install
cd ~/mjpg-streamer/mjpg-streamer/mjpg-streamer-experimental./mjpg_streamer -i "./input_uvc.so -f 15" -o "./output_http.so -w ./www"

• Lancement du serveur Mjpg Streamer sur le port 8080

cd ~/mjpg-streamer/mjpg-streamer/mjpg-streamer-experimental
./mjpg_streamer -i "./input_uvc.so -f 15" -o "./output_http.so -w ./www"

Utilisation du port série

Il est nécessaire d'activer et d'accorder les droits d'accès au port série :

sudo chmod 666 /dev/ttyS0
raspi-config > Interface options > Serial Port > Enable

Choix de l'environnement serveur

Pour la gestion back sur le Raspberry, nous avons d'abord penser utiliser un programme C++ proche du matériel et de la série. Cependant, la gestion web était alors largement compliquée. Nous avons retenu d'utilisation d'un serveur node.js pour servir la page web et transmettre les commandes d'avancement comme les remontées d'alertes.

Interface Web

Principe de fonctionnement

Afin de télépiloter le robot maitre, nous utilisons une interface homme-machine via une page web. Le serveur et le client communiquent à l’aide d’une connexion socket.

Le flux vidéo est fourni par un serveur mjpg streamer, indépendant du serveur NodeJS.

Front

La page web servie est en html, et contient un script JS. D’une part, le retour caméra est incrusté à l’aide de la simple ligne suivante :

<img width="320" height="240" src="http://192.168.246.107:8080/?action=stream">


Au clic d’un bouton, il émet un évènement sur le socket. S'il reçoit un message d'alerte sur le socket, il modifie en conséquence la couleur de l'alerte correspondante

Back

Le serveur web est en NodeJS. Outre servir la page web aux clients qui se connecte, il reçoit les évènements par le socket ouvert avec chacun d’eux. Il les transmet sur le port série. Lorsqu'il commence à recevoir des données d'alerte sur le port série, il envoie un message pour afficher l'alerte sur le client

Dans les deux cas, des timers sont déclenchés pour stopper le robot ou le déclanchement des alertes en cas de déconnexion WiFi

Nous avons utilisé la bibliothèque NodeJS SerialPort pour la gestion des entrées/sorties sur la série

Installation du serveur

Dans un terminal du Raspberry, exécuter à l’emplacement des fichiers du serveur : npm i

Lancement du serveur

• Exécuter ToDo pour lancer le serveur mjpg streamer

• Exécuter sudo node server.js pour lancer le serveur web

Choix des capteurs

Capteur de température

Étude de la diffusion de la température en cas d'incendie

Lors d'un incendie, le rayonnement est la principale source de transmission de la chaleur. Un tableau fournit par le ministère permet d'estimer la densité de flux thermique radiatif en fonction de la distance à la flamme:

On utilise ensuite la loi de Stéphan afin de déterminer la température:

A l'aide d'Excel, on obtient les résultats suivants:

Choix du capteur

Nous avons choisi le capteur AOSONG AM2302 qui permet de mesurer la température ainsi que le taux d'humidité de l'air, fonction dont on ne servira pas. Ce capteur permet de mesurer des températures de -40°C à 80°C.

D'après le modèle:

On n’a que 4 points donc on est peu précis mais on obtient un ordre de grandeur de l’ordre de 23m -27m pour ressentir 80°C en cas d’incendie, le choix d’un capteur mesurant jusqu’à une température de 80°C est donc cohérent avec le cas d’étude. Détecter un incendie environ 25m avant de l’atteindre dans un bâtiment est acceptable pour un robot, sachant qu’on a en plus des capteurs pour le gaz et la fumée (MQ9 et MQ135). On a une température de 60°C à 30m du feu environ (ça chute vite). On placera un seuil d'alerte à 60°C pour détecter les potentiels feux (le robot serait à une distance théorique de 30m du feu ce qui semble correct et réaliste).

ATTENTION : On ne prend pas en compte la convexion et la conduction, on a seulement le rayonnement dans ce modèle simplifié. On aura donc une température un peu plus élevée dans la réalité.

Capteur UV

Pour mesurer l'indice UV, nous avons considéré le capteur SI1145 qui fonctionne par I²C, nous l'avions testé et était fonctionnel. Malheureusement lors d'un autre essai, son alimentation et sa masse ont été malencontreusement inversés ce qui a rendu le capteur hors service. Nous avons donc redirigé notre choix vers les UV sensor Grove v1.1 qui ne fonctionnent pas en I²C mais à l'aide de 3 fils (GND, VCC, Signal). Il fournit des valeurs d'UV cohérentes lors de nos tests (indice UV entre 2 et 3). Nous placerons le seuil d'alerte à 6 pour prévenir d'un risque élevé.

Capteur de gaz toxiques

Choix du capteur

Nous avons choisi le capteur MQ9 qui est un capteur coûtant peu cher et offrant une performance acceptable à condition de l'avoir préchauffé avant utilisation. Il permet de mesurer la concentration en CO (gaz carbonique) afin de permettre au robot maitre de prévenir un danger d'intoxication au gaz carbonique. Il permet également de mesurer la concentration en CH4 afin de pouvoir détecter de potentielles fuites de gaz.

Il fonctionne à l'aide de 3 fils (GND, VCC, Signal).

La concentration en CH4 devient dangereuse à partir de 50 000 ppm (limite d’explosivité), mais une concentration au-delà de 1000 ppm (500 fois supérieure à ce que l'on trouve pour un air pur) ne laisse aucun doute quand à une fuite de gaz. On placera donc la limite à 1000 ppm.

Pour le CO, on placera la limite à 200 ppm, stade à partir duquel une exposition de deux ou trois heures provoque des maux de têtes (--> besoin de vigilance). Le capteur MQ9 permet de mesurer le CO de 10 ppm à 1000 ppm, et le CH4 de 100 ppm à 10 000 ppm donc il convient pour notre projet.

Étalonnage du capteur

La datasheet permet d'étalonner le capteur, à l'aide d'Excel on détermine une courbe de tendance à utiliser pour obtenir nos valeurs.

Note: Rs est la valeur renvoyée par le capteur, R0 est déterminée grâce à la datasheet, et les courbes étalons fournies servent à retrouver les concentrations en ppm des différents gaz.

Capteur de CO2

Le CO2 présente également des dangers pour les personnes, ainsi on équipe le robot d'un capteur de CO2 pour détecter d'éventuels problèmes, les seuils de danger du CO2 sont les suivants:

On va donc placer une alerte à 2000 ppm pour le CO2. Nous avions initialement choisi le capteur XENSIV PAS CO2 qui correspondait à ces critères (mesure le CO2 entre 0 ppm et 32 000 ppm), mais son prix a soudainement grimpé pour des raisons d'approvisionnement. Nous nous sommes donc rabattus sur un autre modèle: le CCS811 qui permet de mesurer le taux de CO2 pour des valeurs comprises en 400 ppm et 8192 ppm (il donne pour résultat 400 ppm par défaut pour les valeurs inférieures ou égales à 400 ppm).

Télémètres

Le robot maitre étant dirigé par caméra, on ne l'équipera que d'un télémètre pour assister le pilote lors de la détection d'obstacles frontaux. Les robots esclaves eux vont être équipés de télémètres pour pouvoir détecter les obstacles dans leur direction de mouvement. Pour le robot maitre, on met une alerte en place pour un obstacle détecté à 20 cm du robot et on bloque le robot si il se trouve à 10 cm de l'obstacle et qu'il souhaite se déplacer vers l'obstacle. Pour le robot esclave, on force le robot esclave à changer de trajectoire 15 cm avant l'obstacle afin de lui laisser le temps d'éviter la collision.

SRF

Dans la série des télémètres SRF, on a à notre disposition les modèles SRF08, SRF10 et SRF04. Les modèles SRF08 et SRF10 fonctionnent à l'aide l'I²C, le modèle SRF04 lui fonctionne par voie analogique à l'aide de 4 fils (echo, trigger, GND, supply). SRF08 peut détecter les objets jusqu'à 6m avec un angle de détection de 55°, le SRF10 peut détecter les objets jusqu'à 6m avec un angle de détection de 72°, le SRF04 peut détecter les objets jusqu'à 3m avec un angle de détection de 30°. La distance minimale de détection des 3 capteurs est de 3 cm. Ces 3 capteurs conviennent à notre utilisation.

US-020

C'est un capteur qui fonctionne avec 4 fils (echo, trigger, gnd, alim), son angle de détection est de 15°, il permet de mesurer les obstacles entre 2cm et 7m. L'angle de détection est plutôt faible mais il pourrait servir sur les robots esclaves pour surveiller les angles du robot.

VMA360

C'est un capteur qui fonctionne avec 4 fils (echo, trigger, gnd, alim), il a un angle de détection de 15°, il permet de mesurer les obstacles entre 2cm et 4,5m. L'angle de détection est plutôt faible mais il pourrait servir sur les esclaves pour surveiller les angles du robot.

Tableau récapitulatif

On estime possible d'alimenter tous ces capteurs avec les batteries prévues au vu des courants d'alimentation qu'elles fournissent.

Librairies Arduino

Nous avons dû installer des librairies Arduino pour faire fonctionner les capteurs : "DFRobot_CCS811" pour le capteur de CO2 CCS811; "DHT Sensor Library" pour le capteur de température; "Adafruit Circuit Playground" et "Adafruit Unified Sensor" pour les capteurs d'Adafruit.

Il faut également avoir installé une librairie dans le gestionnaire de cartes pour pouvoir utiliser l'ESP32 thing (carte utilisée pour les capteurs). Lien du site officiel pour réaliser cette manipulation: https://learn.sparkfun.com/tutorials/esp32-thing-hookup-guide.

Code informatique

Robot maitre

Communication entre la Raspberry et l'ESP32

Dans le sens Raspberry vers ESP32

Synthèse des commandes pour communiquer de la Raspberry vers l'ESP32 :

	Commande
Stop	st
Avancer	av
Arrière	ar
Déplacement à droite	dr
Déplacement à gauche	ga
Rotation à droite	rd
Rotation à gauche	rg

Dans le sens ESP32 vers Raspberry

Synthèse des commandes pour communiquer les alertes de l'ESP32 vers la Raspberry :

	Alerte
CO	C1
CO2	C2
CH4	C4
Température Haute	TH
UV	UV
Distance à l'avant du robot	DA
Erreur : en cas de commande av non exécutée car distance avant trop faible	er

Notes tableaux J101

Sauvegarde des notes des tableaux de la J101 le 7 avril 2022.

Tableau 5

Tableau 4

Tableau 3

Tableau 2

Tableau 1