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'un pile de 12V relié au convertisseur.
2. Les moteurs fonctionnent jusqu'à un maximum de 7.2V, ils consomment chacun 500mA

• 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 12V. 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.
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 :

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

   - st pour stopper tous les moteurs

6. Tester les mouvements entiers :

   • Robot 4 moteurs :

   - avd pour faire avancer le robot tout droit

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

   - gh 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
Arrière	ard
Déplacement à droite	dr
Déplacement à gauche	ga
Rotation à droite	rd
Rotation à gauche	rg

Odométrie robot maître

Utilisation d'une centrale à inertie pour le calcul du déplacement effectué par le robot maître : Pololu AltIMU-10 v4. Cette centrale à inertie est composée des gyroscopes L3GD20H, des accéléromètres/magnétomètres LSM303D et un baromètre LPS25H. La communication se fait en I2C.

Le reste de la documentation est disponible sur le site du composant.

Programmation carte Raspberry Pi 3

La première étape consiste à installer un système d'exploitation sur la Raspberry Pi 3 :

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

Tests de la caméra et essais initiaux :

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. Premier tests en local avec : raspistill -o photo.jpg (enregistrement d’une photo avec retardateur de 5sec), puis raspivid -o video.h264 (enregistre une 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/

Lancer le stream et serveur web via mjpg streamer :

mkdir /tmp/stream (raspistill --nopreview -w 640 -h 480 -q 5 -o /tmp/stream/pic.jpg -tl 100 -t 9999999 -th 0:0:0 &) raspivid -t 0 -n --width 1280 --height 720 -o - | cvlc stream:///dev/stdin --sout '#standard{access=http,mux=ts,dst=:8090}' :demux=h264

LD_LIBRARY_PATH=/usr/local/lib mjpg_streamer -i "input_file.so -f /tmp/stream -n pic.jpg" -o "output_http.so -w /usr/local/www"

Premiers résultats :

streaming de la caméra sur un PC connecté au même réseau wifi

Ensuite pour diffuser la vidéo sur une page web, nous avons utilisé MJPG-Streamer. Il a été installé grâce à une archive zip. Pour démarrer la caméra, nous avons utilisé la commande suivante: raspistill --nopreview -w 640 -h 480 -q 5 -o /tmp/stream/pic.jpg -tl 100 -t 9999999 -th 0:0:0 & Pour lancer le stream: LD_LIBRARY_PATH=/usr/local/lib mjpg_streamer -i "input_file.so -f /tmp/stream -n pic.jpg" -o "output_http.so -w /usr/local/www" Nous avons modifié la page html index.html pour créer une page web avec seulement la caméra et les 4 boutons (avancer, reculer, tourner à gauche et à droite). Pour la gestion de l'appui sur les boutons, nous avons d'abord penser utiliser Un serveur node.js a été installé pour télécommander le robot depuis la page web grâce à la caméra. [[Fichier:Sortie-uart.png|200px|thumb|left]

Interface Web

Principe de fonctionnement

Afin de télépiloter le robot maitre, nous utilisons une interface homme-machine via une page web. Cette page web est en ‘’JS’’, servie par un serveur ‘’NodeJS’’. Le serveur et le client communiquent à l’aide d’une connexion socket.

Le flux vidéo est fourni par un serveur ‘’mjpeg 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.

bouttonForward.onclick = function () {

   socket.emit("forward", true);
   console.log("bouton forward appuyé");

};

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. Alors, il envoie un message console de debug et un message sur la communication série choisie

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 ‘’mjpeg’’

Exécuter 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, les radiations sont 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:

Tableau récapitulatif

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