Sous-marin Télécommandé

Introduction: Sous-marin Télécommandé

Introduction

Un sous-marin télécommandé entièrement fait maison ? C'est le pari que nous nous sommes lancé en concevant ce ROV subaquatique.

Le challenge est de taille car en plus de devoir résister à la pression et être étanche, le sous-marin promet aussi d'être autonome en énergie, d'assurer une plongée jusqu'à 5m de profondeur au moyen d'un système de ballasts, d'explorer les milieux aquatiques en direct grâce à sa caméra et ses deux moteurs brushless lui permettant de manœuvrer même dans les endroits les plus accidentés et tout ça en le contrôlant depuis son ordinateur via une interface didactique et intuitive.

Description fonctionnelle des besoins

Besoins fonctionnels

  1. Un système de ballasts est utilisé pour faire varier la profondeur de plongée
    Lorsque l'utilisateur souhaite faire plonger/remonter le sous-marin, les ballasts se remplissent/vident et le robot plonge/remonte jusqu'à recevoir une commande contraire.

  2. L'avance du moteur est contrôlée par deux moteurs brushless

  3. Les moteurs brushless permettent au sous-marin de tourner (en augmentant/diminuant la vitesse de l'un par rapport à l'autre)

  4. Le sonar permet de calculer à tout moment la distance avec le fond

  5. La mesure de pression permet de connaître à tout moment la profondeur du sous-marin

  6. Si le capteur d'eau situé en fond de cale détecte de l'eau, le sous-marin interrompt toute manœuvre et effectue une remontée d'urgence pour être entretenu

  7. Le sous-marin doit être en mesure de rester stable et ne pas se retourner
    Il détecte la déviation grâce à un accéléromètre et remplit/vide un ballast par rapport à l'autre pour s'équilibrer.

  8. Visualiser un streaming vidéo en direct sur l'interface Node-RED de la Raspberry

Contraintes

  • La coque du prototype sera réalisée en impression 3D et étanchéifiée grâce à de la colle époxy et de la fibre de verre

  • Le prototype devra pouvoir s'éloigner d'une distance de 5m de l'utilisateur et atteindre une profondeur de 5m

  • Le prototype devra se mouvoir à une vitesse de croisière de minimum 1 nœud

  • Le flux vidéo devra offrir une qualité vidéo de 8MP à 30FPS minimum

  • Le prototype devra être autonome en énergie et assurer un fonctionnement de 15min

  • Le prototype utilise la technologie ROS

  • Le prototype doit être contrôlé à distance depuis une interface Node-RED

Un cahier des charges plus complet se trouve en pièce jointe.

Planning

Du 3 février 2020 au 15 mai 2020

Budget

~400€

Step 1: Composants, Matériel & Ressources

Composants

  • Accéléromètre ADXL345
  • Amplificateur INA126P
  • Arduino Uno
  • Batterie Lipo 3300mAh 3C
  • Batterie portable 30000mAh
  • Boitier de refroidissement pour Raspberry Pi 3
  • Borniers électroniques (4)
  • Bulle en verre ø60m
  • Câble RJ45 5m
  • Caméra Raspberry V2
  • Capteurs de fin de course (4)
  • Capteur de pression MPX5050
  • Connecteurs ESC 2.54mm (2)
  • Connecteur RJ45
  • Connecteurs XT60 (3)
  • Dôme en verre ø60mm
  • ESC (2)
  • Fibre de verre
  • Fusible (5A)
  • Interrupteur
  • Joints câble (2)
  • Joints étanches (2)
  • Led
  • Lest (~8kg)
  • Moteurs brushless (2)
  • Moteurs + vis sans fin (2)
  • Pont en H L298N
  • Port USB femelle
  • Raspberry Pi 3
  • Répétiteur Wi-Fi TL-WR902AC
  • Résine époxy
  • Résistances
    • 2.7M Ohms (1)
    • 1M Ohm (1)
  • Roulements à billes 4x13x5mm (2)
  • Seringues 55ml (2)
  • Sonar
  • Tube flexible en silicone ø5mm (30cm)
  • Visserie (boulons, entretoises, vis, ...) M3 et autres

Les références des composants particuliers et les liens de commande sont dispobibles en consultant le document ci-joint.

Matériel

  • Câble HDMI
  • Chargeur de batterie Lipo
  • Clavier
  • Ecran
  • Fer à souder
  • Imprimante 3D
  • Ordinateur
  • Pompe à vélo + pipette
  • Pince à sertir câble réseau
  • Pistolet à colle
  • Souris

Softwares

  • Arduino
  • Fusion 360
  • Node-RED
  • PuTTy
  • Raspbian (ou autre version de Linux)

Step 2: Ballasts

Électronique et mécanique

Les ballasts présents dans le sous-marin sont conçus de la manière suivante :

Deux seringues sont situées à l'intérieur du sous-marin, une de chaque côté. Un tube flexible en silicone relie la sortie des seringues à l'extérieur du sous-marin et est plongé dans l'eau. Chaque seringue est équipée d’un moteur DC monté sur une vis sans fin, placé en parallèle à celle-ci. Un boulon auquel on colle le haut du piston de la seringue est capable de se déplacer le long de la seringue. En ouvrant/fermant la seringue, elle se remplit/vide d’eau, permettant au sous-marin de plonger ou de remonter. En effet, en se remplissant d'eau, sa masse augmente et il plonge.

Le driver moteur peut générer des signaux directs ou inverses pour chaque moteur DC afin de faire tourner la vis dans les 2 sens.

Pour la stabilité de la vis sans fin et également pour fixer le capteur de fin de course du haut (voir photo), un support est fixé à l’aide de deux tiges M3. Un roulement à bille est également ajouté pour une bonne fluidité de mouvement.

Afin de pouvoir régler avec précision la position limite du piston, il y a deux vis M3 qui viennent percuter le capteur de fin de course en fonction de leur hauteur.

Branchements

Pour les branchements nous avons utilisé des borniers à visser pour pouvoir facilement faire les connexions avec les autres parties du sous-marin. Les capteurs de fin de course permettent une ouverture mécanique du circuit et assurent donc que les moteurs DC n'ouvrent ou ne ferment pas les seringues au-delà d'un seuil qui pourrait endommager le montage. Si besoin, nous pourrions également connecter la troisième borne des capteurs de fin de course sur des pins d’interruption de l'Arduino pour pouvoir détecter les zones limites du piston.

Pour fonctionner, le ballast a donc besoin de trois pins, une PWM pour la vitesse, et deux pins de valeur opposée pour le sens de rotation.

Le schéma de branchement est disponible ci-dessus.

Arduino

Le principe du code Arduino est de recevoir une commande permettant de contrôler en temps et en vitesse les différents moteurs du sous-marin et cela grâce au protocole sur le schéma du step "Propulseurs".

La boucle appelle ensuite la fonction de propulseurs suivante :

Paramètres :

  • Vitesse : 0 à 180

Exemple d’utilisation :

propulseur_Fonction(180,90);

Cette fonction met à jour le timer pour la durée de fonctionnement des propulseurs. Elle met le propulseurs droit à vitesse maximale et le propulseur gauche à 50%. L'effet est l'avance du sous-marin en tournant vers la gauche

La fonction suivante permet de tester si la durée de fonctionnement des moteurs est écoulée.

checkMotorDelay()

Cette fonction est appelée à chaque loop. Le code Arduino ci-joint permet de tester la commande des propulseurs ou des ballasts en envoyant les commandes par communication série.

La fonction suivante permet de contrôler les ballasts :

decodeCommand()

Elle implémente le protocole de communication de contrôle des moteurs (ballasts et propulseurs), décode la commande reçue dans le string « cmd » et appelle les fonctions de contrôle des ballasts ou propulseurs.

Elle contrôle le système de ballasts sur base de la valeur de vitesse et de sens de rotation reçue en paramètre pour chaque ballast (droit ou gauche) et met à jour les timers utilisés pour la durée de fonctionnement des moteurs.

Exemple d’utilisation :
Dans la loop si une trame ‘’B25510025510011’’ arrive alors flagCmd == 1. Par conséquent, decodeCommand() est appelée et va déclencher l’activation des ballasts.

Les paramètres extraits sont les suivants :

  • B pour la commande sur les ballasts
  • Vitesse moteur droit = 255
  • Temps moteur droit = 100 décisecondes (10 secondes)
  • Vitesse moteur gauche = 255
  • Temps moteur gauche = 100 décisecondes (10 secondes)
  • Les deux derniers caractères 11 indique qu'on vide les ballasts (22 pour les remplir)

La boucle va ensuite appeler la fonction de ballasts suivante :

Ballast_fonction(255, '1', 255, '1');

Dans cet exemple, les ballasts sont activés à vitesse maximum et se vident en tournant dans le sens horlogique. Le sous-marin remonte donc à la surface.

La fonction suivante permet de tester si la durée de fonctionnement des moteurs est écoulée. Cette fonction est appelée à chaque loop.

checkMotorDelay()

Le code qui permet de tester les ballasts est disponible dans la prochaine étape. Le code de contrôle des propulseurs lui sera ajouté. Ce code implémente donc le protocole de communication pour commander les ballasts et propulseurs.

Step 3: Propulseurs

Arduino

Le principe du code Arduino est de recevoir une commande permettant de contrôler en temps et en vitesse les différents moteurs du sous-marin et cela grâce au protocole sur le schéma ci-dessus.

La fonction ci-dessous permet d'extraire les données de notre trame contenant les différents paramètres :

decodeCommand()

Elle implémente le protocole de communication de contrôle des moteurs (ballasts et propulseurs), décode la commande reçue dans le string « cmd » et appelle les fonctions de contrôle des ballasts ou propulseurs.

Exemple d’utilisation :

Dans la loop si une trame ‘’P18010009010000’’ arrive alors flagCmd == 1

Par conséquent, decodeCommand() est appelée et va déclencher l’activation des propulseurs. Les paramètres qu'elles va extraire sont les suivants :

  • 'P' pour la commande sur les propulseurs
  • Vitesse moteur droit = 180
  • Temps moteur droit = 100 décisecondes (10 secondes)
  • Vitesse moteur gauche = 90
  • Temps moteur gauche = 100 décisecondes (10 )
  • Les deux derniers caractères correspondent aux sens (0,1,2) utilisé dans le cas d'une commande des ballasts (voir step Ballasts)

La boucle va ensuite appeler la fonction de propulseurs suivante :

Paramètres :

  • Vitesse : 0 à 180

Exemple d’utilisation :

propulseur_Fonction(180,90);

Cette fonction met à jour le timer pour la durée de fonctionnement des propulseurs. Elle mets le propulseurs droit à vitesse maximale et le propulseur gauche à 50% de la vitesse max. L'effet est l'avance du sous-marin en tournant vers la gauche

La fonction suivante permet de tester si la durée de fonctionnement des moteurs est écoulée. Cette fonction est appelée à chaque loop.

checkMotorDelay()

Le code Arduino ci-joint permet de tester la commande des propulseurs ou des ballasts en envoyant les commandes par communication série.

Mécanique

Les propulseurs du sous-marin sont réalisés avec des moteurs brushless auxquels une hélice, réalisée en impression 3D, a été fixée. Ces propulseurs sont encerclés par une structure les protégeant d'éventuel(s) impact(s) et sont positionnés sur les flancs du sous-marin, à l'extérieur. Les moteurs brushless sont pilotés en vitesse par des ESC.

Branchements

Pour brancher l'ESC, on connecte chacun des trois câbles à une phase du moteur et le connecteur XT60 à la batterie (ou sur le shield). Parmi les trois câbles de signaux, deux sont connectés sur l'Arduino et un pour alimenter le Raspberry (le rouge).

Les propulseurs se branchent à l'Arduino de la manière suivante :

1. Brancher l'ESC du propulseur droit

  • Signal jaune ESC → Pin 9 Arduino
  • Signal noir ESC → GND Arduino

2. Brancher les 3 signaux de sorties de l'ESC aux 3 signaux d’entrés du propulseur droit

3. Alimenter les ESC avec la batterie (voir step Batterie) ou une source équivalente à 14.8V

La même opération est nécessaire pour les ESC du propulseurs gauche avec les pins suivantes :

  • Signal jaune ESC → Pin 5 Arduino
  • Signal noir ESC → GND Arduino

Étanchéification

Pour étanchéifier les propulseurs nous avons d'abord recouvert l'intégralité des pièces imprimées en 3D de résine époxy. Puis nous les avons peintes. Après avoir placé le moteur (naturellement waterproof) et rallongé la longueur de ses câbles, nous les avons placé dans l'orifice prévu à cet effet et rempli l’intérieur de résine.

Step 4: Sonar

Le sonar a pour objectif de détecter la présence d’obstacle en dessous du sous-marin en mesurant la distance entre lui et l’objet détecté.

Électronique

Les pins du sonar sont connectése à l’Arduino de la manière suivante :

  • 5V → 5V
  • GND → GND
  • ECHO → Pin 10
  • TRIGGER → Pin 11

Arduino

Le code Arduino ci-joint permet de relever une distance en centimètres et de la visualiser sur un terminal série. Il comprend une fonction de filtre faisant 4 mesures successives et comparant la 1ère avec les 3 suivantes. Les mesures suivant la première sont rejetées si celles-ci s’écartent trop de la distance initialement obtenue.

La distance finale mesurée est calculée sur base de la moyenne des 3 dernières mesures (ou moins si celle-ci sont rejetées).

Ce filtre est implémenté par sécurité afin qu'une mesure erronée ne soit pas intempestive pour l'utilisation du sous-marin.

Voir code en pièce jointe.

Step 5: Capteur De Pression

Le transducteur piézorésistif Mpx5050 est le capteur de pression que nous avons choisi. Celui-ci peut mesurer des valeurs de pressions jusqu’à 50kPa, permettant donc à notre sous-marin de descendre jusqu’à 5 mètres de profondeur.

Rôle du capteur de pression

Le rôle du capteur de pression est très important car il nous permet de savoir à quelle profondeur le sous-marin se trouve. En effet la pression sous l’eau augmente de 10kPa tous les mètres. En connaissant la valeur de cette pression nous sommes donc en mesure de connaitre exactement la profondeur à laquelle le sous-marin se trouve.

Récupérer et traiter les données

Il fournit en fait un signal de sortie analogique précis et de haut niveau proportionnel à la pression appliquée. Nous avons cependant tout de même amplifié ce signal analogique car l'échelle de variation analogique était très petite malgré une résolution très grande. En d'autres termes le niveau de tension en sortie du capteur ne varie pas beaucoup mais de manière précise. L'amplificateur utilisé fut le INA126P utilisé avec une résistance de 674 Ohms et il permit donc d'avoir une range analogique plus adéquate.

Calibration

Nous avons par après calibré la conversion de ce signal analogique en un signal digital pour pouvoir connaître la pression. Le code est aussi présent ci-dessous. Pour cette calibration nous avons utilisé un appareil de laboratoire qui permet d'exercer une pression connue sur le capteur et pris plusieurs mesures nous permettant de connaître quelle valeur analogique correspond à quel niveau de pression. Nous avons évidemment dû prendre la pression atmosphérique en compte.

La valeur reçue est ensuite envoyée par ROS où elle est traitée sur la Raspberry.

Step 6: Capteur D'eau

L'eau étant conductrice d'électricité, un courant se crée donc entre les deux pins du capteur lorsque celles-ci sont immergées. En effet, l'eau agit comme un interrupteur qui ferme le circuit jusque-là ouvert.

Le capteur étant positionné en fond de cale, lorsqu'il détecte une infiltration d'eau, le sous-marin reçoit l'ordre d'interrompre toutes ses manœuvres et de remonter à la surface.

NB : Notre capteur étant "fait main", l'illustration ci-dessus ne représente pas strictement le capteur que nous avons utilisé. En effet notre capteur a simplement été réalisé grâce à deux bouts de fil de cuivre placés parallèlement à 2mm d'écart tout en s'assurant qu'ils ne se touchent pas.

Électronique

  • Une pin est connectée au 5V de l'Arduino
  • L'autre est connectée à la pin A0 de l'Arduino

Arduino

Voir code en pièce jointe.

Step 7: Accéléromètre

L'accéléromètre nous permet de contrôler la déviation du sous-marin et donc de réguler le roulis et de l'équilibrer à chaque instant en remplissant/vidant automatiquement un ballast par rapport à l'autre.

Électronique

Les pins de l'accéléromètre doivent être connectées aux pins de l'Arduino de la manière suivante :

  • 5V → 5V
  • GND → GND
  • SDA → A5
  • SCL → A4

Le capteur est capable de déterminer la déviation par rapport au 3 axes (X, Y et Z) mais nous ne sommes dans ce cas-ci intéressés que par la déviation d'un seul des axes. En effet, nous cherchons à éviter que le sous-marin ne tangue de droite à gauche et ne se retourne. La probabilité qu'il tangue d'avant en arrière étant quasi nulle.

Au vu de la façon dont nous placerons l'accéléromètre dans le sous-marin (le bord où se trouvent les pins orienté vers l'avant du sous-marin), seul l'axe Y nous intéresse.

Arduino

Voir code en pièce jointe.

Ressources

https://www.analog.com/media/en/technical-document...

https://howtomechatronics.com/tutorials/arduino/ho...

Step 8: Batterie

Notre sous-marin est évidemment autonome en énergie. Ceci est réalisé grâce à une batterie qui alimente l'ensemble du robot.

Cette étape implémente le relevé de la tension de la batterie. Dans le projet fini cette tension informe l’utilisateur sur le niveau de batterie du sous-marin.

Électronique

La tension de la batterie est calculée via un diviseur de tension créé par la résistance R2 et R3 (voir schéma branchement ci-dessus). On récupère la valeur de la tension R2 sur la pin A2 de l'Arduino. La tension maximum de la batterie est de 14,8V et ne peut descendre en dessous des 12V.

Arduino

On obtient une valeur sur 10bits de la tension par la fonction « analogRead(A2) ». Pour convertir cette valeur en pourcentage de tension on peut effectuer l’opération suivante :

  • Tension de la batterie = (R1+R2)/R1)*(A2_10bits * (5/1024))

On obtient le niveau de batterie (en %) de la manière suivante :

  • %batterie = (Tension de la batterie –12)*35,71

Ainsi si la tension de la batterie est maximale (14.8V) le pourcentage de batterie est égal à 100%. Si la tension de la batterie est à 12V, le pourcentage de batterie est égal à 0%.

Step 9: Intégration Arduino

Ce step a pour but de rassembler toutes les étapes vues précédemment afin de fournir le code Arduino final du projet. Une vidéo d'explication du schéma et une vidéo d'explication du code sont disponibles ci-dessus.

Rôle de l'Arduino

Le rôle de l’Arduino a été défini comme étant l’intelligence qui contrôle physiquement les éléments du sous-marin (moteurs, sonar, capteur de pression, etc.) excepté pour la caméra qui est contrôlée via la Raspberry. Suivant cette logique, les fonctions d’affichage et de pilotage par l'utilisateur sont laissées à la Raspberry.

Pour pouvoir diriger le robot et récupérer les informations essentielles à l’utilisateur telles que sa déviation angulaire ou la tension de la batterie, nous avons voulu que la Raspberry soit en charge de communiquer avec l’Arduino. Pour se faire nous avons utilisé le protocole de communication série « Rosserial » entre les deux cartes.

Branchements

Le schéma de branchement final est illustré sur la figure ci-dessus.

Arduino

Dans cette étape, la simple communication série est délaissée au profit d’une communication plus complexe utilisant le protocole « Rosserial ».
Ce protocole nous permet d’envoyer les données de l’Arduino (expl : la profondeur) vers la Raspberry et de recevoir les commandes de moteurs. On utilise la librairie « Ros.h » pour communiquer avec ROS. Le principe est d’initier des nœuds ROS permettant de créer des topics pour y publier des informations. Une fonction de callback permet également de récupérer la commande envoyée au moteur lorsqu’elle est appelée (lors d’une publication sur le topic « /command »).

Le code "integration.ino" est le code Arduino finale du projet. Pour être testé, il nécessite d'aller jusqu'au step où la communication ROS est paramétrée sur la Raspberry.

Une vidéo explicative du code est disponible ainsi qu'un flowchart du programme (voir schéma ci-dessus).

Le code "integration_serial.ino" permet d'effectuer un test de l'intégration de tout les composants Arduino via le terminal série avec un baudRate de 57600. Attention à entrer des commandes valides pour les moteurs (voir protocole de communication ci-dessus).

Step 10: Raspberry

La Raspberry Pi est ce que l’on appelle un nano-ordinateur monocarte. Plus simplement, on pourrait résumer la Raspberry Pi en disant que c’est un ordinateur de petite taille qui coûte environ 35€.

Très abordable en terme de prix, consommant peu d’énergie et disposant de connecteurs adaptés à l'électronique, la Raspberry Pi est donc très adaptée pour apprendre la programmation, faire de l’électronique, de la domotique, etc.

De plus, elle est basée sur une logique d’interruption permettant de lancer plusieurs scripts d’écoute différents simultanément alors que l’Arduino a une logique séquentielle. Il effectue une boucle de code avec le minimum d’interruption possible. Il est donc plus pratique de donner comme mission à la Raspberry d’établir la communication avec l’interface utilisateur, Node-RED (inutilisable sur l’Arduino), et le traitement de données (lancement du flux vidéo et du Node-RED). De son côté, l’Arduino a pour but d’effectuer les actions de chacun des composants électroniques cycliquement. Le travail informatique et électronique est donc judicieusement réparti sur les deux cartes.

ROS

Installation :

Sur votre installation Linux actuelle (Ubuntu Mate conseillé), installez les package ROS kinetic à l’aide des commandes suivantes :

sudo apt-get update
sudo apt-get install ros-kinetic-desktop-full

Initialisez ensuite les dépendances et les configurez les variables d’environnement avec les commandes suivantes :

sudo rosdep init
rosdep update<br>
echo "source /opt/ros/kinetic/setup.bash" >> ~/.bashrc
source ~/.bashrc
sudo apt-get install python-rosinstall python-rosinstall-generator python-wstool build-essential

Noeuds et topics :

Le ROS permet lorsqu’il est actif de créer des nœuds. Soit avec un script Python (grâce à la librairie rospy), soit via l’Arduino qui est capable de créer plusieurs nœuds qui se connecteront à des topics (ou channel de conversation). Les nœuds connectés au même topic pourront communiquer et se partager tout type d’informations (plus de détails sur la création des nœuds dans les scripts Python dans le step décrivant la communication Arduino-Raspberry).

Il est aussi possible de consulter la liste de nœuds actifs dans le ROS à l’aide de la commande :

rostopic list

On peut aussi écouter ou publier manuellement sur les topics à l’aide des commandes :

rostopic pub /topic type args
rostopic echo /topic

Extrêmement utiles pour le debugging des scripts Python et du code Arduino

Initialiser un espace de travail

L’espace de travail sera le fichier racine du projet il contiendra tous les codes et tous les sous-dossiers nécessaires au projet.

On crée le projet dans le dossier catkin_ws/src à l’aide des commandes suivantes :

mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/src
catkin_init_workspace
cd ~/catkin_ws
catkin_make

On configure la Raspberry pour qu'elle utilise l'espace de travail :

source devel/setup.bash

Le Workspace contient uniquement des scripts Python qui s’occupent de la communication entre le Node-RED et l’Arduino ainsi que du flux vidéo. Des nœuds ROS sont utilisés pour la connexion entre l’Arduino et l’environnement ROS. Pour la connexion entre le Node-RED (détaillé plus loin) et l’environnement ROS le protocole MQTT à été choisi.

MQTT

Node-RED possède en théorie des packages permettant de communiquer directement sur les topics ROS, mais il ne sont plus a jour et/ou incompatibles avec notre version de ROS pour la communication entre Node-RED et l’environnement ROS de notre projet. Nous avons donc opté pour des nœuds MQTT qui permettent simplement de communiquer les informations à l’aide de topics MQTT (l’implémentation dans le code est détaillée plus loin).

Quelques commandes utiles

Les commandes suivantes sont très pratiques, vous en aurez sans doute besoin plusieurs fois durant votre implémentation. (La commande sudo présente avant certaines commandes sert juste à assurer à la Raspberry que vous avez les droits d'administrateur pour par exemple modifier les fichiers protégés.)

  • Changer l'heure de la Raspberry : sudo date --set "11 FEB 2020 15:53:00"
    La Raspberry a tendance à oublier l'heure actuelle ce qui peut rendre l'accès à internet compliqué
  • rentrer dans un dossier : cd [nom_du_dossier]
  • revenir en arrière : cd ..
  • lister les dossiers et fichiers présents à l'emplacement actuel : ls
  • Ouvrir et éditer un script : nano [nom_du_script]
    Vous pouvez aussi utiliser VIM comme éditeur de texte

La touche tabulation permet l'autocomplétion.

  • Arrêter un script qui tourne : ctrl+c
  • Pauser un script : ctrl+z
  • relancer le dernier script pausé: bg

Très utile pour ne pas avoir à lancer plusieurs fenêtres de commande lors des tests

  • Lancer plusieurs commandes simultanément : commande1 & commande2
  • vérifier les services actifs : top
  • tuer un service : kill [id_du_service]

Step 11: Caméra

Communication

Un flux vidéo de résolution 320x240 et de framerate 31 est envoyé en permanence à la Raspberry grâce à une caméra Pi Camera Module.

Le flux vidéo est diffusé sur le réseau local via le port 8000 ( [adresse de la rasp]:8000 dans le navigateur web de l’utilisateur) et est récupéré dans l'interface Node-RED grâce à un nœud URL.

Code

Le code ci-joint permet la communication du flux video et a été récupéré sur le lien ci-dessous. Celui-ci prépare le flux sous forme de classes qui le préconfigurent en l’intégrant dans un serveur https créé par la Raspberry. Le framerate et la résolution sont modifiables à la ligne 73. Cependant nous avons constaté qu’il est préférable de garder la résolution en dessous de 480x360 sous peine de ralentir grandement le framerate même si celui -ci est fixé. Le framerate de 31 suffit largement pour avoir un flux de qualité. Un framerate supérieur risquerait de ralentir et faire surchauffer la Raspberry.

Sources

https://projects.raspberrypi.org/en/projects/getti...

Step 12: Servomoteurs

Caméra mobile

Un servomoteur Arduino est connecté directement à la Raspberry par les sorties digitales. Il permet de faire varier la direction de la caméra horizontalement afin d’avoir un champ de vision plus large.

Électronique

Le servomoteur est connecté au 3.3V de la Raspberry par la pin 1 et au GND par la pin 6. L’entrée de commande est connectée à une pin GPIO de la Raspberry (ici la 17)

Code

Le code écoute sur un topic MQTT les commandes venues de Node-RED.

Le code initie le servomoteur et le listener MQTT au démarrage (lignes 50 à 54) puis écoute sur le nœud MQTT et attend un message STRING contenant la prochaine position du servomoteur (convertit en entier -> entre 7 et 15 pour une inclinaison de -20° à 20°). Le servomoteur est éteint lorsqu’il ne reçoit pas de commande, la réception d’une instruction l’allume, modifie sa position et l’éteint en 0.15 seconde.

NB : Vous noterez qu’à la base deux servomoteurs sont initiés, il était à l’origine prévu de combiner ensemble deux servomoteurs grâce à une impression 3D et de pouvoir modifier la direction verticale de la caméra, cependant le dimensionnement final du sous-marin ne permet pas de placer ce montage.

Sources

https://tutorials-raspberrypi.com/raspberry-pi-ser...

Attachments

Step 13: Scripts ROS

Communication Arduino ↔ Raspberry

Les scripts présent sur le ROS permettent la communication des instructions et informations entre l’Arduino et la Raspberry. Ils ont deux formes différentes :

Arduino → Raspberry

Les scripts battery.py, depth.py, acceleration.py et submarine.py récupèrent respectivement le niveau de batterie restant, la mesure du capteur de pression, la mesure de l’accéléromètre et la mesure du sonar. Les scripts lancent un nœud listener ROS pour récupérer les valeurs données par les différents capteurs et un nœud publisher MQTT pour les renvoyer sur le Node-RED ou elle seront traitées puis affichées.

Les valeurs et spécificités des nœuds sont détaillées dans le fichier utilisation Raspberry disponible au step : Raspberry.

Les lignes :

client = mqtt.Client([nom_du_noeud_MQTT]) #create new instance
	client.connect(broker_adress)
	listener()

créent un nœud MQTT appelé [nom_du_nœud_MQTT] et le connecte à l’adresse ip de la Raspberry. La fonction listener est ensuite appelée.

La fonction :

def listener():
	rospy.init_node([nom_du_noeud_ROS], anonymous=True)
	rospy.Subscriber([nom_du_topic_ROS], [type], callback)
	rospy.spin()<br>

initie un nœud de nom [nom_du_nœud_ROS] anonyme (afin que plusieurs nœuds puissent se connecter au même topic) et le connecte au channel [nom_du_topic_ROS] en précisant le type du message et la fonction de callback (toujours callback()). Le rospy.spin() boucle en vérifiant si un message à été reçu sur le topic ROS.

La fonction :

def callback(data):
	client.publisher([nom_du_topic_MQTT], data.data)

est appelée lorsqu’un message est reçu sur le nœud ROS et renvoie ce même message sur le topic MQTT [nom_du_topic_MQTT] qu’écoutera le Node-RED.

Raspberry → Arduino

Le script commandV2.py récupère les commandes venant du Node-RED destinées aux différents moteurs du sous-marin.

Le script lance un nœud listener MQTT et un nœud publisher ROS

Les lignes :

client = mqtt.Client("P2") #create new instance
client.on_message=on_message #attach function to callback
client.connect(broker_address) #connect to broker
listener()

créent un nœud MQTT listener P2 connecté à la fonction on_message

La fonction :

def listener():
	pub = rospy.Publisher('command', String, queue_size=10)
	rospy.init_node('command', anonymous=True)
	cmd = "P00000100000100”
	pub.publish(cmd)
	client.subscribe("command")
	try:
		client.loop_forever() #loop, frvr
	except KeyboardInterrupt:
		pass

invoque un nœud de publication, le lie au topic ‘command’ et précise que la donnée envoyée sera une STRING. Le dernier argument queue_size représente le nombre de messages qui peuvent être mis en attente avant d’être supprimés.

Une commande d’initialisation des propulseur est directement envoyée sur le channel MQTT ‘command’.

La fonction client.loop_forever() boucle en écoutant le nœud MQTT

La fonction :

def on_message(client, userdata, message):
	pub = rospy.Publisher('command', String, queue_size=10)
	rospy.init_node('command',anonymous=True)
	cmd = str(message.payload)
	pub.publish(cmd)
	print("message received" ,str(message.payload))

est appelée lorsqu’un message MQTT est reçu et publie celui-ci sur le topic ROS

Script ip.py

La fonction unique contenue dans ce script est importée dans tous les autres scripts du ROS et permet de récupérer l’adresse IP actuelle de la Raspberry pour ne pas avoir à la modifier manuellement à chaque changement de réseau.

Scripts et utilisations

  • command.py : communique les valeurs de déplacement de Node-RED vers l'Arduino (topic ROS : /command, topic MQTT : /command)
  • servo.py : commande les servomoteurs de la caméra (topic MQTT : /servo)
  • submarine.py : communique les valeurs de profondeur et de pression vers node red (topic ROS : /chatter, topic MQTT : /chatter)
  • rpi_camera_surveillance_system.py : lance le flux vidéo de la caméra
  • acceleration.py : communique les valeurs de l’accéléromètre
  • ip.py : récupère l’ip de la rasp

Commandes ROS

  • *connexion vers l'Arduino* : rosrun rosserial_python serial_node.py /dev/ttyACM1
  • *publication sur un topic* : rostopic pub toggle_led std_msgs/Empty --once
  • *écoute sur un topic* : rostopic echo /topic_name
  • *lancement du rosbridge* :roslaunch rosbridge_server rosbridge_websocket.launch
  • *lancement du Node-RED* : node-red start
  • Emplacement des scripts : catkin_ws/src/subMarine/src
  • *lancer un script depuis n’importe ou* : rosrun subMarine [nom_du_script]

Comment lancer le robot

  1. Lancer la communication entre la Raspberry et l'Arduino à l'aide de la commande rosrun, l’adresse du port extérieur /dev/ttyACM1 peut varier en fonction du port USB que vous utilisez: ttyACM0, ttyACM1, ttyACM2
  2. Lancez le Node-RED à l'aide de la commande node-red start
  3. Lancez le launchfile
  4. Accédez à l'éditeur Node-RED grace à votre navigateur à l'url: [adresse_ip_de_la_Raspberry]:1880 ou [adresse_ip_de_la_Raspberry]:1880/ui pour l'interface utilisateur.
  5. Pilotez :)

Step 14: Node-RED

Nous avons décidé que le contrôle du sous-marin par l'utilisateur serait fait depuis une interface Node-RED.

Ce choix a été posé car Node-RED :

  • est intuitif et simple à utiliser
  • s'utilise particulièrement bien sur une Raspberry
  • est spécifiquement adapté pour commander à distance grâce à une technologie sans fil

Il suffit donc à l'utilisateur de se connecter à la Raspberry et d'ouvrir l'interface depuis un navigateur web pour commander le sous-marin.

Installation

La première étape est bien sûr d'installer Node-RED sur la Raspberry. Vous trouverez toutes les instructions en suivant le lien ci-dessous :

https://nodered.org/docs/getting-started/raspberry...

Interface utilisateur

Un aperçu de l'interface utilisateur (brut) est illustré afin de représenter plus facilement celle-ci et de la mettre en lien avec le flow.

Flow

Pour éditer Node-RED, il suffit d'introduire l'adresse : http://localhost:1880/ dans un navigateur web de l'appareil sur lequel Node-RED est installé (la Raspberry).

L'interface utilisateur (UI) est constitué de 4 groupes

  1. Data
    où se retrouvent les données acquises par le sous-marin ou ses différents capteurs :
    • le niveau de batterie
      Il est envoyé sur le Node-RED via le nœud MQTT "battery". Lorsqu'il passe sous les 20%, le sous-marin interrompt toutes ses manœuvres pour remonter à la surface et une alerte s'affiche sur l'interface utilisateur. Cette action de remontée est envoyée à la Raspberry via le nœud MQTT "command"
    • la profondeur
      Elle est envoyée sur le Node-RED via le nœud MQTT "depth"
    • la distance par rapport un fond (ou un obstacle)
      Elle est envoyée sur le Node-RED via le nœud MQTT "chatter"
    • la déviation du sous-marin par rapport à l'axe Y
      Elle est envoyée sur le Node-RED via le nœud MQTT "acceleration". Elle passe ensuite dans la fonction "Interpretation" et si la déviation, sur la droite ou la gauche, visible sur une jauge, est supérieure à 25°, le sous-marin la régule en remplissant/vidant un ballast par rapport à l'autre grâce à la fonction "PID". Si ce phénomène se produit, la fonction "Alert" le notifie sur l'interface utilisateur. Cette action est envoyée à la Raspberry via le nœud MQTT "command"
    • la détection d'infiltration d'eau
      Elle est envoyée sur le Node-RED via le nœud MQTT "water". Le traitement de cette information est un peu différent des autres. Jusqu'ici, c'est lorsqu'un comportement nécessitant une action était détecté dans Node-RED que le sous-marin appliquait la commande (avance, plongée, régulation du roulis, etc.). L'information est traitée dans Node-RED, puis envoyée à la Raspberry qui commande l'Arduino. Ceci afin d'alléger les tâches à effectuer par le celui-ci qui atteint déjà ses limites (>80% de la mémoire utilisée).
      Si le capteur d'eau détecte une infiltration, l'Arduino se chargera lui même de commander la remontée d'urgence. De sorte qu'un temps minimal soit perdu pour l'effectuer. En effet, bien que le temps de communication entre les appareils soit minime, dans un cas aussi grave qu'une infiltration d'eau, aucune perte de temps ne peut être tolérée. C'est pourquoi l'Arduino applique lui-même la commande mais communique tout de-même l'information à Node-RED pour que l'utilisateur sache pourquoi le sous-marin effectue une remontée subite.
  2. Vidéo
    où se retrouvent :
    • un champ permettant d'entrer l'adresse IP de la Raspberry et avoir ainsi accès au flux vidéo
    • le flux vidéo
    • des boutons permettant de modifier l'orientation de la caméra
      Chaque pression sur un bouton fait tourner les servomoteurs d'un angle donné. Ces actions sont envoyées à la Raspberry via le nœud MQTT "servo"
      NB : Comme expliqué précédemment, les boutons pour mouvoir la caméra verticalement ont été désactivés.
  3. Commandes
    où se retrouvent les commandes exécutables par l'utilisateur pour mouvoir le sous-marin :
    • un bouton permettant de remonter à la surface
      Lorsque ce bouton est pressé, le sous-marin videra ses ballasts jusqu'à ce que ceux-ci ne contiennent plus d'eau ou qu'une commande contraire ne soit introduite. Cette action est envoyée à la Raspberry via le nœud MQTT "command"
    • un bouton permettant d'interrompre le remplissage/vidage des ballasts ou l'avancée
      Cette action est envoyée à la Raspberry via le nœud MQTT "command"
    • un bouton permettant de plonger
      Lorsque ce bouton est pressé, le sous-marin remplira ses ballasts jusqu'à ce que ceux-ci ne contiennent plus d'air ou qu'une commande contraire ne soit introduite. Cette action est envoyée à la Raspberry via le noeud MQTT "command"
    • un slider permettant de régler l'angle de rotation du sous-marin
    • un slider permettant de régler la vitesse du sous-marin
      Lorsqu'une vitesse est entrée, la fonction "Run" vérifie si un angle de rotation a également été commandé. Si oui, elle adaptera proportionnellement la vitesse d'un moteur par rapport à l'autre pour faire tourner le sous-marin en conséquence. Cette action est envoyée à la Raspberry via le nœud MQTT "command"
  4. Dashboard
    où se retrouvent de manière plus visuelle les commandes entrées par l'utilisateur
    • l'angle de rotation
    • la vitesse relative du sous-marin

Voir code en pièce jointe.
Attention : Le code ci-joint a été converti au format .txt mais il s'agit en réalité d'un fichier .json. Cette convertion a été effectuée car, pour une obscure raison, Instructable refuse l'upload de fichier .json. Prenez bien soin de le convertir en fichier .json avant de l'importer dans Node-RED.

Attachments

Step 15: PCB

Pour la conception du PCB, nous avons décidé de réaliser un shield Arduino qui comprend tous les connecteurs et capteurs du projet afin de pouvoir fiabiliser les connexions et simplifier la mise en place.

Nous y avons donc installé le gyroscope pour contrôler le roulis du sous-marin, le capteur de pression et son amplificateur, le module d’amplification du sonar, le buck 12V pour les moteurs des ballasts et un diviseur de tension pour connaitre la tension de la batterie via l'ADC.

Nous utilisons le régulateur 5V des ESC pour alimenter la Raspberry et l'Arduino. Pour ce faire, le connecteur de faible puissance du ballast de gauche est connecté à un interrupteur afin de pouvoir choisir ou non d'alimenter la logique. Ensuite on passe par un fusible 5A pour protéger l'électronique en cas de cours circuit. On termine par une LED témoin et un connecteur USB. Il suffit donc après de placer un câble USB entre le shield et la Raspberry puis un autre entre l'Arduino et lui pour que toute la logique soit alimentée. Nous avions également prévu sur le shield la possibilité de choisir d'utiliser le régulateur du ballast de droite en fixant ou non un shunt pont.

Il reste donc les connecteurs des ESC, les deux de puissance (XT60), les deux de faible puissance (de pas 2.54mm), ceux des ballasts (de pas 2.54mm) et le connecteur de puissance de la batterie (XT60).

Step 16: Impressions 3D

Nous avons choisi d'utiliser l'impression 3D pour réaliser l’ensemble des éléments de structure..Ceci afin d'avoir un résultat optimal. Nous avons tout imprimé en PLA et renforcé la structure en contact avec l'eau avec de la résine époxy et de la fibre de verre. Pour le choix des différents designs, tout à été fait sur mesure hormis le support des propulseurs et l'hélice (modifiée pour notre mandrin moteur) qui ont été trouvés sur Thingiverse :
https://www.thingiverse.com/thing:2947126. Pour réaliser les design, nous avons utilisé le logiciel Fusion 360 en licence éducative. Vous trouverez ci-joint les fichiers sources Fusion 360 de chaque pièce. Pour apprendre à utiliser ce logiciel vous pouvez regarder le tutoriel en vidéo ci-dessous :

Hélices

L'hélice vient s'accrocher sur le mandrin du moteur.

Supports propulseurs

Le support des propulseurs permet de fixer ceux-ci, à l'aide de vis M3, au sous-marin.

Supports ballasts

Les ballasts sont collés dans le sous marin, d'un coté et de l'autre.

Base

La base permet de réaliser un montage unique empilant tout l'électronique et de la fixer au sous-marin.

Coque

La coque est constituée des supports propulseurs, de la coque en elle même et des couvercles de fermeture où l'étanchéité est assuré par des joints.

Bouée

La bouée permet maintenir le répétiteur wifi à la surface de l'eau et à l'abri de celle-ci.

Step 17: Assemblage

Après avoir imprimé chaque pièce (à noter que la coque doit être potentiellement divisée en plusieurs pièces en fonction de la taille qu'il est possible d'imprimer sur votre imprimante comme ça a été le cas pour nous) il est temps de réaliser l'assemblage pour uniformiser le tout et enfin d'étanchéifier l'ensemble.

Structure

Nous avons dû diviser la coque en trois parties pour l'imprimer donc dans un premier temps il a fallu les recoller ensemble. Pour cela nous avons utilisé de la colle cyanoacrylate.

Il ensuite été nécessaire de fixer les propulseurs après les avoir étanchéifiés (voir step Propulseurs). Pour ce faire nous avons utilisé de la colle époxy à séchage rapide.

Une fois fait, il a fallu placer le dôme transparent en utilisant de la colle cyanoacrylate et de la colle époxy pour être certains de l’étanchéité (il est important une fois cela fait de protéger la coupole pour évité de l’abîmer).

Nous pouvons à présent passer au reste de l'étanchéification.

Étanchéité

Pour étanchéifier la structure nous avons utiliser deux matériaux, de la fibre de verre et de la résine époxy. L'idée est de recouvrir la structure de ce bi-composant pour la renforcer. En effet, l'épaisseur de l'impression est très fine (<2mm) donc très peu rigide. Les parois sont aussi très fragiles donc la fibre de verre et la résine époxy permettent de rendre le tout extrêmement dur et résistant. La résine époxy permet également d'imperméabilisé le PLA qui est un matériaux naturellement poreux. Pour ce faire il faut donc déposer la fibre découpée à la forme voulue sur une petite zone à traiter et puis de recouvrir de résine époxy.

Cette étape est extrêmement laborieuse, d'une part parce qu'elle est très longue, vous ne pouvez traiter qu'une petite partie à la fois et vous devez attendre 24h entre chaque passage, d'autre part parce que la résine étant très liquide avant cristallisation, elle se faufile par la moindre interstice.Pour les zones de fermeture (couvercle et trous d'accès sur le sous marin, il ne faut pas mettre de fibre de verre. Pour les trous des ballast et capteur de pression, mettre les tuyaux et les collés. Pour le sonar, faire pareille.

Finition

Après avoir recouvert l'intégralité du sous marin du bi-composant, nous avons peint la structure avec une peinture en bombe bleu, et résistante à l'eau.

Fermeture du sous-marin

Pour fermer le sous-marin il suffit de passer le joint dans la rainure de l'ouverture (voir photo) puis de poser le couvercle dessus et de serer 6 boulon M3.

Verification des fuites

Afin de vérifier la présence de fuite, nous avons réalisé un couvercle percé en sont centre ou nous avons collé à la colle époxy une pipette de chambre à air de vélo. Une fois ce couvercle placé, nous avons injecté de l'air sous pression (0.5 bar) pour vérifier qu'elle ne s'en allait pas. Si c'est le cas il faut trouvé la fuite en mettant la structure dans l'eau et voir ou l'air s'échappe. Il faut ensuite colmater la fuite avec de la colle époxy.

Assemblage des composants

Remplir la structure de toute l'électronique composant par composant.

Lestage du sous-marin

Une fois le sous-marin assemblé, fermé et testé, il faut le lester pour qu'il soit tout juste en flottaison mais qu'une fois les ballasts remplis, il se mette à couler. Pour ça nous avons rajouté 8 kg de poids de musculation en dessous de celui-ci.

Step 18: Répéteur

Problématique

Il est extrêmement compliqué d'assurer une communication sans fil dans l'eau. En tout cas à petit budget.

La communication sans fil n'étant pas possible, nous nous sommes résolus à transmettre nos données par câble RJ45. Cependant, par défi technique et soin de la réalisation, nous tenions tout de même à ce que le sous-marin ne soit pas relié à l'ordinateur qui le commande par un long câble.

SSH

Pour communiquer avec le sous-marin pour par exemple commander les moteurs, nous avons besoin de piloter la Raspberry à distance via le protocole SSH. Pour cela une connexion doit être assurée. Nous nous connectons donc au sous-marin grâce au logiciel PuTTY et avons alors accès a l'invite de commande de la Raspberry.

Solution

Nous avons donc pensé à réaliser un relais de communication placé sur une bouée. Celui-ci est relié au sous-marin par un câble RJ45 et est connecté via le réseau Wi-Fi à l'ordinateur opérateur.

Répéteur

Pour cela nous avons choisi le répétiteur TL-WR902AC configuré en mode client. Il faut le configurer à partir d’un ordinateur pour qu’il répète la connexion par câble jusqu’au port Ethernet de la Raspberry.

Voici une petite vidéo expliquant comment le configurer.

L'adresse IP est alors attribuée à la Raspberry par le répétiteur mais celui-ci ne peut en attribuer seulement dans la plage d'IP permise par le masque de sous réseau attribué au répétiteur. On comprend donc que l'IP du répétiteur change en fonction du réseau auquel il est connecté et donc qu'on ne peut fixer l'adresse IP de la Raspberry.

En fait en pratique on peu la fixer mais pour un réseau fixe. Si on passe de 10.0.0.xxx à 192.168.0.xxx, l'adresse attribuée à la Raspberry changera. Ce qui revient à la même problématique.

Nous avions alors deux moyen d'obtenir l'IP:

  1. Regarder la liste des appareils connecté au réseau et leur IP correspondante.
  2. Faire un ifconfig dans l'invite de commande sur la Raspberry.

Step 19: Interface Utilisateur

Voici enfin l'interface utilisateur ! Celle qui permet de commander le sous-marin et surveiller toutes les informations qu'il capte.

Avant de voir en vidéo le sous-marin fonctionner, voici une explication en image, partie par partie, de l'interface utilisateur.

Pour accéder à l'interface utilisateur, il suffit d'introduire l'adresse : http://localhost:1880/ui dans un navigateur web de l'appareil sur lequel Node-RED est installé (la Raspberry).

Les images ci-dessus sont illustrent, dans l'ordre, chaque point décrit dans la suite de ce step.

Data

  1. Tout va bien
    Le niveau de batterie, la profondeur, la sonar et la déviation sont affichés
  2. Le niveau de batterie passe sous les 20%
    Une alerte s'affiche : "Retreat !" et le sous-marin interrompt toute action en cours et effectue une remontée d'urgence en envoyant la commande "B25550025550011" à l'Arduino.
  3. Déviation à gauche
    Le sous-marin penche trop à gauche, la déviation est inférieure à -25°. Le sous-marin interrompt toute action en cours et remplit le ballast de droite et vide celui de gauche jusqu'à ce que la déviation soit supérieure à -25°.
  4. Déviation à droite

    Le sous-marin penche trop à droite, la déviation est supérieure à 25°. Le sous-marin interrompt toute action en cours et remplit le ballast de gauche et vide celui de droite jusqu'à ce que la déviation soit inférieure à 25°.

  5. Infiltration d'eau

    Une alerte s'affiche : "Water inside, Retreat !". Comme expliqué précédemment, au moment où l'infiltration est détectée par l'Arduino, celui-ci interrompt toute action en cours et effectue une remontée d'urgence. L'infiltration n'est pas traitée par Node-RED mais est affichée à l'écran de sorte que l'utilisateur comprenne pourquoi le sous-marin effectue une remontée subite.

Vidéo

  1. En entrant l'adresse IP de la Raspberry (localhost), le flux vidéo s'affiche automatiquement. Les boutons permettent d'orienter celle-ci.

Commandes et Dashboard

  1. Plongée
    En appuyant sur le bouton "Dive", l'Arduino reçoit la commande "B25550025550022" et remplit les ballasts jusqu'à recevoir une autre commande.
  2. Stop
    Le bouton "Stop" interrompt toute action (plongée, remontée ou autre) en voyant la commande "B00000000000011" à l'Arduino
  3. Avance
    Lorsqu'un angle et une vitesse sont entrées, le sous-marin enclenche les propulseurs.
    Exemple : "P07020007020000"
    NB : Une sécurité a été implementée de sorte que si seule la vitesse du sous-marin est commandée (et pas la direction) celui-ci ne démarre pas. En effet, au démarrage du sous-marin, la direction est naturellement orientée sur -90° (virage à gauche maximum). Cette sécurité à pour but que le sous-marin ne démarre pas en effectuant un virage serré à gauche non voulu.Il ne démarrera pour la première fois qu'après avoir reçu une direction et une vitesse.
  4. Virage à gauche
    Le sous-marin augmente/diminue la vitesse d'un propulseur par rapport à l'autre pour effectuer un virage.
    Exemple : "P05020008020000". Dans ce cas-ci, le propulseur droit tourne plus vite que le gauche.
  5. Virage à droite
    Le sous-marin augmente/diminue la vitesse d'un propulseur par rapport à l'autre pour effectuer un virage.
    Exemple : "P03020000020000". Dans ce cas-ci, le propulseur gauche tourne plus vite que le droit.
  6. Remontée
    En appuant sur le bouton "Surface", l'Arduino reçoit la commande "B25550025550011" et vide les ballasts jusqu'à recevoir une autre commande.

Step 20: Projet Fini

Setup

  1. Avant de brancher la batterie, vérifier que tous les composants sont correctement connectés et que l'interrupteur est sur OFF
  2. Brancher la batterie en s'assurant qu'elle soit suffisamment chargée
  3. Allulmer l'interrupteur et s’assurer d’entendre le bruit caractéristique des propulseurs sinon recommencer les étapes 1 et 2
  4. Allumer le répétiteur (après s'être assuré que la batterie d'alimentation était suffisamment chargée) et s'y connecter en Wi-FI
  5. Se connecter en SSH à la Raspberry
  6. Lancer les scripts sur la Raspberry comme expliqué précédemment
  7. Lancer Node-RED et ouvrir l'interface utilisateur
  8. Enjoy !

Démonstration

Il n'a pas été possible de réaliser une démonstration en milieu aquatique mais nous avons pu montrer que tous les composants fonctionnent

Be the First to Share

    Recommendations

    • DIY Summer Camp Contest

      DIY Summer Camp Contest
    • Maps Challenge

      Maps Challenge
    • Metal Contest

      Metal Contest

    Comments