Robotique Educative
Ateliers dans le primaire et le secondaire. Documentation de projets réalisés avec des écoles, collèges, lycées.
- Qu'est ce que CréaBot ? Le club robotique de l'IUT de Haguenau
- Année scolaire 2023-2024
- Club Robotique Cycle 1 - LittleBot
- Description du projet
- Phase 1 - Conception - 3 x 1H30
- Phase 2 - Câblage et programmation du LittleBot - 4 x 1h30
- Phase 3 - Assemblage et réctification - 2 x 1h30
- Fiche Séance 2 - 1H30
- Qu'est ce qu'un servo-moteur ?
- Piloter un servomoteur avec Mblock
- Fiche Séance 3 - 1H30
- Qu'est ce qu'un capteur à ultrasons ?
- Fiche Séance 4 - 1H30
- Fiche Séance 5 - 1H30
- Fiche Séance 6 - 1H30
- Fiche Séance 7 - 1H30
- Fiche Séance 8 - 1H30
- Fiche Séance 9 - 1H30
- Câblage et programmation du LittleBot
- Apprendre à utiliser TinkerCad (classe)
- Programme MBLOCK
- Club Robotique collège Cycle 2 - Station de mesure (T°, H)
- Club Robotique Cycle 3 - Voiture RC
- Phase 1 - Conception 2D et 3D - ? x 1h30
- Phase 2 - Électronique et programmation
- Moteur CC - Principe de fonctionnement
- Moteur CC - Commande de moteur à courant continu
- Moteur CC - Contrôler la vitesse avec une roue encodeuse
- Le module Bluetooth HC-05
- RC Car - Voiture modélisme radiocommandée
- Code voiture RC
- Stages de Robotique pour les collégiens - Station Mesure Eau
- Fiche résumé
- Conception technique du stage
- Conception de la formation des animateurs
- Atelier de formation des animateurs
- Ateliers de développement de la station de mesure de l'eau (5 jours)
- Matériel et Plateforme standards pour la robotique éducative
Qu'est ce que CréaBot ? Le club robotique de l'IUT de Haguenau
Voir aussi le Club Robotique CréaBot sur le site de l'IUT de Haguenau
Objectifs et compétences
Tous les mercredis après midi, en période scolaire, le club robotique CréaBot accueille des collégiens passionnés par les technologies du numérique pour explorer et développer leur intérêt pour les robots au sein du Fablab d'Alsace-Nord (FAN) de l'IUT de Haguenau .
Ce club a pour objectif d’initier un jeune public à la robotique et la programmation afin de les sensibiliser aux métiers et aux enjeux technologiques d'aujourd'hui et de demain. Il contribue au développement des apprentissages fondamentaux que sont les mathématiques, la physique, la technologie, l'informatique sous forme ludique.
Plusieurs activités sont proposées durant toute l'année autour de la conception, la fabrication, l'assemblage et la programmation de robots où différents aspects techniques seront abordés sur chaque robot tels que la mécanique, l'électronique et la programmation.
Au-delà des compétences techniques, le club de robotique favorise également le développement de compétences transversales telles que la créativité, la résolution de problèmes et le travail d’équipe. Les collégiens seront amenés à collaborer et à partager leurs idées pour atteindre un objectif commun. Notre club de robotique est un véritable espace de partage, d’apprentissage et d’expérimentation autour des STIM (science, technologie, ingénierie et mathématiques).
Encadrés par le Fab-Manager du FAN, compétent et passionné, ils apprennent à concevoir et construire des éléments mécaniques et électroniques du robot à partir de modèles ou de leur propre création.
À travers ce club, les collégiens exploitent l'informatique (programmation, comparaison de stratégies) et travaillent la démarche d'investigation : mise en situation d'autonomie, mettre en place une stratégie, réaliser des essais, valider ou invalider la méthode, comprendre d'où vient le problème et corriger en conséquence le programme.
Les collégiens découvrent les différentes fonctionnalités des capteurs, pour prendre connaissance de l'environnement, ainsi que des moteurs permettant les déplacements du robot (avancer, reculer, tourner à droite ou à gauche, suivre une trajectoire).
Différents types de robots seront fabriqués durant l'année pour assurer des opérations selon les applications et les missions à mener : robot mobile à 2 ou 4 roues, bras robotique, robot à 4 ou 6 pattes....
A qui s'adresse-t-il ?
Ce club s'adresse principalement aux collégiens de la 6ème à la 3ème.
Horaires
Les activités du club sont organisées en période scolaire sur les horaires suivants :
- 6ème-5ème : 14h-15h30
- 4ème-3ème : 16h-17h30
Pas d'activité au club pendant les vacances scolaires.
Lieu et encadrement
Fablab de l'IUT de Haguenau
30 rue du Maire André Traband
67500 Hagueanu
Encadré par le Fab-Manager du Fablab
Année scolaire 2023-2024
Planning de l'année scolaire 2023-2024
Le planning se décompose en 3 cycles de 3 mois avec un robot par cycle. Les difficultés de chaque cycle est progressif.
1er cycle : Le contenu est entièrement donné, du schéma de câblage aux instructions de construction en passant par les programmes informatique du robot.
2ème cycle : Les participants doivent réfléchir comment créer la pièce, quelle forme est optimal, le programme est pré-construit et une aide leur est proposée.
3ème cycle : Seul le "type de robot" leur est donné, ils devront réfléchir à quelle esthétique lui donner, quels capteurs utiliser, comment l'assembler et comment le programmer.
Pour chaque cycle, les participants sont amenés à travailler sur 3 domaines :
- La conception mécanique et électronique.
- La fabrication mécanique et électronique
- La programmation (Scratch, Python, langage C...)
Les 3 domaines sont abordés en parallèle, afin d'introduire les notions et techniques progressivement et de manière didactique.
1er cycle : Little Bot
Le premier cycle sera consacré à la fabrication du robot appelé LittleBot.
Pour ce cycle, nous utiliserons l'environnement Mblock de programmation informatique par bloc (Scratch) ainsi que le logiciel de dessin 3D assisté par ordinateur TinkerCAD (CAO).
Durant ce cycle, nous apprendrons à utiliser une imprimante 3D mais aussi des composants pour de l'électronique.
Nous découvrirons les principes et le fonctionnement du capteur ultrason ainsi que des servomoteurs.
Le programme, le câblage et l'assemblage est fourni pour la réalisation de ce projet.
L'objectif final de ce cycle est de faire avancer le robot, le faire tourner et de lui faire éviter des objets.
2ème cycle : Segway
Le deuxième cycle sera consacré à la fabrication d'un robot de type segway.
Pour ce robot, nous utiliserons le langage C++ (Arduino) pour le faire fonctionner ainsi que l'utilisation du logiciel Fusion360.
Durant ce cycle, nous apprendrons à utiliser plusieurs types de capteurs tel quel l'infrarouge et le gyroscopique.
Nous apprendrons comment fonctionne une télécommande et nous ferons fonctionner notre robot avec celle-ci.
Le programme, le câblage et l'assemblage vous sera donné partiellement pour ce projet.
L'objectif final de ce cycle est de comprendre la cinématique d'un "segway", garder une stabilité avec ce robot et faire avancer celui-ci.
3ème cycle : Araignée ou Traceur de découpe
Le troisième cycle sera consacré à la fabrication d'un robot de type "araignée" et/ou type "traceur de découpe".
Pour ce robot, nous utiliserons le langage C++ (Arduino) pour le faire fonctionner ainsi que l'utilisation du logiciel Fusion360.
Durant ce cycle, nous utiliserons plusieurs servomoteur ainsi qu'un capteur ultrason, un haut parleur et un micro
L'objectif final de ce cycle est de comprendre la cinématique d'un robot à 4 pattes et ses déplacement ainsi que le déplacer en utilisant uniquement le son de notre voix.
En ce qui concerne le traceur, nous le coderons en C++ et nous utiliserons fusion 360 pour l'impression 3D.
Nous utiliserons des moteurs pas à pas ainsi que des servomoteurs pour le déplacement du crayon.
L'objectif est de construire un traceur de découpe permettant de dessiner avec une image vectoriel.
Le programme, le câblage et l'assemblage vous sera pas donné pour la réalisation de ce projet. Seul le type de robot vous sera donné, à vous de le contruire de A à Z.
Club Robotique Cycle 1 - LittleBot
Description du projet
Introduction
Pour le premier cycle, nous allons créer un robot mobile très simple appelé LittleBot.
Pour ce robot, nous utiliserons la programmation par bloc de type Scratch via l'environnement de développement MBlock ainsi que le logiciel de modélisation 3D TinkerCAD.
Durant ce cycle, nous apprendrons à utiliser une imprimante 3D mais aussi des composants pour de l'électronique.
Nous découvrirons les principes fonctionnement et la mise en œuvre d'un capteur ultrason ainsi que de servomoteurs.
Le programme, le câblage et l'assemblage sera donné pour la réalisation de ce projet.
L'objectif final de ce cycle est de faire avancer le robot, le faire tourner et de lui faire éviter des objets.
Description du cycle
- Compétences Animateur
- Prérequis participants
- Age 10-15
- Notions de base en électricité et circuit électronique
- Notions de base en géométrie
- Des bases en Langage de programmation par bloc "scratch" est un plus
-
Logiciels :
- Programmation : MBlock (scratch) et Arduino IDE (C)
- Modélisation CAO : TinkerCAD, ONSHAPE, FreeCAD
- Préparation impression 3D (slicer) :
-
Compétences et technologies :
- Programmer une Carte microcontrôleur Arduino depuis MBlock et Arduino IDE
- Stocker dans une variable la valeur d'un Capteur de distance ultrason HC-SR04
- Piloter un Servomoteur en donnant la valeur de sa vitesse de rotation
- Télécharger le modèle 3D d'une pièce sur internet
- Modifier le modèle 3D d'une pièce avec TinkerCAD
- Préparer un fichier d'impression 3D avec ...
- Lancement d'une impression 3D sur l'imprimante ...
Description du déroulé
11 séances :
- 4 séances Conception électronique et câblage : Arduino et MBlock
- Introduction Arduino et MBlock
- Actionneur : servomoteur (déplacement)
- Capteur : ultrason (distance)
- Couplage capteur moteur
- 4 séances Conception mécanique et assemblage : TinkerCAD et impression 3D
- 2 séances sur TinkerCAD
- 2 séances sur l'impression 3D
- 3 séances d'assemblage et de programmation : Arduino IDE
- Assemblage du LittleBot
- Programmation de la cinématique du véhicule
- Algorithmie pour stratégie d'évitement d'obstacle
Matériel
Projet inspiré de : https://www.thingiverse.com/thing:2417739
- 1 x Arduino Nano ou compatible (seeeduino, funduino,...) : ~10€
- 1 x câble USB C : ~1€
- 1 x Sensor Shield pour Arduino Nano : ~3€
- 2 x servomoteur à rotation 360° (DM-S0090D-R 9g/0.08s/1.6kg.cm) : ~2€
- 1 x Module ultrason (HC-SR04) : ~2€
- 2 x élastique pour les roues (diamètre Xmm)
Une imprimante 3D pour imprimer les pièces suivantes (~5€ de filament) :
- Châssis :
- Capot :
- Roues avec rainure pour insertion élastique :
Phase 1 - Conception - 3 x 1H30
Conception 3D avec TinkerCAD
Prérequis participant :
- Travail sur ordinateur
- Manipulation avec la souris (clic droit, clic gauche, sélection,...)
Compétences Animateur :
Compétences techniques et soft skills :
- Pratique du logiciel TinkerCAD ou autre logiciel de CAO (Solidworks, Fusion360,...)
- Animation
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- Connexion et navigateur internet (Firefox)
- Session invité ou nominative
- Connexion et navigateur internet (Firefox)
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation / Tutoriels :
- Tutoriel animateur TinkerCAD - création d'une activité
- Tutoriel élève TinkerCAD - modélisation d'une pièce
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Débrancher et ranger les composants
- Chaque participant vérifie la boite du voisin (check-list)
- Remettre ordinateur dans l'état initial
- Programme de la prochaine séance
Phase 2 - Câblage et programmation du LittleBot - 4 x 1h30
Prérequis Participant
- Travail sur ordinateur
- Manipulation avec la souris (clic droit, clic gauche, sélection,...)
- Manipulation du clavier
- Notions d'électricité
- Notions de programmation par bloc (scratch)
Prérequis Animateur
Compétences techniques
- Pratique du logiciel Arduino IDE, connaissance en programmation C++
- Gestion des drivers sous Windows ou Expérience avec Ubuntu / Linux Mint
- Circuits et branchements électrique
Soft skills
- Animation
- Gestion de la Motivation et de l'attention
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
-
12 PCs (1 par participant)
- Windows ou Linux
- Connexion et navigateur internet (Firefox)
- Session invité ou nominative
- Logiciel Arduino IDE pré-installé
-
Composants éléctroniques
- Carte Arduino Nano (x12)
- Shield (extension Arduino Nano) (x12)
- Capteur Ultrasons HRC-SR04 (x12)
- Servo-Moteur DM-S0090D (x24)
- Câble Dupont (x48 - 4/participants)
-
Programmes du LittleBot et des composants
Préparation
Matériel par participant sur un poste PC en début de séance :
Documentation / Tutoriels :
- Tutoriel animateur Arduino IDE-
création d'une activité - Tutoriel élève Arduino IDE-
modélisation d'une pièce - Tutoriel Arduino Nano
- Tutoriel Capteur Ultrason
- Tutoriel Servo moteur
Exemple de déroulement pédagogique
Exemple indicatif de déroulé par séance
Déroulé effectué en 2023-2024 au club robotique de l'IUT de Haguenau (1H30/séance, collégiens 6ème-3ème) :
- Séance 1 : Câblage et programmation d'une LED sur ? Arduino IDE ou MBlock ?
- Séance 2 : Principe physique, Câblage et programmation d'un câbleur ultrason
- Séance 3 : Principe physique, câblage, et programmation d'un servomoteur
- Séance 4 : Câblage complet du LittleBot
- Séance 5 : Programmation du LittleBot
Exemple de déroulé pour la séance 1
Déroulement pédagogique complet
Pour la découverte du câblage et de la programmation, nous allons découvrir petit-à-petit les différents composants électroniques, logiciels et programmes informatiques (code) nécessaire au fonctionnement du LittleBot. Commençons pas la découverte de la carte microcontrôleur "Arduino Nano" et sa carte de développement "Sensor Shield v3".
Tutoriel : Qu'est-ce que l'"Arduino"
Maintenant que nous sommes experts en microcontrôleur, voyons comment l'utiliser pour de la robotique.
Tutoriel : Qu'est-ce qu'un robot ?
Un robot est composé de capteurs et d'actionneurs. Nous allons d'abord découvrir et apprendre à utiliser un capteur de distance :
Tutoriel : Qu'est-ce qu'un capteur ultrason ?
Ce capteur peut être utilisé pour modifier le mouvement du robot qui est actionné par des servomoteurs :
Tutoriel : Qu'est-ce qu'un servomoteur ?
Maintenant que nous savons capter notre environnement et actionner des moteurs, nous allons pouvoir programmer le mouvement des moteurs en fonction de ce que le capteur reçoit :
Tutoriel : Câblage et programmation du LittleBot
Conclusion / Rangement / Démontage :
Phase 3 - Assemblage et réctification - 2 x 1h30
Prérequis participant :
- Travail manuel et sur ordinateur
- Manipulation avec la souris (clic droit, clic gauche, sélection,...)
- Manipulation du clavier
Compétences Animateur :
Compétences techniques et soft skills :
- Pratique du logiciel Arduino IDE, connaissance en programmation C++
- Animation
- Compétences manuelles
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- Connexion et navigateur internet (Firefox)
- Session invité ou nominative
- Logiciel Arduino IDE pré-installé
- Connexion et navigateur internet (Firefox)
- Composants éléctroniques
- Carte Arduino Nano (x12)
- Shield (extension Arduino Nano) (x12)
- Capteur Ultrasons HRC-SR04 (x12)
- Servo-Moteur DM-S0090D (x24)
- Câble Dupont (x48 - 4/participants)
- Programme du LittleBot
- Châssis et capot imprimés en 3D (x12)
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation / Tutoriels :
- Tutoriel Arduino Nano
- Tutoriel Capteur Ultrason
- Tutoriel Servo moteur
- Tutoriel Câblage et Programmation
Déroulement de la séance
Lors de notre première séance, nous allons câbler et assembler le robot. Tout d'abord, nous allons câbler notre capteur ultrasons à notre shield. Par la suite, nous allons assembler le robot dans sont châssis avec le tutoriel d'assemblage.
Puis nous allons brancher nos servo-moteurs à notre Shield en passant par les emplacements prévu sur notre châssis.
Pour se faire, nous allons utiliser le tutoriel de Câblage et programmation ainsi que le tutoriel d'assemblage du LittleBot. TUTO EN COURS DE RÉDACTION
Puis nous allons programmer notre robot pour vérifier son fonctionnement via le tutoriel de Câblage et programmation.
Une fois ceci fait nous assemblons complètement notre robot. Il ne manque plus qu'à le brancher et le faire tourner !
Lors de notre seconde séance nous allons rectifier / améliorer notre robot.
Avec le code que nous avons donné à notre carte, le robot ne tourne que dans un sens lors de la rencontre d'un obstacle.
Nous allons donc améliorer le programme pour rendre la direction aléatoire. Pour se faire nous allons utiliser le tutoriel Amélioration du LittleBot.
De plus notre LittleBot étant branché par USB à notre ordinateur, il ne pourrait pas aller bien loin. Nous lui installerons alors une batterie qui se représente ici par une pile. Voici comment la brancher. TUTO EN COURS DE RÉDACTION.
A la fin de ces 2 séances, notre LittleBot est totalement autonome et peu se déplacer pendant des heures. Félicitation !
Fiche Séance 2 - 1H30
Introduction aux servo-moteurs
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience avec les composants de base Arduino
- Bases de la Programmation Arduino IDE
- Animation
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- MBlock et Arduino IDE installés
- configuration port série et modèle carte
- MBlock et Arduino IDE installés
- arduino Nano + Sensor shield + servomoteur
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un servo-moteur ?"
- Tutoriel branchement
- Check-list composants présents dans la boite. Pour vérification en début et en fin de séance.
Fiche participant
Objectifs
Compétences techniques :
- Prendre en main servo et Logiciel
- Faire tourner un servo moteur
Savoir-être, compétences transversales :
- Travail individuel
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Débrancher et ranger les composants
- Chaque participant vérifie la boite du voisin (check-list)
- Remettre ordinateur dans l'état initial
- Programme de la prochaine séance
Qu'est ce qu'un servo-moteur ?
I Introduction
Lorsque vous créez un projet qui intègre des éléments robotique vous arrivez forcément à devoir faire un choix de moteur pour automatiser votre création. Plusieurs solutions existent, comme par exemple des moteurs à courant continu:
Ceux-ci ont l'avantage d'être très simple d'utilisation. Il suffit de connecter leurs deux fil d'alimentation à une batterie et ils se mettent à tourner.
Une autre solution serait d'utiliser des moteurs pas à pas :
Ces moteurs sont très pratique pour déplacer quelque-chose à un endroit précis, du fait que vous pouvez précisément le positionner à un angle donné. Par contre leur utilisation n'est pas aussi triviale que pour un moteur à courant continu.
Ce que je vous propose dans ce tutoriel c'est de découvrir les Servomoteurs. il en existe deux type :
- A contrôle d'angle
- A contrôle de vitesse de rotation
Les premiers ne tournent pas en continu, mais en général entre 0° et 180° et vous pouvez contrôler leur angle de rotation. Très pratique quand vous voulez faire un bras robotisé, piloter l’orientation des roues avant d'une voiture, ou bien contrôler un petit mécanisme. Les Servomoteurs suivants sont très pratiques lorsque vous souhaitez faire tourner un objet en contrôlant sa vitesse, par exemple des roues! :
Ce sont des Servomoteurs à contrôle d'angle sur 180° et le tutoriel va donc porter sur ce type de moteur.
II Fonctionnement
https://fr.wikipedia.org/wiki/Servomoteur --> fonctionnement
Les Servomoteurs intègrent au sein d'un même boitier un moteur à courant continu, un potentiomètre, un réducteur et un circuit de contrôle. L'idée est que la valeur d'angle est mesurée grâce au potentiomètre et le circuit de contrôle fait tourner le moteur et corrige l'orientation. Voila une image qui donne une idée du fonctionnement interne:
Vous l'avez surement remarqué, le Servomoteur a trois fils. Le fil marron correspond à la masse, le fil rouge au 5 Volts et le fil orange à l'envoi de données. C'est par le fil orange que nous allons envoyer le signal pour la commande de l'angle voulu au Servomoteur.
L’instruction par le fil orange s'envoie sous la forme d'un signal PWM (Pulse Width modulation=Modulation en largeur d'impulsion). Le principe est que l'envoi d'instruction se fait par un signal électrique qui passe de façon régulière et rapide (30-50Hz ou 300Hz) de 0 à 5 Volts. La valeur de l'angle voulu est définie par le rapport entre le temps où le signal est à 5 Volts et le temps où celui-ci est à 0 Volt. Par exemple pour un angle de 0°, on envoie 5V pendant 1ms puis 0V pendant 19ms : Le signal est à 5V pendant 5% du temps (1ms/20ms). Une image vous donnera une meilleure idée:
III Mise en pratique
Pour consolider votre compréhension nous allons mettre en pratique avec un Arduino. L'Arduino permet de générer des signaux PWM avec la fonction AnalogWrite() mais nous ne pouvons pas l'utiliser avec un Servomoteur, car sa fréquence est trop élevée (environ 500Hz). Pour ce faire nous allons plutôt utiliser la librairie servo.h qui est disponible de base avec le programme Arduino.
Connectez d'abord un Servomoteur à l'Arduino comme sur l'image:
et on utilisera pour l'exemple le code suivant
#include <Servo.h>
Servo myservo; // On créé un objet MyServo par lequel on envoie les instructions au servo
void setup()
{
pinMode(6,OUTPUT);
myservo.attach(6); // On associe notre objet au Pin connecté au fil de données du servo
}
void loop()
{
myservo.write(0); //donne l'ordre de mettre le Servo à son angle minimum
delay(1000);
myservo.write(255); //donne l'ordre de mettre le Servo à son angle maximum
delay(1000);
}
Si tout se passe bien, vous devriez voir le Servomoteur tourner de 180° toutes les secondes. Après ça, je vous conseille de vous amuser en modifiant les valeurs et/ou le code afin de vous familiariser avec son utilisation.
Vous savez maintenant le minimum nécessaire pour correctement utiliser un Servomoteur.
Piloter un servomoteur avec Mblock
I/ Introduction
Pour ce faire nous allons utiliser Mblock.
Après avoir lancé le logiciel, nous allons ajouter la carte que nous utilisons :
Cliquez sur "Ajouter".
Puis sur la carte qui nous intéresse, ici c'est l'Arduino Nano.
Puis cliquez sur connecter, cette fenêtre s'ouvrira.
Cochez "Afficher tous les appareils disponibles", puis selectionnez le port COM de votre carte.
Votre carte Arduino est maintenant connectée au logiciel.
II/ Branchement du servo
III/ Code
Fiche Séance 3 - 1H30
Introduction au capteur à ultrasons
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience avec les composants de base Arduino
- Bases de la Programmation Arduino IDE
- Animation
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- MBlock et Arduino IDE installés
- configuration port série et modèle carte
- MBlock et Arduino IDE installés
- Capteur à ultrasons (HC-SR04) + carte Sensor shield + arduino Nano + X cables dupont
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un capteur à ultrasons ?"
- Check-list composants présents dans la boite. Pour vérification en début et en fin de séance.
Fiche participant
Objectifs
Compétences techniques :
- Introduction générale, objectifs du club et du cycle 1
- Prendre en main capteur ultrasons
- Faire tourner un servo selon une distance
Savoir-être, compétences transversales :
- Travail individuel
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Débrancher et ranger les composants
- Chaque participant vérifie la boite du voisin (check-list)
- Remettre ordinateur dans l'état initial
- Programme de la prochaine séance
Qu'est ce qu'un capteur à ultrasons ?
HC-SR04 est un capteur à ultrasons qui est principalement utilisé pour la mesure de distance. En émettant des ondes ultrasonores et en mesurant le temps pris par ces ondes pour rebondir après avoir frappé un objet, le HC-SR04 peut déterminer avec précision la distance à laquelle cet objet se trouve. De par son coût abordable et sa facilité d’intégration avec des plateformes telles qu’Arduino, le HC-SR04 est devenu un choix prisé parmi les amateurs de bricolage et les professionnels.
Principe de fonctionnement
Le fonctionnement d'un capteur à ultrason comme le HC-SR04 est assez simple. Il comporte deux éléments principaux : un émetteur ultrasonore et un récepteur ultrasonore. Voici les étapes clés du fonctionnement du capteur :
- Lorsque le capteur est alimenté, l’émetteur envoie une série de 8 impulsions ultrasoniques de 10µs à une fréquence spécifique (généralement de 40 kHz).
- Lorsque une impulsion sonore atteint un objet, elle rebondit et est renvoyée vers le récepteur ultrasonore comme un écho.
- Le capteur mesure le temps entre le moment où l’impulsion a été émise et celui où l’écho a été reçu.
- En utilisant la vitesse connue du son dans l’air (environ 343 m/s ou 34,3 cm/µs) et la durée de l’écho mesurée, le capteur calcule la distance jusqu’à l’objet en utilisant la formule : distance = (durée de l’écho / 2) * vitesse du son.
- Le résultat est ensuite converti en une distance numérique et envoyé au Arduino via une sortie numérique
Description du capteur HC-SR04
Broche | Description |
---|---|
VCC | Il s’agit de la broche d’alimentation. Elle nécessite généralement une entrée de 5V Courant Continu, la rendant directement compatible avec des cartes comme Arduino. |
Trig (Déclenchement) | Cette broche est utilisée pour initier le capteur à émettre une onde ultrasonore. En envoyant une impulsion haute d’au moins 10µs à cette broche, le HC-SR04 émettra une série de 8 impulsions d'ultrasons à 40 kHz. |
Echo | Une fois l’onde ultrasonore émise et qu’elle rebondit après avoir frappé un objet, la broche Echo fournit une impulsion de sortie. La largeur de cette impulsion est proportionnelle à la distance de l’objet par rapport au capteur. En mesurant la durée de cette impulsion, Arduino peut déterminer la distance jusqu’à l’objet. |
GND (Masse) | Cette broche est connectée à la masse du circuit. |
Le câblage :
Pour connecter le capteur HC-SR04 à une carte Arduino, suivez ces étapes :
- Connectez la broche VCC du HC-SR04 à la broche 5V sur la carte arduino uno. Cela assure que le capteur reçoive la puissance nécessaire pour son fonctionnement.
- Reliez la broche GND (Masse) du HC-SR04 à l’une des broches de masse (GND) d’Arduino. Cela établit une masse électrique commune entre le capteur et arduino.
- Connectez la broche Trig du HC-SR04 à une broche numérique d’Arduino, par exemple, la broche D12. Cette broche est responsable de l’envoi d’un signal pour déclencher le capteur afin qu’il émette les ondes ultrasonores.
- Reliez la broche Echo du HC-SR04 à une autre numérique sur l’Arduino, comme la broche D11. Cette broche détecte l’onde ultrasonore écho après réflexion sur un objet.
Programmer un HC-SR04
Ce code permet de mesurer une distance et de l'afficher sur le serial print du logiciel Arduino IDE.
// définition des numéros de broches
const int trigPin = 12;
const int echoPin = 11; // définition des variables
long duration;
int distance;
void setup()
{
pinMode(trigPin, OUTPUT); // Définit le trigPin comme sortie
pinMode(echoPin, INPUT); // Définit le echoPin comme entrée
Serial.begin(9600); // Commence la communication série
}
void loop()
{
// Efface le trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2); // Met le trigPin à l'état HIGH pendant 10 microsecondes
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW); // Lit le echoPin, renvoie le temps de trajet de l'onde sonore en microsecondes
duration = pulseIn(echoPin, HIGH); // Calcul de la distance
distance = duration * 0.034 / 2; // La vitesse du son est d'environ 0.034 cm par microseconde
Serial.print(“Distance: “); // Affiche la distance sur le moniteur série
Serial.println(distance);
}
Source :
https://www.moussasoft.com/hc-sr04-capteur-ultrason-avec-arduino
Fiche Séance 4 - 1H30
Introduction au logiciel de modélisation 3D (TinkerCad)
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
- Connaissance de TinkerCad
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience avec la modélisation
- bases de l'informatique
- Animation
Matériels nécessaires
logiciel, modélisation, mécanique, outils, matériaux,
- 12 PCs (1 par participant)
- Compte enseignant pour animateur et création de compte élève pour les utilisateurs
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un capteur à ultrasons ?"
A MODIFIER
Fiche participant
Objectifs
Compétences techniques :
- Introduction générale à la modélisation 3D
- Prendre en main le logiciel TinkerCad
- Faire des modifications sur un fichier donnée
Savoir-être, compétences transversales :
- Travail individuel
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Eteindre les PC
- Eteindre les PC
- Programme de la prochaine séance
Fiche Séance 5 - 1H30
Introduction au logiciel de modélisation 3D (TinkerCad)
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
- Connaissance de TinkerCad
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience avec la modélisation
- bases de l'informatique
- Animation
Matériels nécessaires
logiciel, modélisation, mécanique, outils, matériaux,
- 12 PCs (1 par participant)
- Compte enseignant pour animateur et création de compte élève pour les utilisateurs
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un capteur à ultrasons ?"
A MODIFIER
Fiche participant
Objectifs
Compétences techniques :
- Introduction générale à la modélisation 3D
- Prendre en main le logiciel TinkerCad
- Faire des modifications sur un fichier donnée
Savoir-être, compétences transversales :
- Travail individuel
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Eteindre les PC
- Eteindre les PC
- Programme de la prochaine séance
Fiche Séance 6 - 1H30
Introduction à l'impression 3D
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience avec la modélisation
- Connaissance de l'impression 3D
- bases de l'informatique
- Animation
- Utilisation de Kahoot
Matériels nécessaires
logiciel, modélisation, mécanique, outils, matériaux,
- 12 PCs (1 par participant)
- Avec un slicer
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un capteur à ultrasons ?"
A MODIFIER
Fiche participant
Objectifs
Compétences techniques :
- Introduction générale à la modélisation 3D
- Savoir identifier de l'impression 3D
- Prendre en main logiciel un slicer (creality slicer)
- Faire des modifications sur un fichier donnée
Savoir-être, compétences transversales :
- Travail individuel
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Eteindre les PC
- Eteindre les PC
- Programme de la prochaine séance
Fiche Séance 7 - 1H30
Introduction à l'impression 3D
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
- Travail sur imprimante
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience avec la modélisation
- Connaissance de l'impression 3D
- bases de l'informatique
- Animation
Matériels nécessaires
logiciel, modélisation, mécanique, outils, matériaux,
- 6 PCs (1 pour deux participant)
- Avec un slicer
- 3 imprimante 3D
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un capteur à ultrasons ?"
A MODIFIER
Fiche participant
Objectifs
Compétences techniques :
- Ré-introduction générale à la modélisation 3D
- Reprendre en main logiciel un slicer (creality slicer)
- Optimiser l'impression de pièce
- Préparer un imprimante 3D à l'impression (calibrage, charger du filament)
Savoir-être, compétences transversales :
- Travail en duo
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Eteindre les PC
- Eteindre les PC
- Programme de la prochaine séance
Fiche Séance 8 - 1H30
Introduction à l'impression 3D
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
- Travail sur robot
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience en programmation et électronique Arduino
- bases de l'informatique
- Animation
Matériels nécessaires
logiciel, modélisation, mécanique, outils, matériaux,
- 6 PCs (1 pour deux participant)
- Avec Arduino IDE
- Structure robot LittleBot
- Matériel Arduino (Arduino nano, Sensor Shield, Capteur ultrason, 2 servo moteur 360) * par le nombre de groupe
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un capteur à ultrasons ?"
A MODIFIER
Fiche participant
Objectifs
Compétences techniques :
- Ré-introduction générale à la programmation Arduino
- Comprendre la cinématique du robot
- Assembler le robot
- Résoudre les problèmes de programmation
Savoir-être, compétences transversales :
- Travail en duo
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Eteindre les PC
- Eteindre les PC
- Programme de la prochaine séance
Fiche Séance 9 - 1H30
Adaptation au contrainte du cahier des charges
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
- Travail sur robot
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience en CAO sur Tinker CAD
- bases de l'informatique
- Animation
Matériels nécessaires
logiciel, modélisation, mécanique, outils, matériaux,
- 10 PCs (1 par participant)
- Internet et comtpe Tinker CAD
- Structure robot LittleBot
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un capteur à ultrasons ?"
A MODIFIER
Fiche participant
Objectifs
Compétences techniques :
- Ré-introduction générale à la modélisation sur Tinker CAD
- Comprendre le cahier des charges du Littlebot
- Modifier un modèle 3D pour le rendre utilisable
Savoir-être, compétences transversales :
- Travail en autonomie
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Eteindre les PC
- Eteindre les PC
- Programme de la prochaine séance
Câblage et programmation du LittleBot
Le câblage
Pour le câblage et la programmation du LittleBot, il nous faut :
- Un Arduino Nano (ou équivalant)
- Un Sensor Shield
- Un capteur à ultrason (HC-SR04)
- 2 Servomoteur / Moteur (DM-S0090D)
Le branchement ce présente comme ceci :
- Tout d'abord nous branchons l'Arduino Nano sur notre Sensor Shield. Attention, il y a un sens. Le port de charge doit être sur l'extérieur de votre Shield.
- Nous allons a présent brancher notre capteur à ultrason :
- VCC sur une pin 5V.
- Trig sur la pin 6.
- Echo sur la pin 7.
- GND sur une pin GND
3. Nous allons brancher nos Servomoteur, les câbles de nos servo sont tous reliés à un raccord. Celui ci ne peut être branché que dans un seul sens. Nou brancherons donc un servo sur la pin 10 et un servo sur la pin 11.
- Le fil marron sur la pin G
- Le fil rouge sur la pin V
- Le fil orange sur la pin S
Ainsi le servo qui est sur la pin 10 sera notre roue droite et le Servo sur la pin 11 sera notre roue gauche.
Votre câblage est terminé.
Passons maintenant à la programmation.
Le programme
Ici nous décomposerons notre programme pour bien l'écrire.
Tout d'abord, nous déclarons la librairie et les servo que nous utiliserons :
#include <Servo.h>
#define trigPin 6
#define echoPin 7
Servo servo1;
Servo servo2;
Puis nous déclarons sur quelles pins sont branchés nôtre capteur et nos servo :
void setup() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
servo1.attach(11);
servo2.attach(10);
}
Rentrons dans le vive du sujet :
void loop() {
long duration, distance; // Nous déclarons notre variable que nous retrouverons plus tard
digitalWrite(trigPin, LOW); //Ici notre capteur à ultrason est en "position 0"
delayMicroseconds(2); // Pendant 2 Microsecondes
digitalWrite(trigPin, HIGH); //Ici notre capteur à ultrason est "activé"
delayMicroseconds(10); //Pendant 10 Microsecondes
digitalWrite(trigPin, LOW); //Puis nous le retournons en position "0"
duration = pulseIn(echoPin, HIGH); // Nous déclarons notre variable "duration" qui est la durée du trajet du son.
distance = (duration*0.034) / 2; // Nous déclarons notre variables "distance" par la duréé multiplié par la vitesse du son le tout divisé par 2.
if (distance < 20) { // Nos déplacement commence ici, "Si la distance est inférieur à 20cm alors..."
servo1.writeMicroseconds(1000);//Servo Gauche tourne à l'envers
servo2.writeMicroseconds(2000);//Servo Droit tourne à l'envers
delay (2000);// pendant 2 sec
servo1.writeMicroseconds(1000);//Servo Gauche tourne à l'envers
servo2.writeMicroseconds(1500);//Arrêt du Servo Droit
delay (2000);// pendant 2 sec
}
else { //Sinon...
servo1.writeMicroseconds(2000);//Servo Gauche tourne
servo2.writeMicroseconds(1000);//Servo Droit tourne
delay (2000);// pendant 2 sec
}
}
Puis nous assemblons le tout, voici à quoi cela devrait ressembler :
#include <Servo.h>
#define trigPin 6
#define echoPin 7
Servo servo1;
Servo servo2;
void setup() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
servo1.attach(11);
servo2.attach(10);
}
void loop() {
long duration, distance;
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration*0.034) / 2;
if (distance < 20) {
servo1.writeMicroseconds(1000);
servo2.writeMicroseconds(2000);
delay (2000);
servo1.writeMicroseconds(1000);
servo2.writeMicroseconds(1500);
delay (2000);
}
else {
servo1.writeMicroseconds(2000);
servo2.writeMicroseconds(1000);
delay (2000);
}
}
Apprendre à utiliser TinkerCad (classe)
Utiliser Tinkercad
TinkerCad est un "logiciel" de modélisation 3D simple d'utilisation.
Il permet aussi de programmer et de créer des câblages avec des Arduino numérique.
Tout d'abord il vous faudra, avec un compte enseignant, créer une classe sur le site web : https://www.tinkercad.com/
Dans ce tuto nous allons apprendre les bases de ce logiciel avec la fonction perçage.
Voici les étapes pour que les utilisateurs puisse se connecter à la classe.
Rejoindre une classe
La première étapes sera d'aller sur le site web https://www.tinkercad.com/joinclass.
Puis d'entrer le code de classe fourni par le professeur.
Nous allons utilisé un pseudo prédéfini par le professeur.
Programme MBLOCK
Club Robotique collège Cycle 2 - Station de mesure (T°, H)
Phase 1 Conception (2 séances)
Phase 1 - Conception
Objectifs
Compétences techniques:
-
Introduction générale à la modélisation 3D
-
Prendre en main le logiciel TinkerCad
-
Modéliser un boîtier pour le capteur
Savoir-être, compétences transversales:
-
Travail individuel
-
Lire un tutoriel détaillé
Déroulement de la séance:
-
Consignes: Sécurité, précautions matériel
-
Travail individuel.
-
Rappel: Tout est fragile.
-
-
Phases et méthodes d’animation a. Présentation de l'activité du jour
-
Objectifs rappelés.
-
Importance de la modélisation 3D dans le projet.
-
-
Prendre en main le logiciel TinkerCad
-
Démonstration interactive.
-
Manipulation guidée des outils de base.
-
-
La conception du fichier :
Création du Boîtier Principal:
-
Ouvrir TinkerCad et démarrer un nouveau projet.
-
Placer un cube de base de 7.5*5.8*3 cm depuis la bibliothèque d'objets.
-
Ajouter un deuxième cube de 7.3*5.6*2.8 cm.
-
Venir percer le deuxième cube au premier.
Création du Passage pour le Capteur:
- Choisir une paroi latérale du boîtier.
- Utiliser l'outil "Percage" pour créer un trou rectangulaire de 2*3 cm.
- Placer le trou à l'emplacement souhaité pour le passage du capteur.
Conception du Capot:
- Créer un nouveau cube de 7.3*5.6*0.9 cm au-dessus du boîtier existant.
- Positionner le cube de manière à recouvrir entièrement le boîtier.
- Ajouter un deuxième cube de 7.1*5.4*0.9 cm et venir percer ce dernier au premier grâce à l’outil "perçage".
- Puis ensuite ajouter un cube en dessous de 7.5*5.8*0.1 cm.
Ajustements Finaux:
-
Vérifier l'alignement du capot avec le boîtier principal.
-
Ajuster la position du capot pour qu'il puisse se fermer correctement.
-
Réviser les dimensions et l'agencement global pour assurer la cohérence du design.
Validation et Export:
- Vérifier visuellement la modélisation en 3D pour s'assurer de la conformité avec les spécifications.
- Exporter le modèle au format souhaité pour une utilisation ultérieure (STL, etc.).
Conclusion / Rangement / Démontage:
- Retour sur les notions clés de la séance.
- Q&R pour clarifier les doutes.
- Rangement en fin de séance.
- Éteindre les PC.
Phase 2 - Impression 3D
Phase 2 - Impression 3D
Objectifs :
- Acquérir une introduction à la préparation de modèles pour l'impression 3D.
- Maîtriser l'utilisation du logiciel Cura.
- Préparer un modèle 3D pour l'impression avec les paramètres appropriés.
Compétences techniques :
- Utilisation générale de la préparation pour l'impression 3D.
- Utilisation spécifique du logiciel Cura.
Savoir-être et compétences transversales :
- Capacité à suivre des instructions détaillées.
Déroulement de la séance :
- Consignes de sécurité et précautions matérielles.
- Travail individuel.
- Présentation de l'activité du jour, rappel des objectifs.
- Démonstration interactive de l'utilisation du logiciel Cura.
- Importation du fichier STL exporté depuis TinkerCad dans Cura.
- Configuration des paramètres d'impression :
- Sélection d'une qualité standard.
- Activation des supports pour les parties surplombantes.
- Réglage des autres paramètres selon les besoins spécifiques du projet.
- Aperçu du modèle dans l'environnement d'impression.
- Vérification de la disposition du modèle sur le plateau d'impression.
- Prévisualisation des supports générés par Cura.
- Ajustements éventuels des paramètres pour optimiser l'impression.
- Génération du code G pour l'imprimante 3D.
- Exportation du fichier prêt pour l'impression.
Conclusion / Rangement :
- Récapitulation des points clés de la séance.
- Rangement du matériel en fin de séance.
Dans cette phase, les participants vont apprendre à préparer leur modèle 3D pour l'impression en utilisant le logiciel Cura. Ils vont importer leur fichier STL, ajuster les paramètres d'impression, générer le code pour l'imprimante 3D et exporter le fichier prêt pour l'impression. Si des questions se posent ou si vous avez besoin de plus d'informations, n'hésitez pas à demander !
Phase 3 - Câblage et Programmation
Phase 3 - Câblage et Programmation de la station
Objectifs
Compétences techniques:
- Compréhension du câblage d'un Arduino Nano avec un Sensor Shield et un capteur de température.
- Programmation pour stocker les valeurs de température et d'humidité dans la mémoire de l'Arduino Nano.
Déroulement de la séance
-
Introduction:
- Présentation des éléments nécessaires pour le câblage et la programmation.
- Importance du câblage et de la programmation dans le projet de station météo.
-
Câblage:
-
Programmation:
- Télécharger la librairie Arduino DHT de Adafruit https://www.arduino.cc/reference/en/libraries/dht-sensor-library/
- bien installer la dépendance Adafruit Unified Sensor
- Télécharger la librairie Arduino DHT de Adafruit https://www.arduino.cc/reference/en/libraries/dht-sensor-library/
-
- Déclaration des librairies nécessaires et des adresses de stockage dans la mémoire EEPROM.
-
#include <DHT.h> #include <EEPROM.h> #define DHTPIN 2 // La broche à laquelle le capteur DHT est connecté #define DHTTYPE DHT22 // Type de capteur DHT (DHT11 dans cet exemple) void setup(){ Serial.begin(9600); } DHT dht(DHTPIN, DHTTYPE); int adresseEEPROM = 0; // Adresse de la mémoire EEPROM pour stocker la température (partie entière) int adresseDecimaleEEPROM = 1; // Adresse suivante pour stocker la partie décimale int adresseHumiditeEEPROM = 2; // Adresse suivante pour stocker l'humidité (partie entière) int adresseDecimaleHumiditeEEPROM = 3; // Adresse suivante pour stocker la partie décimale de l'humidité
- Fonctionnement de la fonction loop pour mesurer la température et l'humidité.
- Stockage des valeurs dans la mémoire EEPROM avec gestion des adresses.
- Réinitialisation des adresses lorsque la mémoire est pleine.
-
void loop() { // Mesurer la température et l'humidité float temperature = dht.readTemperature(); float humidite = dht.readHumidity(); // Vérifier si les mesures sont valides if (!isnan(temperature) && !isnan(humidite)) { // Stocker la température en interne (partie entière à adresse, partie décimale à adresseDecimaleEEPROM) EEPROM.write(adresseEEPROM, int(temperature)); EEPROM.write(adresseDecimaleEEPROM, int((temperature - int(temperature)) * 100)); // Stocker l'humidité en interne (partie entière à adresseHumiditeEEPROM, partie décimale à adresseDecimaleHumiditeEEPROM) EEPROM.write(adresseHumiditeEEPROM, int(humidite)); EEPROM.write(adresseDecimaleHumiditeEEPROM, int((humidite - int(humidite)) * 100)); // Incrémenter les adresses pour la prochaine mesure adresseEEPROM += 4; // Incrémenter de 4 pour laisser un espace pour la prochaine paire (température et humidité) adresseDecimaleEEPROM += 4; adresseHumiditeEEPROM += 4; adresseDecimaleHumiditeEEPROM += 4; // Vérifier si nous avons atteint la fin de l'espace EEPROM if (adresseEEPROM >= EEPROM.length()) { adresseEEPROM = 0; // Revenir au début de l'espace EEPROM adresseDecimaleEEPROM = 1; // Commencer à l'adresse suivante pour la partie décimale de la température adresseHumiditeEEPROM = 2; // Commencer à l'adresse suivante pour la partie entière de l'humidité adresseDecimaleHumiditeEEPROM = 3; // Commencer à l'adresse suivante pour la partie décimale de l'humidité } } else { Serial.println("Erreur de lecture du capteur."); } // Attendre avant la prochaine mesure delay(600000); // Attendre temps de secondes entre les mesures (ajustez selon vos besoins) }0
- Maintenant il nous faut le code pour lire les valeurs stockées.
#include <EEPROM.h> int adresseEEPROM = 0; // Adresse de la mémoire EEPROM pour la lecture des données void lireDonneesEEPROM() { Serial.println("Lecture des données depuis l'EEPROM:"); while (adresseEEPROM < EEPROM.length()) { // Lire la partie entière de la température int partieEntiereTemperature = EEPROM.read(adresseEEPROM); // Lire la partie décimale de la température int partieDecimaleTemperature = EEPROM.read(adresseEEPROM + 1); // Lire la partie entière de l'humidité int partieEntiereHumidite = EEPROM.read(adresseEEPROM + 2); // Lire la partie décimale de l'humidité int partieDecimaleHumidite = EEPROM.read(adresseEEPROM + 3); // Afficher les valeurs lues Serial.print("Température: "); Serial.print(partieEntiereTemperature); Serial.print("."); Serial.print(partieDecimaleTemperature); Serial.print(" °C, Humidité: "); Serial.print(partieEntiereHumidite); Serial.print("."); Serial.print(partieDecimaleHumidite); Serial.println(" %"); // Incrémenter l'adresse pour la prochaine paire de valeurs adresseEEPROM += 4; } } void setup() { Serial.begin(9600); lireDonneesEEPROM(); } void loop() { // Votre code principal ici }
-
Validation:
- Vérification du programme pour s'assurer du bon fonctionnement.
- Test du stockage des valeurs dans la mémoire EEPROM.
-
Conclusion:
- Récapitulation des points clés de la séance.
- Réponses aux questions éventuelles.
Résolution de problèmes
- Si
dht.h
n'est pas reconnu quand vous vérifiez/compilez le fichier, essayer une librairie adaptée à la marque de votre DHT22. Par exemple pour DFRobot : - Cliquer sur Code > Télécharger ZIP https://github.com/CainZ/DHT
- Ajouter la librairie à la main dans ArduinoIDE
- Vérifier la bonne installation de la librairie, dans "contributed libraries"
Club Robotique Cycle 3 - Voiture RC
Phase 1 - Conception 2D et 3D - ? x 1h30
Conception 2D et 3D avec TinkerCad et OnShape
Prérequis participant :
- Travail sur ordinateur
- Travail sur feuille
- Manipulation avec la souris (clic droit, clic gauche, sélection,...)
- Manipulation de fourniture (crayon, gomme...)
Compétences Animateur :
Compétences techniques et soft skills :
- Pratique du logiciel TinkerCAD et du logiciel OnShape
- Comprendre et savoir utiliser une mise en plan
- Animation
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- Connexion et navigateur internet (Firefox)
- Session invité ou nominative
- Connexion et navigateur internet (Firefox)
- 12 moteurs à courant continue / dimensions des moteurs
- 24 Feuilles blanches
- 12 crayons de papier
- 12 gommes
- 5 tailles crayons
- 12 règles
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation / Tutoriels :
- Tutoriel animateur TinkerCAD - création d'une activité
- Tutoriel élève TinkerCAD - modélisation d'une pièce
- Tutoriel animateur OnShape - création d'une activité
- Tutoriel élève OnShape - modélisation d'une pièce
Déroulement de la séance
Nous allons donc créer notre châssis, pour commencer voici la forme ainsi que les cotations de notre pièce.
Puis une extrusion sur 3mm.
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Débrancher et ranger les composants et les fournitures
- Chaque participant vérifie la boite du voisin (check-list)
- Remettre l'ordinateur dans l'état initial
- Débrancher et ranger les composants et les fournitures
- Programme de la prochaine séance
Phase 2 - Électronique et programmation
Prérequis participant :
- Travail sur ordinateur
- Manipulation avec la souris (clic droit, clic gauche, sélection,...)
- Manipulation de composant électronique (composant, câble...)
Compétences Animateur :
Compétences techniques et soft skills :
- Pratique du logiciel Arduino IDE
- Comprendre et savoir un langage de programmation
- Animation
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- Connexion et navigateur internet (Firefox)
- Session invité ou nominative
- Connexion et navigateur internet (Firefox)
- 12 moteurs à courant continue
- 12 module de contrôle L9110S
- 12 module Bluetooth HC-05
- Câble Dupont
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation / Tutoriels :
Déroulement de la séance
Conclusion / Rangement / Démontage :
Moteur CC - Principe de fonctionnement
Explication du moteur à courant continue :
https://www.youtube.com/watch?v=JV50zqHvqAM&list=PLKLRexlzHZepqmJXVM3Kq52xCRRqlOZ0H
Câblage et programmation avec Module L9110S :
https://www.robot-maker.com/shop/blog/32_Utilisation-des-encodeurs.html
Câblage et programmation sans Module L9110D :
https://wiki.dfrobot.com/Micro_DC_Motor_with_Encoder-SJ01_SKU__FIT0450
Moteur CC - Commande de moteur à courant continu
Moteur à courant continu "moteur jaune"
https://seafile.unistra.fr/d/16f415226d224af5bd8f/
\Seafile\Reseau_FabLab_Alsace_Nord\01_Robotique_Educative
Module de contrôle L9110S
Montage :
https://arduino.blaisepascal.fr/controleur-l9110s/
#define moteurA_1 5
#define moteurA_2 6
#define moteurB_1 10
#define moteurB_2 11
int vitesseA = 255; // 0 à 255
int vitesseB = 255; // 0 à 255
void setup() {
// Configuration des ports en mode "sortie"
pinMode(moteurA_1, OUTPUT);
pinMode(moteurA_2, OUTPUT);
pinMode(moteurB_1, OUTPUT);
pinMode(moteurB_2, OUTPUT);
}
void loop() {
digitalWrite(moteurA_1, LOW);
analogWrite(moteurA_2, vitesseA);
digitalWrite(moteurB_1, LOW);
analogWrite(moteurB_2, vitesseB);
delay(2000);
analogWrite(moteurA_1, vitesseA);
digitalWrite(moteurA_2, LOW);
analogWrite(moteurB_1, vitesseB);
digitalWrite(moteurB_2, LOW);
delay(2000);
digitalWrite(moteurA_1, LOW);
digitalWrite(moteurA_2, LOW);
digitalWrite(moteurB_1, LOW);
digitalWrite(moteurB_2, LOW);
delay(3000);
}
Module de contrôle L298
Attention le module entraîne une chute de tension d'environ 3V. Donc si vous voulez délivrer 5V à vos moteurs à courant continu il faudra une alimentation de 8V.
https://arduino.blaisepascal.fr/pont-en-h-l298n/
// Pont en H L298N
//Ports de commande du moteur B
int motorPin1 = 10;
int motorPin2 = 11;
int enablePin = 5;
// Vitesse du moteur
int state = 55;
void setup() {
// Configuration des ports en mode "sortie"
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(enablePin, OUTPUT);
// Initialisation du port série
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0)
{
// Lecture de l'entier passé au port série
state = Serial.parseInt();
//
// Sens du mouvement
//
if (state > 0) // avant
{
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
Serial.print("Avant ");
Serial.println(state);
}
else if (state < 0) // arrière
{
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
Serial.print("Arriere ");
Serial.println(state);
}
else // Stop (freinage)
{
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, HIGH);
Serial.println("Stop");
}
//
// Vitesse du mouvement
//
analogWrite(enablePin, abs(state));
}
delay(100);
}
PWM
https://arduino.blaisepascal.fr/conversion-numeriqueanalogique-pwm/
Moteur CC - Contrôler la vitesse avec une roue encodeuse
Utilisation des encodeurs
https://wiki.dfrobot.com/Micro_DC_Motor_with_Encoder-SJ01_SKU__FIT0450
- Installer Arduino PID depuis le gestionnaire de librairies
//source Sample Code 2 https://wiki.dfrobot.com/Micro_DC_Motor_with_Encoder-SJ01_SKU__FIT0450#target_3
//The sample code for driving one way motor encoder
#include <PID_v1.h>
const byte encoder0pinA = 2;//A pin -> the interrupt pin 0
const byte encoder0pinB = 3;//B pin -> the digital pin 3
// int E_left =5; //The enabling of L298PDC motor driver board connection to the digital interface port 5
// int M_left =4; //The enabling of L298PDC motor driver board connection to the digital interface port 4
int MOTEUR_A_1 =5; //Connexion du pilote de moteur CC l9110s au port digital 5
int MOTEUR_A_2 =6; //Connexion du pilote de moteur CC l9110s au port digital 6
byte encoder0PinALast;
double duration,abs_duration;//the number of the pulses
boolean Direction;//the rotation direction
boolean result;
double val_output;//Power supplied to the motor PWM value.
double Setpoint;
double Kp=0.6, Ki=5, Kd=0;
PID myPID(&abs_duration, &val_output, &Setpoint, Kp, Ki, Kd, DIRECT);
void setup()
{
Serial.begin(9600);//Initialize the serial port
pinMode(MOTEUR_A_1, OUTPUT); //L298P Control port settings DC motor driver board for the output mode
pinMode(MOTEUR_A_2, OUTPUT);
Setpoint =80; //Set the output value of the PID
myPID.SetMode(AUTOMATIC);//PID is set to automatic mode
myPID.SetSampleTime(100);//Set PID sampling frequency is 100ms
EncoderInit();//Initialize the module
}
void loop()
{
advance();//Motor Forward
abs_duration=abs(duration);
result=myPID.Compute();//PID conversion is complete and returns 1
if(result)
{
Serial.print("Pluse: ");
Serial.println(duration);
duration = 0; //Count clear, wait for the next count
}
}
void EncoderInit()
{
Direction = true;//default -> Forward
pinMode(encoder0pinB,INPUT);
attachInterrupt(0, wheelSpeed, CHANGE);
}
void wheelSpeed()
{
int Lstate = digitalRead(encoder0pinA);
if((encoder0PinALast == LOW) && Lstate==HIGH)
{
int val = digitalRead(encoder0pinB);
if(val == LOW && Direction)
{
Direction = false; //Reverse
}
else if(val == HIGH && !Direction)
{
Direction = true; //Forward
}
}
encoder0PinALast = Lstate;
if(!Direction) duration++;
else duration--;
}
void advance()//Motor Forward
{
digitalWrite(MOTEUR_A_1,LOW);
analogWrite(MOTEUR_A_2,val_output);
}
void back()//Motor reverse
{
digitalWrite(MOTEUR_A_1,HIGH);
analogWrite(MOTEUR_A_2,val_output);
}
void Stop()//Motor stops
{
digitalWrite(MOTEUR_A_2, LOW);
}
Avec la librairie Motor PID
https://github.com/natnqweb/Motor_PID
Interruptions
https://www.best-microcontroller-projects.com/arduino-interrupt.html
https://forum.arduino.cc/t/solved-arduino-nano-and-interrupt-on-pin-6/1090623/3
Sources
https://www.robot-maker.com/shop/blog/32_Utilisation-des-encodeurs.html
Le module Bluetooth HC-05
Test et configuration du module
- Suivre les instructions pour le module HC-05, qui peut être configuré en module maître ou esclave. Le module HC-06 lui ne peut être que esclave, mais il est plus simple à configurer.
https://www.aranacorp.com/fr/votre-arduino-communique-avec-le-module-hc-05/
- On peut communiquer avec le module bluetooth HC-05 via la liaison série de l'Arduino Nano
- Se renseigner sur ce qu'est une liaison série, par ex. ici : https://arduino.blaisepascal.fr/bibliotheque-serial/
- Réaliser le câblage entre l'Arduino Nano et le module bluetooth HC-05
- Bien vérifier que le Pin qui Reçoit les données sur l'Arduino (RxDpin) soit connecté au Pin du HC-05 qui Tansmet (TxDpin). Et vice-versa, donc chaque câble transmet les données dans une direction opposée.
-
Si on prend les Pins RX (Digital 0) et TX (Digital 1) de l'arduino pour connecter RXD et TXD du HC-05, cela rentre en conflit avec la connexion USB entre l'arduino et le PC.
-
Donc on prend les Pins Digital 2 et 3 et on utilise la bibliothèque
SoftwareSerial
//Test et Configuration du module Bluetooth HC-05
//Le port série matériel de l'Arduino Nano (Pins 0/RX et 1/TX) est déjà utilisé pour la liaison Arduino-USB avec l'ordinateur
//On utilise donc une liaison série logicielle pour la liaison Arduino-HC05 avec le module Bluetooth
#include <SoftwareSerial.h> //Software Serial Port
#define RxDpin 2 //Pin Digital 2 pour arduino Rx (pin0=serial)
#define TxDpin 3 //Pin Digital 3 pour arduino Tx (pin1)
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut configurer le HC-05
//on maintient le bouton à côté de la PIN EN/KEY enfoncé au démarrage de l'Arduino
#define baudrate 38400 //Vitesse pour la liaion Arduino-HC05 en mode configuration
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut communiquer à travers le bluetooth depuis un smartphone,
//on appaire le HC-05 depuis l'appli avec le mot-de-passe par défaut : 1234
// #define baudrate 9600 //Vitesse pour la liaion Arduino-HC05 en mode utilisation smartphone
SoftwareSerial BTSerie(RxDpin,TxDpin);
char caractereTexte;
String phraseTexte;
void setup()
{
Serial.begin(9600); //Vitesse (baudRate) pour la liaison Arduino-USB
delay(500);
Serial.println("En mode communication USB - Pret pour les commandes AT");
Serial.println("Le HC-05 doit clignoter lentement (2 secondes)");
//Configuration de la liaison SoftwareSerial avec le HC-05
pinMode(RxDpin, INPUT); //Configuration du Pin RxD (Receive) en mode entrée
pinMode(TxDpin, OUTPUT); //Configuration du Pin TxD (Transmit) en mode sortie
BTSerie.begin(baudrate); //Vitesse pour la liaion Arduino-HC05
if (baudrate==38400) {
Serial.println("En mode communication USB - Pret pour les commandes AT");
Serial.println("Le HC-05 doit clignoter lentement (2 secondes)");
}
else if (baudrate==9600){
Serial.println("En mode smartphone - Pret pour être appairé");
Serial.println("Le HC-05 doit clignoter rapidement avant d'être appairé");
}
else{
Serial.println("La vitesse de communication (baudrate) a été personnalisée");
}
delay(500);
// Commandes AT pour le HC-05
// BTSerie.print("AT+NAME?"); //Demande le nom du module. Noter le ?
// BTSerie.print("AT+NAME=RCcar-HC-05-1"); //Définir le nom du module.
BTSerie.print("AT+VERSION?"); //Demande le N° de version. Noter le ?
// BTSerie.print("AT+UART?"); //Demande la vitesse série (baudrate). Noter le ?
// BTSerie.print("AT+UART=57600,0,0"); //Définir la vitesse série (baudrate).
// BTSerie.print("AT+ROLE?"); //Demande le mode du module, maitre ou esclave. Noter le ?
// BTSerie.print("AT+PSWD?"); //Demande le mot-de-passe du module. Noter le ?
// La console série de l'ordinateur d'où l'on envoie les commandes AT doit être réglée de telle sorte que
// les fins de ligne soient « les deux, NL et CR », ce qui revient à envoyer \r\n à la fin de chaque commande.
BTSerie.print("\r\n"); // sur HC-05, toutes les commandes doivent se terminer par \r\n
// afficher ce que le module bluetooth répond
Serial.print( BTSerie.read() ); // afficher sur la console ce qui est lu sur BT
// pour AT+VERSION?, c'est le n° de version puis OK qui s'affiche
void loop(){
//On lit ce qui est envoyé à l'Arduino depuis la console via la liaison Serial
readSerialPort();
//Et on l'Arduino l'envoie au HC-05 via la liaison SoftwareSerial
if(phraseTexte!="") BTSerie.println(phraseTexte);
//L'Arduino lit ce que le HC-05 envoie via la liaison SoftwareSerial et l'envoie vers la console
if (BTSerie.available()>0){
Serial.write(BTSerie.read());
}
}
void readSerialPort(){
phraseTexte="";
while (Serial.available()) {
delay(10);
if (Serial.available() >0) {
caractereTexte = Serial.read(); //le port série envoie des caractères de texte octet par octet (byte from serial buffer)
phraseTexte += caractereTexte; //construction d'une phrase en concaténant les caractères reçus
}
}
}
Pilotage d'un moteur CC via bluetooth
//Voiture modélisée radiocommandée (RC car) avec deux moteurs CC à l'arrière et un servomoteur de direction
#include <Servo.h>
Servo myservo; // create servo object to control a servo
//Le port série matériel de l'Arduino Nano (Pins 0/RX et 1/TX) est déjà utilisé pour la liaison Arduino-USB avec l'ordinateur
//On utilise donc une liaison série logicielle pour la liaison Arduino-HC05 avec le module Bluetooth
#include <SoftwareSerial.h> //Software Serial Port
#define RxDpin 2 //Pin Digital 2 pour arduino Rx (pin0=serial)
#define TxDpin 3 //Pin Digital 3 pour arduino Tx (pin1)
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut configurer le HC-05
//on maintient le bouton à côté de la PIN EN/KEY enfoncé au démarrage de l'Arduino
// #define baudrate 38400 //Vitesse pour la liaion Arduino-HC05 en mode configuration
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut communiquer à travers le bluetooth depuis un smartphone,
//on appaire le HC-05 depuis l'appli avec le mot-de-passe par défaut : 1234
#define baudrate 9600 //Vitesse pour la liaion Arduino-HC05 en mode utilisation smartphone
SoftwareSerial BTSerie(RxDpin,TxDpin);
char caractereTexte;
String phraseTexte;
void setup()
{
Serial.begin(9600); //Vitesse (baudRate) pour la liaison Arduino-USB
delay(500);
//Configuration de la liaison SoftwareSerial avec le HC-05
pinMode(RxDpin, INPUT); //Configuration du Pin RxD (Receive) en mode entrée
pinMode(TxDpin, OUTPUT); //Configuration du Pin TxD (Transmit) en mode sortie
BTSerie.begin(baudrate); //Vitesse pour la liaion Arduino-HC05
if (baudrate==38400) {
Serial.println("En mode communication USB - Pret pour les commandes AT");
Serial.println("Le HC-05 doit clignoter lentement (2 secondes)");
}
else if (baudrate==9600){
Serial.println("En mode smartphone - Pret pour être appairé");
Serial.println("Le HC-05 doit clignoter rapidement avant d'être appairé");
}
else{
Serial.println("La vitesse de communication (baudrate) a été personnalisée");
}
delay(500);
pinMode(13,OUTPUT); //left motors forward
pinMode(12,OUTPUT); //left motors reverse
pinMode(11,OUTPUT); //right motors forward
pinMode(10,OUTPUT); //right motors reverse
pinMode(9,OUTPUT); //Led
pinMode(5,OUTPUT); //SG90 steering motor
myservo.attach(5); // attaches the servo on pin 5 to the servo object
}
void loop() {
// Serial.write(blueToothSerial.read());
//On lit caractere par caractere sur la liaion Arduino-USB et on affiche sur la liaison Arduino-HC05
if (Serial.available()) {
caractereTexte = Serial.read();
BTSerie.write(caractereTexte);
// Serial.println("Caractere envoye vers bluetooth : ");
// Serial.println(caractereRecu);
}
//On lit caractere par caractere sur la liaion Arduino-HC05 et on affiche sur la liaison Arduino-USB
if (BTSerie.available()) {
caractereTexte = BTSerie.read();
Serial.print(caractereTexte);
// }
if(caractereTexte == 'F'){ //move forward(all motors rotate in forward direction)
digitalWrite(10,LOW);
digitalWrite(12,LOW);
digitalWrite(13,HIGH);
digitalWrite(11,HIGH);
// myservo.write(90); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'B'){ //move reverse (all motors rotate in reverse direction)
digitalWrite(13,LOW);
digitalWrite(11,LOW);
digitalWrite(12,HIGH);
digitalWrite(10,HIGH);
// myservo.write(90); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'L'){ //turn right (left side motors rotate in forward direction, right side motors doesn'caractereRecu rotate)
digitalWrite(10,LOW);
digitalWrite(12,LOW);
digitalWrite(13,LOW);
digitalWrite(11,HIGH);
// myservo.write(60); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'R'){ //turn left (right side motors rotate in forward direction, left side motors doesn'caractereRecu rotate)
digitalWrite(10,LOW);
digitalWrite(12,LOW);
digitalWrite(11,LOW);
digitalWrite(13,HIGH);
// myservo.write(120); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'S'){ //STOP (all motors stop)
digitalWrite(13,LOW);
digitalWrite(12,LOW);
digitalWrite(11,LOW);
digitalWrite(10,LOW);
// myservo.write(90);
}
delay(100);
}
}
Depuis le clavier de PC
Depuis une application bluetooth de smartphone Android
- Ajouter le HC-05 depuis les paramètres Bluetooth Android
- Rentrer le code PIN
1234
- Démarrer l'Application Bluetooth
- Appuyer sur les flèches / le joystick
- Si les flèches ne fonctionnent pas c'est qu'elles n'envoient pas les bons caractères
- Vous pouvez envoyer directement les caractères via un terminal série d'une Application Bluetooth
Voici les caractères Android :
- F pour Forward : Avancer
- B pour Backward : Reculer
- R pour Right : Aller à droite
- L pour Left : Aller à gauche
- S pour Stop : Arrêter
Voici le fonctionnement du joystick de l'application E&E: Arduino Automation par Engineers & Electronics
- Quand on appuie sur la flèche du haut, le caractère
F
(objetchar
) est envoyé par le téléphone au HC-05 puis à l'Arduino via la liaison série Software Arduino-HC05 qui est configurée par défaut en baudrate 9600 (vérifiable en envoyant la commandeBTSerie.print("AT+UART?");
au HC-05) - Quand on relâche le bouton, le caractère
S
est envoyé
L'application E&E: Arduino Automation par Engineers & Electronics est testée ne semble pas fonctionner avec les Android récents ni iOS :
- https://play.google.com/store/apps/details?id=com.himanshu.ArduinoAutomation
- Chercher une application alternative en tapant les mots-clé bluetooth arduino
- Autres applications possibles : Carino, bluetooth2, BLE RobotCar, Arduino Bluetooth Controller (giumig)
Sources
https://knowledge.parcours-performance.com/arduino-bluetooth-hc-05-hc-06/
RC Car - Voiture modélisme radiocommandée
Pilotage depuis le clavier d'un PC
via la liaison série Arduino-USB
- Sans contrôle de vitesse des moteurs CC
//Voiture modélisée radiocommandée (RC car) avec deux moteurs CC à l'arrière et un servomoteur de direction
// A COMPLETER pour le servo //
//Le port série matériel de l'Arduino Nano (Pins 0/RX et 1/TX) est déjà utilisé pour la liaison Arduino-USB avec l'ordinateur
//On utilise donc une liaison série logicielle pour la liaison Arduino-HC05 avec le module Bluetooth
#include <SoftwareSerial.h> //Software Serial Port
#define RxDpin 2 //Pin Digital 2 pour arduino Rx (pin0=serial)
#define TxDpin 3 //Pin Digital 3 pour arduino Tx (pin1)
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut configurer le HC-05
//on maintient le bouton à côté de la PIN EN/KEY enfoncé au démarrage de l'Arduino
// #define baudrate 38400 //Vitesse pour la liaion Arduino-HC05 en mode configuration
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut communiquer à travers le bluetooth depuis un smartphone,
//on appaire le HC-05 depuis l'appli avec le mot-de-passe par défaut : 1234
#define baudrate 9600 //Vitesse pour la liaion Arduino-HC05 en mode utilisation smartphone
SoftwareSerial BTSerie(RxDpin,TxDpin);
char caractereTexte;
String phraseTexte;
void setup()
{
Serial.begin(9600); //Vitesse (baudRate) pour la liaison Arduino-USB
delay(500);
//Configuration de la liaison SoftwareSerial avec le HC-05
pinMode(RxDpin, INPUT); //Configuration du Pin RxD (Receive) en mode entrée
pinMode(TxDpin, OUTPUT); //Configuration du Pin TxD (Transmit) en mode sortie
BTSerie.begin(baudrate); //Vitesse pour la liaion Arduino-HC05
if (baudrate==38400) {
Serial.println("En mode communication USB - Pret pour les commandes AT");
Serial.println("Le HC-05 doit clignoter lentement (2 secondes)");
}
else if (baudrate==9600){
Serial.println("En mode smartphone - Pret pour être appairé");
Serial.println("Le HC-05 doit clignoter rapidement avant d'être appairé");
}
else{
Serial.println("La vitesse de communication (baudrate) a été personnalisée");
}
delay(500);
pinMode(13,OUTPUT); //left motors forward
pinMode(12,OUTPUT); //left motors reverse
pinMode(11,OUTPUT); //right motors forward
pinMode(10,OUTPUT); //right motors reverse
pinMode(9,OUTPUT); //Led
pinMode(5,OUTPUT); //SG90 steering motor
// A COMPLETER pour le servo //
//myservo.attach(5); // attaches the servo on pin 5 to the servo object
}
void loop() {
// Serial.write(blueToothSerial.read());
//On lit caractere par caractere sur la liaion Arduino-HC05 et on affiche sur la liaison Arduino-USB
if (BTSerie.available()) {
caractereTexte = BTSerie.read();
Serial.print(caractereTexte);
}
//On lit caractere par caractere sur la liaion Arduino-USB et on affiche sur la liaison Arduino-HC05
if (Serial.available()) {
caractereTexte = Serial.read();
BTSerie.write(caractereTexte);
// Serial.println("Caractere envoye vers bluetooth : ");
// Serial.println(caractereRecu);
// }
if(caractereTexte == 'F'){ //F comme Forward - avancer (tous les moteurs vers l'avant, servo à 90°)
digitalWrite(10,LOW);
digitalWrite(11,HIGH);
digitalWrite(12,LOW);
digitalWrite(13,HIGH);
}
else if(caractereTexte == 'B'){ //B comme Backward reculer (tous les moteurs en sens inverse, servo à 90°)
digitalWrite(10,HIGH);
digitalWrite(11,LOW);
// A COMPLETER //
}
else if(caractereTexte == 'L'){ //L comme Left - tourner à gauche (moteur de droite vers l'avant, gauche à l'arrêt, servo à 120°)
// A COMPLETER //
}
else if(caractereTexte == 'R'){ //R comme Right - tourner à droite (moteur de gauche vers l'avant, droite à l'arrêt, servo à 60°)
// A COMPLETER //
}
else if(caractereTexte == 'S'){ //STOP (tous les moteurs à l'arrêt, servo à 90°)
// A COMPLETER //
}
delay(100);
}
}
Pilotage bluetooth avec contrôle de la vitesse des moteur
Depuis une application bluetooth de smartphone Android
Depuis le moniteur série d'Arduino IDE
Source : https://www.instructables.com/View-Serial-Monitor-Over-Bluetooth/#
- Ajouter le HC-05 dans Windows depuis les périphériques bluetooth et saisir le code PIN
1234
- Dans Arduino IDE
- Sélectionner le port série correspondant au HC-05. Il y en a deux, tester les deux
- Ouvrir le moniteur série
- Envoyer les commandes de pilotage :
F
,B
,L
,R
,S
.
//source Sample Code 2 https://wiki.dfrobot.com/Micro_DC_Motor_with_Encoder-SJ01_SKU__FIT0450#target_3
//The sample code for driving one way motor encoder
#include <PID_v1.h>
const byte encoder0pinA = 0;//A pin -> the interrupt pin 0
const byte encoder0pinB = 1;//B pin -> the digital pin 3
const byte encoder0pinA_2 = 8;//A pin -> the interrupt pin 0
const byte encoder0pinB_2 = 9;//B pin -> the digital pin 3
// int E_left =5; //The enabling of L298PDC motor driver board connection to the digital interface port 5
// int M_left =4; //The enabling of L298PDC motor driver board connection to the digital interface port 4
int MOTEUR_A_1 =12; //Connexion du pilote de moteur CC l9110s au port digital 5
int MOTEUR_A_2 =13; //Connexion du pilote de moteur CC l9110s au port digital 6
int MOTEUR_B_1 =10; //Connexion du pilote de moteur CC l9110s au port digital 5
int MOTEUR_B_2 =11; //Connexion du pilote de moteur CC l9110s au port digital 6
byte encoder0PinALast;
double duration,abs_duration;//the number of the pulses
boolean Direction;//the rotation direction
boolean result;
double val_output;//Power supplied to the motor PWM value.
double Setpoint;
double Kp=0.6, Ki=5, Kd=0;
PID myPID(&abs_duration, &val_output, &Setpoint, Kp, Ki, Kd, DIRECT);
#include <Servo.h>
#define trigPin 6
#define echoPin 7
// #define EncoderInit
Servo servo1;
Servo servo2;
Servo monServo;
//Le port série matériel de l'Arduino Nano (Pins 0/RX et 1/TX) est déjà utilisé pour la liaison Arduino-USB avec l'ordinateur
//On utilise donc une liaison série logicielle pour la liaison Arduino-HC05 avec le module Bluetooth
#include <SoftwareSerial.h> //Software Serial Port
#define RxDpin 2 //Pin Digital 2 pour arduino Rx (pin0=serial)
#define TxDpin 3 //Pin Digital 3 pour arduino Tx (pin1)
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut configurer le HC-05
//on maintient le bouton à côté de la PIN EN/KEY enfoncé au démarrage de l'Arduino
// #define baudrate 38400 //Vitesse pour la liaion Arduino-HC05 en mode configuration
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut communiquer à travers le bluetooth depuis un smartphone,
//on appaire le HC-05 depuis l'appli avec le mot-de-passe par défaut : 1234
#define baudrate 9600
#include <Servo.h>
Servo myservo; // create servo object to control a servo
SoftwareSerial BTSerie(RxDpin,TxDpin);
char caractereTexte;
String phraseTexte;
void setup()
{
Serial.begin(9600);//Initialize the serial port
pinMode(MOTEUR_A_1, OUTPUT); //L298P Control port settings DC motor driver board for the output mode
pinMode(MOTEUR_A_2, OUTPUT);
pinMode(MOTEUR_B_1, OUTPUT); //L298P Control port settings DC motor driver board for the output mode
pinMode(MOTEUR_B_2, OUTPUT);
Setpoint =80; //Set the output value of the PID
myPID.SetMode(AUTOMATIC);//PID is set to automatic mode
myPID.SetSampleTime(100);//Set PID sampling frequency is 100ms
EncoderInit();//Initialize the module
pinMode(RxDpin, INPUT); //Configuration du Pin RxD (Receive) en mode entrée
pinMode(TxDpin, OUTPUT); //Configuration du Pin TxD (Transmit) en mode sortie
BTSerie.begin(baudrate);
// Commandes AT pour le HC-05
// BTSerie.print("AT+NAME?"); //Demande le nom du module. Noter le ?
// BTSerie.print("AT+NAME=RCcar-HC-05-1"); //Définir le nom du module.
BTSerie.print("AT+VERSION?"); //Demande le N° de version. Noter le ?
// BTSerie.print("AT+UART?"); //Demande la vitesse série (baudrate). Noter le ?
// BTSerie.print("AT+UART=57600,0,0"); //Définir la vitesse série (baudrate).
// BTSerie.print("AT+ROLE?"); //Demande le mode du module, maitre ou esclave. Noter le ?
// BTSerie.print("AT+PSWD?"); //Demande le mot-de-passe du module. Noter le ?
// La console série de l'ordinateur d'où l'on envoie les commandes AT doit être réglée de telle sorte que
// les fins de ligne soient « les deux, NL et CR », ce qui revient à envoyer \r\n à la fin de chaque commande.
BTSerie.print("\r\n"); // sur HC-05, toutes les commandes doivent se terminer par \r\n
// afficher ce que le module bluetooth répond
Serial.print( BTSerie.read() ); // afficher sur la console ce qui est lu sur BT
// pour AT+VERSION?, c'est le n° de version puis OK qui s'affiche
if (baudrate==38400) {
Serial.println("En mode communication USB - Pret pour les commandes AT");
Serial.println("Le HC-05 doit clignoter lentement (2 secondes)");
}
else if (baudrate==9600){
Serial.println("En mode smartphone - Pret pour être appairé");
Serial.println("Le HC-05 doit clignoter rapidement avant d'être appairé");
}
else{
Serial.println("La vitesse de communication (baudrate) a été personnalisée");
}
monServo.attach(5);
delay(500);
pinMode(13,OUTPUT); //left motors forward
pinMode(12,OUTPUT); //left motors reverse
pinMode(11,OUTPUT); //right motors forward
pinMode(10,OUTPUT); //right motors reverse
pinMode(9,OUTPUT); //Led
pinMode(5,OUTPUT); //SG90 steering motor
// A COMPLETER pour le servo //
//myservo.attach(5); // attaches the servo on pin 5 to the servo object
}
void loop()
{
//On lit caractere par caractere sur la liaion Arduino-USB et on affiche sur la liaison Arduino-HC05
if (Serial.available()) {
caractereTexte = Serial.read();
BTSerie.write(caractereTexte);
// Serial.println("Caractere envoye vers bluetooth : ");
// Serial.println(caractereRecu);
}
//On lit caractere par caractere sur la liaion Arduino-HC05 et on affiche sur la liaison Arduino-USB
if (BTSerie.available()) {
caractereTexte = BTSerie.read();
Serial.print(caractereTexte);
// }
if(caractereTexte == 'F'){ //move forward(all motors rotate in forward direction)
advance();//Motor Forward
monServo.write(90); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'B'){ //move reverse (all motors rotate in reverse direction)
back();//Motor reverse
monServo.write(90); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'L'){ //turn right (left side motors rotate in forward direction, right side motors doesn'caractereRecu rotate)
left();
monServo.write(60); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'R'){ //turn left (right side motors rotate in forward direction, left side motors doesn'caractereRecu rotate)
right();
monServo.write(120); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'S'){ //STOP (all motors stop)
Stop();
monServo.write(90);
}
abs_duration=abs(duration);
result=myPID.Compute();//PID conversion is complete and returns 1
if(result)
{
Serial.print("Pluse: ");
Serial.println(duration);
duration = 0; //Count clear, wait for the next count
} // sets the servo position according to the scaled value
}
}
void EncoderInit()
{
Direction = true;//default -> Forward
pinMode(encoder0pinB,INPUT);
attachInterrupt(0, wheelSpeed, CHANGE);
}
void wheelSpeed()
{
int Lstate = digitalRead(encoder0pinA);
if((encoder0PinALast == LOW) && Lstate==HIGH)
{
int val = digitalRead(encoder0pinB);
if(val == LOW && Direction)
{
Direction = false; //Reverse
}
else if(val == HIGH && !Direction)
{
Direction = true; //Forward
}
}
encoder0PinALast = Lstate;
if(!Direction) duration++;
else duration--;
}
void advance()//Motor Forward
{
digitalWrite(MOTEUR_A_1,LOW);
digitalWrite(MOTEUR_A_2,val_output);
digitalWrite(MOTEUR_B_1,val_output);
digitalWrite(MOTEUR_B_2,LOW);
}
void back()//Motor reverse
{
digitalWrite(MOTEUR_A_1,val_output);
digitalWrite(MOTEUR_A_2,LOW);
digitalWrite(MOTEUR_B_1,LOW);
digitalWrite(MOTEUR_B_2,val_output);
}
void left()
{
digitalWrite(MOTEUR_A_1,LOW);
digitalWrite(MOTEUR_A_2,val_output);
digitalWrite(MOTEUR_B_1,LOW);
digitalWrite(MOTEUR_B_2,LOW);
}
void right()
{
digitalWrite(MOTEUR_A_1,LOW);
digitalWrite(MOTEUR_A_2,LOW);
digitalWrite(MOTEUR_B_1,val_output);
digitalWrite(MOTEUR_B_2,LOW);
}
void Stop()//Motor stops
{
digitalWrite(MOTEUR_A_1, LOW);
digitalWrite(MOTEUR_A_2, LOW);
digitalWrite(MOTEUR_B_1, LOW);
digitalWrite(MOTEUR_B_2, LOW);
}
Sources
https://github.com/himanshus2847/Bluetooth-Controlled-Robot-using-Arduino
https://www.youtube.com/watch?v=o-aRCxh9IhE
Code voiture RC
//source Sample Code 2 https://wiki.dfrobot.com/Micro_DC_Motor_with_Encoder-SJ01_SKU__FIT0450#target_3
//The sample code for driving one way motor encoder
#include <PID_v1.h>
const byte encoder0pinA = 0;//A pin -> the interrupt pin 0
const byte encoder0pinB = 1;//B pin -> the digital pin 3
const byte encoder0pinA_2 = 8;//A pin -> the interrupt pin 0
const byte encoder0pinB_2 = 9;//B pin -> the digital pin 3
// int E_left =5; //The enabling of L298PDC motor driver board connection to the digital interface port 5
// int M_left =4; //The enabling of L298PDC motor driver board connection to the digital interface port 4
int MOTEUR_A_1 =12; //Connexion du pilote de moteur CC l9110s au port digital 5
int MOTEUR_A_2 =13; //Connexion du pilote de moteur CC l9110s au port digital 6
int MOTEUR_B_1 =10; //Connexion du pilote de moteur CC l9110s au port digital 5
int MOTEUR_B_2 =11; //Connexion du pilote de moteur CC l9110s au port digital 6
byte encoder0PinALast;
double duration,abs_duration;//the number of the pulses
boolean Direction;//the rotation direction
boolean result;
double val_output;//Power supplied to the motor PWM value.
double Setpoint;
double Kp=0.6, Ki=5, Kd=0;
PID myPID(&abs_duration, &val_output, &Setpoint, Kp, Ki, Kd, DIRECT);
#include <Servo.h>
#define trigPin 6
#define echoPin 7
// #define EncoderInit
Servo servo1;
Servo servo2;
Servo monServo;
//Le port série matériel de l'Arduino Nano (Pins 0/RX et 1/TX) est déjà utilisé pour la liaison Arduino-USB avec l'ordinateur
//On utilise donc une liaison série logicielle pour la liaison Arduino-HC05 avec le module Bluetooth
#include <SoftwareSerial.h> //Software Serial Port
#define RxDpin 2 //Pin Digital 2 pour arduino Rx (pin0=serial)
#define TxDpin 3 //Pin Digital 3 pour arduino Tx (pin1)
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut configurer le HC-05
//on maintient le bouton à côté de la PIN EN/KEY enfoncé au démarrage de l'Arduino
// #define baudrate 38400 //Vitesse pour la liaion Arduino-HC05 en mode configuration
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut communiquer à travers le bluetooth depuis un smartphone,
//on appaire le HC-05 depuis l'appli avec le mot-de-passe par défaut : 1234
#define baudrate 9600
#include <Servo.h>
Servo myservo; // create servo object to control a servo
SoftwareSerial BTSerie(RxDpin,TxDpin);
char caractereTexte;
String phraseTexte;
void setup()
{
Serial.begin(9600);//Initialize the serial port
pinMode(MOTEUR_A_1, OUTPUT); //L298P Control port settings DC motor driver board for the output mode
pinMode(MOTEUR_A_2, OUTPUT);
pinMode(MOTEUR_B_1, OUTPUT); //L298P Control port settings DC motor driver board for the output mode
pinMode(MOTEUR_B_2, OUTPUT);
Setpoint =80; //Set the output value of the PID
myPID.SetMode(AUTOMATIC);//PID is set to automatic mode
myPID.SetSampleTime(100);//Set PID sampling frequency is 100ms
EncoderInit();//Initialize the module
pinMode(RxDpin, INPUT); //Configuration du Pin RxD (Receive) en mode entrée
pinMode(TxDpin, OUTPUT); //Configuration du Pin TxD (Transmit) en mode sortie
BTSerie.begin(baudrate);
// Commandes AT pour le HC-05
// BTSerie.print("AT+NAME?"); //Demande le nom du module. Noter le ?
// BTSerie.print("AT+NAME=RCcar-HC-05-1"); //Définir le nom du module.
BTSerie.print("AT+VERSION?"); //Demande le N° de version. Noter le ?
// BTSerie.print("AT+UART?"); //Demande la vitesse série (baudrate). Noter le ?
// BTSerie.print("AT+UART=57600,0,0"); //Définir la vitesse série (baudrate).
// BTSerie.print("AT+ROLE?"); //Demande le mode du module, maitre ou esclave. Noter le ?
// BTSerie.print("AT+PSWD?"); //Demande le mot-de-passe du module. Noter le ?
// La console série de l'ordinateur d'où l'on envoie les commandes AT doit être réglée de telle sorte que
// les fins de ligne soient « les deux, NL et CR », ce qui revient à envoyer \r\n à la fin de chaque commande.
BTSerie.print("\r\n"); // sur HC-05, toutes les commandes doivent se terminer par \r\n
// afficher ce que le module bluetooth répond
Serial.print( BTSerie.read() ); // afficher sur la console ce qui est lu sur BT
// pour AT+VERSION?, c'est le n° de version puis OK qui s'affiche
if (baudrate==38400) {
Serial.println("En mode communication USB - Pret pour les commandes AT");
Serial.println("Le HC-05 doit clignoter lentement (2 secondes)");
}
else if (baudrate==9600){
Serial.println("En mode smartphone - Pret pour être appairé");
Serial.println("Le HC-05 doit clignoter rapidement avant d'être appairé");
}
else{
Serial.println("La vitesse de communication (baudrate) a été personnalisée");
}
monServo.attach(5);
delay(500);
pinMode(13,OUTPUT); //left motors forward
pinMode(12,OUTPUT); //left motors reverse
pinMode(11,OUTPUT); //right motors forward
pinMode(10,OUTPUT); //right motors reverse
pinMode(9,OUTPUT); //Led
pinMode(5,OUTPUT); //SG90 steering motor
// A COMPLETER pour le servo //
//myservo.attach(5); // attaches the servo on pin 5 to the servo object
}
void loop()
{
//On lit caractere par caractere sur la liaion Arduino-HC05 et on affiche sur la liaison Arduino-USB
if (BTSerie.available()) {
caractereTexte = BTSerie.read();
Serial.print(caractereTexte);
}
//On lit caractere par caractere sur la liaion Arduino-USB et on affiche sur la liaison Arduino-HC05
if (Serial.available()) {
caractereTexte = Serial.read();
BTSerie.write(caractereTexte);
// Serial.println("Caractere envoye vers bluetooth : ");
// Serial.println(caractereRecu);
// }
if(caractereTexte == 'F'){ //move forward(all motors rotate in forward direction)
advance();//Motor Forward
monServo.write(90); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'B'){ //move reverse (all motors rotate in reverse direction)
back();//Motor reverse
monServo.write(90); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'L'){ //turn right (left side motors rotate in forward direction, right side motors doesn'caractereRecu rotate)
left();
monServo.write(60); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'R'){ //turn left (right side motors rotate in forward direction, left side motors doesn'caractereRecu rotate)
right();
monServo.write(120); // sets the servo position according to the scaled value
}
else if(caractereTexte == 'S'){ //STOP (all motors stop)
Stop();
monServo.write(90);
}
abs_duration=abs(duration);
result=myPID.Compute();//PID conversion is complete and returns 1
if(result)
{
Serial.print("Pluse: ");
Serial.println(duration);
duration = 0; //Count clear, wait for the next count
} // sets the servo position according to the scaled value
}
}
void EncoderInit()
{
Direction = true;//default -> Forward
pinMode(encoder0pinB,INPUT);
attachInterrupt(0, wheelSpeed, CHANGE);
}
void wheelSpeed()
{
int Lstate = digitalRead(encoder0pinA);
if((encoder0PinALast == LOW) && Lstate==HIGH)
{
int val = digitalRead(encoder0pinB);
if(val == LOW && Direction)
{
Direction = false; //Reverse
}
else if(val == HIGH && !Direction)
{
Direction = true; //Forward
}
}
encoder0PinALast = Lstate;
if(!Direction) duration++;
else duration--;
}
void advance()//Motor Forward
{
digitalWrite(MOTEUR_A_1,LOW);
digitalWrite(MOTEUR_A_2,val_output);
digitalWrite(MOTEUR_B_1,val_output);
digitalWrite(MOTEUR_B_2,LOW);
}
void back()//Motor reverse
{
digitalWrite(MOTEUR_A_1,val_output);
digitalWrite(MOTEUR_A_2,LOW);
digitalWrite(MOTEUR_B_1,LOW);
digitalWrite(MOTEUR_B_2,val_output);
}
void left()
{
digitalWrite(MOTEUR_A_1,LOW);
digitalWrite(MOTEUR_A_2,val_output);
digitalWrite(MOTEUR_B_1,LOW);
digitalWrite(MOTEUR_B_2,LOW);
}
void right()
{
digitalWrite(MOTEUR_A_1,LOW);
digitalWrite(MOTEUR_A_2,LOW);
digitalWrite(MOTEUR_B_1,val_output);
digitalWrite(MOTEUR_B_2,LOW);
}
void Stop()//Motor stops
{
digitalWrite(MOTEUR_A_1, LOW);
digitalWrite(MOTEUR_A_2, LOW);
digitalWrite(MOTEUR_B_1, LOW);
digitalWrite(MOTEUR_B_2, LOW);
}
Stages de Robotique pour les collégiens - Station Mesure Eau
Le stage se déroule de la manière suivante : 1. Conception de la formation des animateurs 2. Conception du contenu technique du stage 3. Journée de formation des animateurs (1 jour) 4. Ateliers de robotique éducative pour jeunes (3 jours) Coût :
Fiche résumé
Intitulé de l'atelier
Illustration / Image
Durée de l'atelier
Objectifs pédagogiques
Autres objectifs (si applicable)
- Défis Résilience des territoires ADEME (si applicable)
Préparation
Outillage (investissement)
Ex. Imprimante 3D
- Coût d'un robot :
Matériaux (consommable pour un stage)
Consommable
Financement
- Coût par enfant : 5000€/24
Local / Lieu / Équipement
- 1 PC par élève (minimum 1 PC pour deux)
- 1 animateur pour 4 participants
Équipe
- animateurs ayant participé à la formation
- 1 animateur pour 4 participants
Normes / Sécurité
- Autorisation parentale -> sortie de bâtiment sans les parents
- Droit à l'image -> photos pour la com'
- Carnet de vaccination
- Fiche sanitaire
Conception technique du stage
Exécution
Accueil
Consignes
Préparation des Matériaux / Kits
Pauses
Fabrication / Assemblage
Etapes avec les participants
Matin
Après-midi
Rangement
Photo de Groupe
Après l'Atelier
Communication
Documentation
Contact Documentation / Atelier
Conception de la formation des animateurs
Exécution
Accueil
Consignes
Préparation des Matériaux / Kits
Pauses
Fabrication / Assemblage
Etapes avec les participants
Matin
Après-midi
Rangement
Photo de Groupe
Après l'Atelier
Communication
Documentation
Contact Documentation / Atelier
Atelier de formation des animateurs
Fiche de documentation de conduite d'atelier
Exécution
- Accueil des enfants + Jeu "brisure de la glace"
- Atelier pédagogique (~ 1h30 max)
- Activité ludique (jeux de société/en extérieur/etc...)
- Goûter
- Rituel de départ
Accueil
Consignes
Préparation des Matériaux / Kits
Pauses
- Pauses du goûter
Fabrication / Assemblage
Etapes avec les participants
Matin
Après-midi
Exemples d'activités ludiques
- Jeux de société
- Loup-garou
- Jeux pour découvrir l'IUT
- Geogesser
- Exemple de badge
- Geogesser
Rangement
Photo de Groupe
Après l'Atelier
Communication
Documentation
Contact Documentation / Atelier
Ateliers de développement de la station de mesure de l'eau (5 jours)
Mission Otez l’eau
Depuis quelques mois, un changement soudain dans la qualité de l'eau a été signalé dans plusieurs régions du monde, ce qui soulève des inquiétudes. Les premières enquêtes révèlent une contamination progressive de l'eau, liée à des défaillances dans les systèmes de traitement et de rejets des eaux usés par une usine. Face à cette menace environnementale et sanitaire, l'association Savoirs Vivants, et l’IUT de Haguenau, ont été missionné par les services secrets français pour monter une équipe de roboticiens et de chercheurs pour identifier l’usine à la source de ces contaminations.
En tant que nouveaux membres de ce consortium de chercheurs votre première mission sera de vous trouver un nom d’équipe pour réussir à communiquer facilement avec le reste des autres chercheurs et votre chef d’équipe.
Votre mission consiste à concevoir, assembler, et programmer la Station AquaLife pour qu'elle soit capable de détecter les contaminants dans l'eau avec précision et efficacité. Pour cela, vous utiliserez des technologies de pointe en robotique, en informatique et en analyse chimique.
La Station AquaLife que vous allez concevoir pour collecter et analyser des échantillons d'eau en temps réel, fournira des données essentielles pour identifier les sources d’eau contaminé et ainsi trouver la source de ces contaminations.
Déroulement du projet :
- Lundi : Conception 3D - Initiez-vous au design assisté par ordinateur pour concevoir la pièce manquante de la Station AquaLife, permettant d’afficher les données sur l’écran.
- Mardi : Assemblage et Pratique - Construisez le prototype de votre Station AquaLife en assemblant les capteurs et les circuits nécessaires.
- Mercredi : Programmation Fonctionnelle - Implémentez le code informatique qui permettra à la Station AquaLife de collecter et d'analyser les données.
- Jeudi : Tests chimiques - Testez votre Station AquaLife avec différents échantillons d'eau récoltés autours des usines ciblés.
- Vendredi : Analyse et Présentation - Interprétez les données collectées, identifiez les tendances et préparez une présentation de vos résultats. Cette étape sera cruciale pour identifier la source de la contamination.
En participant à la Mission Otez l’eau, vous apportez une contribution concrète à la résolution d'un problème environnemental d’envergure. Vous acquerrez des compétences en robotique, en analyse de données et en travail d'équipe, tout en aidant à protéger la ressource la plus précieuse de notre planète : l'eau. Prêts à relever ce défi vital ?
Préparation des Matériaux / Kits
Station de mesure de l'eau
Liste du matériel de la station : Liste_materiel.pdf
Connexion des capteurs sur la carte d'extension DRF0762 : connexion_capteurs_carte_DFR0762.pdf
Arduino
Installation de la carte ESP2 et des bibliothèques pour la station d'eau dans l'IDE Arduino : Arduino_Installation_Cartes_Bibliotheques.pdf
Programme Arduino complet de la station d'eau : 2024_stage_collegiens_v5_Station_Eau.ino
Ci-dessous, le programme simplifié :
/// CODE SIMPLIFIE SANS TDS ET TURBIDITE
// #include <Arduino.h>
#include <U8g2lib.h> // by oliver <olikraus@gmail.com> testé 2.34.22
#include <DHT.h>
#include <OneWire.h>
#include <DallasTemperature.h>
//****************************************************************************************//
// Constante de temps et broches de connexion des capteurs //
//****************************************************************************************//
const int pause_affichage_ms = 100; // temps de pause d'affichage en milliseconde
// #define TDS_Sensor_Pin_Num A2 // TDS sensor on Analog pin Ax
// #define Turbidity_Sensor_Pin_Num A3 // Turbidity sensor on Analog pin Ax
#define pH_Sensor_Pin_Num A4 // pH sensor on Analog pin Ax
#define DS18S20_Pin_Num_v2 D2 // DS18B20 sensor on digital pin Dx <======= Zone d'affectation des capteurs et actionneurs
#define DHT_Sensor_Pin_Num D6 // DHT on Digital pin Dx
//****************************************************************************************//
//Données et configuration pour le capteur DHT
#define ref_DHT DHT22 // référence du DHT (DHT11, DHT22...)
char Hum_DHT[8], Temp_DHT[8];
DHT dht(DHT_Sensor_Pin_Num, ref_DHT);
// Données pour le capteur pH meter (v2) ==> site DFRobot
const int numMeasure = 10;
char pH_2[8];
float offset_pH2 = 0; // valeur standard = -1.8 avec la carte pH alimentée en 3.3V et -2.5 avec carte alimentée en 5V
// Donnée TDS meter (v1)
// char TDS_1[8];
// float temperature = 25;
// Données pour le capteur de turbidité
// char Turbi_volt[8], NTU_strg[8];
// float Turbi_val = 0;
// Configuration pour le capteur de température DS18B20 (v2)
OneWire ds(DS18S20_Pin_Num_v2); //on digital pin 2
char Temp_DS_2[8];
// Configuration de l'afficheur SSD1315
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(/* rotation=*/ U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); //Low spped I2C
/*
U8g2lib Example Overview:
Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
*/
void get_DHT()
{
float h = 0.0;
float t = 0.0;
h = dht.readHumidity();
dtostrf(h, 5, 1, Hum_DHT); // conversion digital to string
t = dht.readTemperature();
dtostrf(t, 5, 1, Temp_DHT);
Serial.print("DHT ==> Humidité : ");
Serial.print(Hum_DHT);
Serial.print(" Température (°C) : ");
Serial.println(Temp_DHT);
}
void get_pH_2()
{
int buf[10],temp;
for(int i=0;i<numMeasure;i++) //Get 10 sample value from the sensor for smooth the value
{
buf[i]=analogRead(pH_Sensor_Pin_Num);
delay(10);
}
for(int i=0;i<numMeasure-1;i++) //sort the analog from small to large
{
for(int j=i+1;j<numMeasure;j++)
{
if(buf[i]>buf[j])
{
temp=buf[i];
buf[i]=buf[j];
buf[j]=temp;
}
}
}
unsigned long int sumValue = 0; //Store the average value of the sensor feedback
for(int i=2;i<numMeasure-2;i++) //take the average value of 6 center sample
sumValue+=buf[i];
float phValue=(float)sumValue*5.0/4096/(numMeasure-4); //convert the analog into millivolt
// phValue=3.5*phValue + offset_pH2; //convert the millivolt into pH value avec carte pH alimentée en 5v
phValue=5.3*phValue + offset_pH2; //convert the millivolt into pH value avec carte pH alimentée en 3.3v
dtostrf(phValue, 5, 1, pH_2);
Serial.print("pH_2 value: ");
Serial.println(phValue,2);
}
// void get_TDS_1()
// {
// int TDS_ADC = 0;
// float TDS_volt = 0;
// float compensationCoefficient = 1.0+0.02*(temperature-25.0); //temperature compensation formula: fFinalResult(25^C) = fFinalResult(current)/(1.0+0.02*(fTP-25.0));
// float compensationVolatge = 0; //temperature compensation
// float TDS_val = 0;
// TDS_ADC = analogRead(TDS_Sensor_Pin_Num);
// TDS_volt = TDS_ADC/4096.0*5.0;
// compensationVolatge = TDS_volt/compensationCoefficient;
// TDS_val=(133.42*compensationVolatge*compensationVolatge*compensationVolatge - 255.86*compensationVolatge*compensationVolatge + 857.39*compensationVolatge)*0.5; //convert voltage value to tds value
// dtostrf(TDS_val, 5, 1, TDS_1);
// Serial.print("TDS_1 valADC (0 à 4095) : ");
// Serial.print(TDS_ADC);
// Serial.print(" voltage (V) : ");
// Serial.print(TDS_volt);
// Serial.print(" ppm : ");
// Serial.println(TDS_val);
// }
// void get_Turbidity()
// {
// int sensorValue = 0;
// float voltage = 0, NTU = 0;
// sensorValue = analogRead(Turbidity_Sensor_Pin_Num); // read the input on analog pin
// voltage = sensorValue * (5.0 / 4096); // Convert the analog reading (which goes from 0 - 4095) to a voltage (0 - 5V)
// dtostrf(voltage, 5, 1, Turbi_volt);
// NTU = -1120.4*voltage*voltage + 5742.3*voltage - 4352.9; //
// dtostrf(NTU, 5, 0, NTU_strg);
// Serial.print("Turbidity (volt) : "); // print out the value you read:
// Serial.print(voltage); // print out the value you read:
// Serial.print(" Turbidity (NTU) : "); // print out the value you read:
// Serial.println(NTU); // print out the value you read:
// Turbi_val = voltage;
// }
void get_TempDS_2()
{
//returns the temperature from one DS18S20 in DEG Celsius
byte data[12];
byte addr[8];
if (!ds.search(addr))
{
//no more sensors on chain,reset search
Serial.println("No more addresses.");
Serial.println();
ds.reset_search();
}
Serial.print("ROM =");
for(int i = 0; i < 8; i++)
{
Serial.write(' ');
Serial.print(addr[i], HEX);
}
Serial.println();
if (OneWire::crc8(addr,7)!=addr[7])
{
Serial.println("CRC is not valid!");
}
// the first ROM byte indicates which chip
byte type_s;
switch (addr[0])
{
case 0x10:
Serial.println(" Chip = DS18S20"); // or old DS1820
type_s = 1;
break;
case 0x28:
Serial.println(" Chip = DS18B20");
type_s = 0;
break;
case 0x22:
Serial.println(" Chip = DS1822");
type_s = 0;
break;
default:
Serial.println("Device is not a DS18x20 family device.");
break;
}
if (addr[0] != 0x10 && addr[0] != 0x28)
{
Serial.print("Device is not recognized");
}
ds.reset();
ds.select(addr);
ds.write(0x44,1); //start conversion, with parasite power on at the end
byte present = ds.reset();
ds.select(addr);
ds.write(0xBE); //ReadScratchpad
for(int i=0; i<9; i++) //weneed9bytes
{
data[i]=ds.read();
}
ds.reset_search();
byte MSB=data[1];
byte LSB=data[0];
float tempRead=((MSB<<8)|LSB); //using two's compliment
float TemperatureSum = tempRead/16;
// return TemperatureSum;
dtostrf(TemperatureSum, 5, 1, Temp_DS_2);
Serial.print("Temperature DS (en °C) : ");
Serial.println(TemperatureSum);
}
void setup()
{
// put your setup code here, to run once:
Serial.begin(115200);
Serial.println("**********************************************");
Serial.println("Setup Serial monitor OK");
u8g2.begin();
Serial.println("Setup écran OLED OK");
dht.begin();
pinMode(pH_Sensor_Pin_Num,INPUT); // Set pH sensor pin to input mode
// pinMode(Turbidity_Sensor_Pin_Num, INPUT); // Set the turbidity sensor pin to input mode
Serial.println("End of setup");
Serial.println("**********************************************");
}
void loop()
{
// put your main code here, to run repeatedly:
get_DHT();
get_pH_2();
// affichage des données
u8g2.setFont(u8g2_font_ncenB08_tr); // choose a suitable font
//****************************************************************************************//
// écran OLED SSD1315 :
// fonction U8g2.drawStr(n°colonne,n°ligne,string)
u8g2.clearBuffer(); // clear the internal memory
u8g2.drawStr(0,10,"Station eau"); // write something to the internal memory
u8g2.drawStr(0,25,"Humidity DHT :"); // affichage du texte "Humidity DHT:"
u8g2.drawStr(92,25,Hum_DHT); // affichage de la valeur de l'humidité
u8g2.drawStr(0,30,"Temp DHT :"); // affichage du texte "Temp DHT :"
u8g2.drawStr(68,30,Temp_DHT); // affichage de la valeur de température fournie par le capteur DHT <== zone à modifier (remplacer xx par des valeurs)
u8g2.drawStr(0,35,"pH :"); // affichage du texte "pH :"
u8g2.drawStr(20,35,pH_2); // affichage de la valeur du pH
u8g2.sendBuffer(); // transfer internal memory to the display
delay(pause_affichage_ms);
//****************************************************************************************//
// get_TDS_1();
// get_Turbidity();
get_TempDS_2();
//****************************************************************************************//
u8g2.clearBuffer(); // clear the internal memory
// u8g2.drawStr(0,25,"TDS :"); // affichage du texte "TDS :"
// u8g2.drawStr(35,25,TDS_1); // affichage de la valeur de conductivité TDS
// u8g2.drawStr(0,37,"Turbidity (V) :"); // affichage du texte "Turbidity (V) :"
// u8g2.drawStr(80,37,Turbi_volt); // affichage de la valeur de turbidité en volt <== zone à modifier
u8g2.drawStr(0,49,"Temp DS :"); // affichage du texte "Temp_DS :" à la position
u8g2.drawStr(57,49,Temp_DS_2); // affichage de la valeur de température du DS18B20
u8g2.sendBuffer();
//****************************************************************************************//
//****************************************************************************************//
// Code pour gérer une LED //
//****************************************************************************************//
// Affciher un message d'alerte selon la valeur de la turbidité
/*
float seuil = x; // valeur du seuil
if (Turbi_val > seuil) // comparaison par rapport au seuil
{
u8g2.drawStr(0,62,"Eau limpide !");
u8g2.sendBuffer();
}
else
{
u8g2.drawStr(0,62,"Eau trouble !");
u8g2.sendBuffer();
}
*/
delay(pause_affichage_ms);
Serial.println();
}
Calibration du capteur pH
Programme Arduino pour la calibration du capteur pH : 2024_calibration_materiel_capteur_pH.ino
Procédure de calibration matériel du capteur pH : Procedure_Calibration_Materiel_Capteur_pH.pdf
Jour 1 - Conception 3D
Mission :
Une dernière pièce est manquante pour la réalisation de la station. Vous allez devoir la concevoir et la produire sur mesure en utilisant un logiciel de conception 3D (TINKERCAD), ce qui permettra d'obtenir le boitier de la station AquaLife.
Conception Tinkercad T78-12G-PM4
TINKERCAD est un logiciel de conception 3D simple et efficace. Ce tutoriel vous aidera à l’utiliser : https://innovation.iha.unistra.fr/books/2-fablab-activites-logiciels/page/initiation-3d-tinkercad
Ouvrir Tinkercad à partir de la barre de recherche Windows de votre ordinateur.
Dans l'onglet 3, prenez l'outil nommé « boîtes », ensuite faites-le glisser sur le plan de construction.
Une fenêtre apparaîtra, vous permettant de régler différents paramètres de cette fenêtre (rayon, étapes, longueur, largeur et hauteur) pour voir ce qui se passe.
Vous êtes désormais prêt(e) à conceptualiser les pièces nécessaires pour finaliser notre station AquaLife. Celle-ci doit à la fin ressembler à la photo ci-dessous.
Création de la dernière pièce de la station : Pour commencer, il vous faut un rectangle avec les mesures suivantes : Longueur = 126 mm ; Largeur = 54 mm ; Hauteur = 3 mm.
Nous devons créer un emplacement pour l’afficheur. Pour ce faire, nous avons besoin d’un rectangle de perçage. Donnez-lui les dimensions suivantes : Longueur = 25 mm ; Largeur = 18 mm ; Hauteur = 4 mm.
Déplacez-le sur votre rectangle rouge.
Pour assembler les deux, utilisez les raccourcis clavier : Ctrl+A puis Ctrl+G
Voici le rendu que vous devriez avoir :
Par la suite, créez l’emplacement pour la vis qui maintiendra votre afficheur.
Pour ce faire, créez un cylindre de perçage.
Voici ses dimensions : Diamètre = 8 mm ; Hauteur = 5 mm.
Déplacez-le pour le mettre au bon endroit.
L’outil « règle » sera votre meilleur ami pour placer correctement le cylindre.
Placez cet outil dans le coin inférieur droit de l’emplacement de l’afficheur. Une fois placé, des cotes apparaîtront, comme sur l'image suivante :
Modifiez seulement les cotes en vert. La cote de gauche sera de 5 mm et celle du bas de 8 mm. Ensuite, assemblez les deux en faisant : Ctrl+A puis Ctrl+G.
Votre support pour l’afficheur est maintenant prêt !
Jour 2 - Assemblage mécanique et électronique
Mission :
Aujourd’hui, votre objectif est d’assembler les capteurs de votre station AquaLife. Pour réaliser l’assemblage et le montage, vous allez d’abord découvrir les différents capteurs, les fixer à votre station et les câbler à la carte ESP32 en fonction des recommandations de connexion. Ci-dessous une image du montage final :
Tutoriel des capteurs :
L'ESP32 (et son extension) est une carte microcontrôleur très performante qui permet de créer des projets électroniques connectés. Grâce à ses nombreux ports, tu peux y connecter des capteurs, des moteurs, ou d'autres composants pour réaliser des gadgets intelligents, des systèmes de domotique, ou des robots. |
Un afficheur est un écran qui permet de montrer des informations ou des données provenant du microcontrôleur. On peut l'utiliser pour afficher des textes, des chiffres... C'est très utile pour voir ce que fait le microcontrôleur en temps réel, comme la température d'une pièce, le score d'un jeu, ou l'état d'un système. |
Un conductimètre est un instrument qui mesure la capacité de l'eau à conduire l'électricité, ce qui nous informe sur la quantité de sels ou d'autres substances dissoutes dans l'eau. Plus l'eau contient de substances dissoutes, mieux elle conduit l'électricité. Cette mesure est très utile pour vérifier la pureté de l'eau. |
Un turbidimètre, permet de mesurer la turbidité, qui sert à évaluer la clarté de l'eau en détectant combien de petites particules sont suspendues dans celle-ci. Plus l'eau contient de particules comme de la terre, des micro-organismes, ou des substances chimiques, plus elle apparaît trouble. |
|
|
Un pH-mètre est un instrument utilisé pour mesurer l'acidité ou la basicité d'une solution. Il donne une valeur appelée "pH", qui varie généralement de 0 à 14. Un pH de 7 est neutre, des valeurs inférieures à 7 indiquent une acidité, et des valeurs supérieures à 7 révèlent une basicité. Le pH-mètre est essentiel, car il aide à comprendre l'équilibre chimique des solutions. |
Un thermomètre est un instrument qui permet de mesurer la température de l'eau. En mesurant la température, on peut s'assurer que l'eau est dans les conditions optimales, que ce soit pour assurer la santé des organismes aquatiques, garantir la sécurité des baigneurs, ou maintenir l'efficacité des processus industriels. |
Le DHT22 est un capteur qui mesure à la fois la température et l'humidité de l'air ambiant. Il fournit des informations précieuses pour contrôler les conditions environnementales. En mesurant l'humidité, le DHT22 aide à surveiller la quantité de vapeur d'eau dans l'air, ce qui est crucial pour maintenir une bonne qualité de l'air. Pour la température, il assure que les conditions soient confortables et sûres. |
Avec ces informations vous êtes prêts à assembler votre station.
Étape 1 : Aller chercher les composants auprès de l'animateur
- Un afficheur, avec des câbles femelle-femelle de toutes les couleurs.
- Un conductimètre avec sa carte d’interface, ainsi qu’un câble correspondant.
- Un turbidimètre, avec sa carte d’interface, ainsi qu’un câble correspondant.
- Un pH-mètre, avec sa carte d’interface, ainsi qu’un câble correspondant.
- Un thermomètre, avec sa carte d’interface, ainsi qu’un câble correspondant.
- Un DHT22, avec sa carte d’interface, ainsi qu’un câble correspondant.Un ESP32 et son extension, ainsi qu’un câble USB/USB-C pour alimenter votre station à l’ordinateur.
Étape 2 : Fixer les interfaces des capteurs à la station.
Fixer avec des vis adaptées, les interfaces des capteurs dans la boite de la station comme indiqué ci-dessous.
Étape 3 : Brancher l’afficheur et les capteurs à l’ESP32 via la carte d’extension présentée ci-dessous.
Observer l’organisation de la carte d’extension et repérer les différents signaux.
Connecter les capteurs et l'afficheur sur la carte d'extension DFR0762 selon les indications ci-dessous :
Jour 3 - Programmation Arduino
Mission :
Aujourd’hui, votre objectif est de programmer la station AquaLife. Vous allez écrire, modifier et tester le code nécessaire pour contrôler les différents capteurs selon les instructions décrites ci-dessous. Bonne chance.
Étape 1 : Lancement de l'IDE Arduino et configuration de l'application
-
Charger le fichier : 2024_stage_collegiens_v5.ino
-
Connectez votre station ESP32 à votre ordinateur via un câble USB-A/USB-C.
-
Vérifiez le port de connexion de votre ESP32 (CH340K), en consultant le gestionnaire de périphériques de votre ordinateur pour identifier le port de communication (dans notre exemple ci-dessous : COM10).
- Sélectionnez ce port de communication dans l'environnement Arduino en utilisant le menu déroulant situé en haut à gauche, comme indiqué dans l'exemple (indiqué comme "Unknown COM10" dans cet exemple).
- Choisissez le modèle de carte approprié pour votre ESP32 dans les options de carte disponibles. Pour cet exemple, sélectionnez "FireBeetle 2 ESP32-E" (voir dans l’exemple ci-dessous).
Étape 2 : Assignation des pins des capteurs dans le code
- Dans le code, de la ligne 13 à 17, remplacez les marqueurs "Ax" et "Dx" par les numéros de pin correspondants à votre câblage sur la carte d'extension de l'ESP32. Par exemple, si le pin analogique pour le capteur de TDS est 9, remplacez "TDS_Sensor_Pin_Num Ax" par "TDS_Sensor_Pin_Num A9".
Étape 3 : Compiler et charger le code dans l’ESP32
- Un message d’erreur apparaît, notez les numéros des lignes de code mentionnés.
- Remplacez les chaînes de caractères "xxxxx", "yyyyy" et "zzzzz" mentionnées dans les lignes d'erreur par l'identifiant du capteur spécifié. Ces identifiants, comme "TDS_Sensor_Pin_Num" pour le turbidimètre, sont indiqués en orange dans les lignes de code de 13 à 17.
- Assurez-vous que le capteur concerné par l'erreur est correctement décrit dans une fonction dont le nom est en adéquation avec ce capteur, située dans les lignes précédant l’erreur.
- Recompilez le code pour vérifier que les erreurs ont été corrigées.
Une fois le code compilé sans erreurs, chargez-le dans l'ESP32 en cliquant de nouveau sur le bouton encadré en rouge.
Étape 4 : Correction de l'affichage pour une lecture claire des informations des capteurs
- Modifiez la durée de pause entre chaque séquence d'affichage, qui se trouve à la ligne 11. Changez la valeur actuelle de 0,1 seconde à 2 secondes. Notez que cette valeur doit être saisie en millisecondes dans le code.
- Le code pour la première séquence d'affichage est situé entre les lignes 275 et 291. Vous remarquerez que les lignes de texte se superposent, rendant difficile la lecture des informations.
- Corrigez ce problème en ajustant le deuxième paramètre (x) dans la fonction d'affichage u8g2.drawStr(y, x, "texte"); pour bien séparer les informations relatives aux capteurs "Humidity DHT", "Temp DHT", et "pH" sur l'afficheur.
Étape 5 : Activation d’un message d’alerte sur l’afficheur
- Identifiez dans le code les lignes 309 à 328 qui permettront d'afficher un message d'alerte en lien avec le capteur de turbidité.
- Actuellement, ces lignes sont en commentaire et ne sont pas prises en compte lors de la compilation. Pour les activer, supprimez les marqueurs de commentaire /* et */ qui se trouvent respectivement aux lignes 315 et 328.
- Relevez la valeur de turbidité affichée sur votre appareil et définissez un seuil inférieur à cette valeur. Modifiez la valeur dans la déclaration (float seuil = x;) pour y placer votre seuil (supérieur à 0 et inférieur à votre valeur d’affichage).
- Compilez et téléchargez à nouveau le programme dans votre ESP32.
- Testez le fonctionnement du message d’alerte en plaçant une feuille de papier devant le turbidimètre pour simuler une turbidité élevée.
Jour 4 - Tests
Mission :
Aujourd’hui, votre objectif est de tester les différents échantillons d’eau qui nous sont parvenu de trois pays différents avec votre station AquaLife. Vous avez un échantillon d’un cours d’eau de l’Australie (noté A), la Brésil (noté B), le Canada (noté C) et un cours d’eau en Alsace qui sera le Témoin (noté T), faites les analyses et compléter le tableau proposé dans le document.
Étape 1 : Collecte et préparation des échantillons d’eau
- Notez et remplissez à moitié quatre gobelets avec des échantillons d'eau provenant de différents pays : Australie (noté A), Brésil (noté B), Canada (noté C) et le cours d’eau en Alsace qui servira de Témoin (noté T).
- Avant de verser l'eau dans les gobelets, agitez bien les bouteilles pour homogénéiser les échantillons.
- Utilisez un cinquième gobelet pour rincer vos capteurs après chaque analyse. Remplissez ce gobelet avec de l'eau du robinet. Assurez-vous de changer l'eau de rinçage dans ce gobelet entre chaque type d’eau analysé (A, B, C, et T).
Étape 2 : Analyses physique des échantillons d’eau A, B, C et T
- Pour analyser un échantillon, par exemple l'échantillon A, plongez les capteurs dans le gobelet correspondant. Homogénéisez la solution en remuant doucement le gobelet ou en déplaçant lentement les capteurs dans l'eau.
- Notez les résultats de l'analyse dans le tableau prévu à cet effet (Voir 4ème partie : Compléter le tableau avec vos analyses).
- Après chaque analyse, rincez les capteurs dans le gobelet de rinçage. Répétez la mesure jusqu'à obtenir trois résultats pour chaque capteur et pour chaque échantillon. Ce processus, appelé "tripliquas", est expliqué plus en détail un peu plus loin.
- Pensez à changer l'eau du gobelet de rinçage entre chaque type d’eau analysé (A, B, C et T).
Étape 3 : Analyses chimiques des échantillons d’eau A, B, C et T
- Réalisez l’analyse chimique du Nitrate, à l’aide du photomètre. C'est un appareil qui permet de mesurer la concentration en polluants. Celui-ci mesure la différence entre l’échantillon et la solution (Echantillon avec le réactif), grâce au changement de couleur.
- Pour cela, suivez le protocole illustré dans le schéma ci-dessous.
- Notez les résultats de l'analyse dans le tableau prévu à cet effet un peu plus loin.
Protocole du Photomètre :
1. Prélèvement : À l'aide d'une pipette jaugée, prélevez 10 ml de l’échantillon à analyser.
2. Transfert : Versez l’eau de la pipette jaugée dans une cuvette propre.
3. Calibration : Réalisez un étalonnage en faisant le blanc (zéro) pour ajuster le photomètre avant l'analyse proprement dite.
4. Ajout du réactif : Introduisez le réactif approprié dans l’échantillon.
5. Mélange : Agitez doucement la solution pour bien mélanger le réactif avec l'échantillon.
6. Mesure : Placez la cuvette dans le photomètre et lancez la mesure en appuyant sur le bouton "start".
Schéma d’utilisation du photomètre
Étape 4 : Compléter le tableau avec vos analyses
Echantillon |
Témoin (T) |
Australie (A) |
Brésil (B) |
Canada (C) |
pH |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Turbidité |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Conductivité |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Température |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Nitrate |
|
|
|
|
Tableau des analyses des échantillons des différents pays
Les chercheurs font aussi des analyses en tripliquas, pourquoi ?
Lorsqu'on réalise des analyses en tripliquas, cela signifie qu'on fait la même expérience trois fois. Cela peut sembler répétitif, mais c’est très important, surtout dans la recherche scientifique.
Confirmer les résultats : Imagine que tu essaies une nouvelle recette de cookies avec tes amis. Si tu ne fais qu'un seul cookie et qu'il est parfait, c'est génial, mais tu ne sais pas si c'est parce que tu as suivi la recette à la lettre ou si tu as juste eu de la chance. Si tu fais trois fournées de cookies et qu'elles sont toutes délicieuses, alors tu peux être sûr que la recette est bonne.
Trouver les erreurs : Parfois, une erreur peut se glisser dans une expérience. Si tu ne fais l'expérience qu'une seule fois et qu'il y a une erreur, tu ne le sauras jamais. Mais si tu fais l'expérience trois fois et que les résultats de l'une sont différents des autres, cela peut te signaler qu'il y a eu un problème quelque part. Cela aide à être plus précis.
Moyenne des résultats : Lorsqu’on fait une expérience plusieurs fois, on peut calculer la moyenne des résultats. Cela permet d'avoir une idée plus claire de ce qui se passe réellement. Par exemple, si un jour il fait 25°C, un autre 28°C et un autre 26°C, la température moyenne te donne une idée plus stable du temps qu'il fait réellement.
En faisant des analyses en tripliquas, les scientifiques s’assurent que leurs découvertes sont solides et fiables. C’est comme vérifier ton travail en mathématiques ; plus tu vérifies, plus tu es sûr de ton résultat !
Jour 5 - Analyse et Présentation
Mission :
Aujourd’hui, votre objectif est de traiter les données des différents échantillons prélevés dans les cours d’eau de l’Australie (noté A), la Brésil (noté B), le Canada (noté C) et le Témoin Alsace (noté T). Pour cela, vous devez traiter vos données à l’aide d’un fichier Excel, interpréter vos résultats pour apporter vos conclusions et enfin compléter un PowerPoint pour présenter vos résultats.
Étape 1 : Traitement des données à l’aide d’un fichier Excel
- Complétez le tableau Excel à votre disposition avec les données récoltées la veille par votre station AquaLife.
- Calculer la moyenne de vos tripliquas en utilisant la formule entre crochet [=MOYENNE(Cellule1; Cellule2; Cellule3)]
Rappel : une Cellule = Colonne + Ligne
Exemple : Cellule1 pour le premier échantillon de pH du Témoin est B2 qui contient la valeur 7,6 dans l’exemple. - Les graphiques pour le pH, la conductivité, la turbidité et la concentration en Nitrate apparaissent. Attention plusieurs erreurs se sont glissées à l’intérieur et il faut les corriger. Le graphique pour le pH est correct. Utilisez ce format comme modèle pour corriger les autres graphiques, en suivant les instructions ci-dessous :
o Pour le graphique de la turbidité, il manque l’échantillon Témoin. Pour l’ajouter, faites un clic droit sur le graphique et allez dans "Sélectionner les donnes… " et cochez la case correspondant au Témoin (T).
o Pour le graphique de la conductivité, il manque les étiquettes des valeurs de vos échantillons. Pour les ajouter, faites un clic gauche sur le graphique et allez dans "Eléments de graphique" en haut à droite du graphique pour cocher la case "étiquette de données" pour les ajouter.
o Le graphique de la concentration en Nitrates est au format pourcentage (%), ce qui ne permet pas de distinguer les différences entre les échantillons. Faites un clic droit sur le graphique pour aller dans "Modifier le type de graphique" et choisissez "Histogramme groupé".
Étape 2 : Interprétation et conclusion
- Compléter le tableau ci-dessous, pour cela ajouter des - / + /++ dans chaque ligne en fonction des informations présentées par la suite sur le pH, la turbidité, la conductivité et la concentration en nitrate de vos échantillons.
Allez lire l’Exemple dans la section pH en bas de la page. - Faite le Bilan en comptant le nombre de + pour chaque échantillon. Celui qui en a le plus est probablement le cours d’eau le plus contaminé.
Attention, il n’y a pas de bonnes ou mauvaises réponses, c’est à vous d’interpréter vos résultats !
Echantillon |
Australie (A) |
Brésil (B) |
Canada (C) |
pH |
|
|
|
Turbidité |
|
|
|
Conductivité |
|
|
|
Nitrate |
|
|
|
Bilan |
|
|
|
· Le pH, c'est comme une échelle qui nous dit si l'eau est acide, neutre ou basique. Pour les rivières et les lacs, le mieux, c'est que leur pH soit entre 6,5 et 8,5. C'est comme être juste au milieu, ni trop acide, ni trop basique, ce qui est parfait pour les plantes et les animaux qui vivent dans l'eau.
o Si le pH est en dessous de 6,5, l'eau est trop acide, ça peut être difficile pour les poissons et d'autres créatures aquatiques de vivre, grandir et se reproduire normalement. Cela peut arriver à cause de la pollution de l'air qui tombe avec la pluie.
o Si le pH est au-dessus de 8,5, l'eau est trop basique, ça peut aussi causer des problèmes aux poissons et à leur environnement, comme irriter leur peau ou changer la façon dont certains nutriments et toxines se comportent dans l'eau. Cela peut être dû à des rejets d'usines.
Exemple : Si j’ai un pH compris entre 6,5 et 8,5 alors je vais noter – dans mon tableau ; en revanche, si j’ai un pH compris entre 8,5 et 10, alors je vais noter +, car celui-ci s’éloigne un peu de la normal, mais si j’ai un pH > 10 alors ++, car celui-ci s’éloigne fortement de la normal.
Enfin, si j’ai un pH compris entre 5 et 6,5, alors je vais noter +, car celui-ci s’éloigne un peu de la normal, mais si j’ai un pH < 5 alors ++, car celui-ci s’éloigne fortement de la normal.
- La turbidité, correspond au trouble présent dans l'eau.
o Si la turbidité est au-dessus du niveau normal (Témoin), cela signifie généralement que l'eau est très claire. Cela peut être bon pour la pénétration de la lumière et aide à maintenir un écosystème sain pour la photosynthèse des plantes aquatiques.
o Si la turbidité est en dessous du niveau normal (Témoin), l'eau devient plus trouble. Cela peut être causé par des activités humaines comme le défrichement des terres ou la construction, qui déplacent beaucoup de terre. Une eau trouble peut créer plusieurs problèmes pour les animaux aquatiques comme des difficultés respiratoires (Les particules fines dans l'eau peuvent bloquer ou endommager les branchies des poissons, rendant difficile pour eux de respirer).
- La conductivité, est une mesure qui nous dit combien l'eau peut conduire l'électricité. Pour les rivières et les lacs, une conductivité normale peut varier entre 50 et 1500 microsiemens par centimètre (µS/cm).
o Si la conductivité est en dessous du niveau normal (50-1500), cela peut signifier que l'eau est très pure. Bien que cela puisse sembler positif, une faible conductivité peut parfois limiter la disponibilité de certains nutriments essentiels pour la vie aquatique, affectant ainsi les organismes qui dépendent de ces nutriments.
o Si la conductivité est au-dessus du niveau normal (50-1500), cela peut être dû à des activités humaines telles que l'agriculture, où des fertilisants riches en minéraux sont utilisés, ou des effluents industriels. Une conductivité élevée peut poser des problèmes pour les espèces aquatiques.
- La concentration en nitrate, est un indicateur important de la santé d'un cours d'eau, car les nitrates sont une forme de nutriment essentiel pour la croissance des plantes, mais peuvent être problématiques en grande quantité. Normalement, une concentration en nitrate dans un cours d'eau devrait être inférieure à 1000 microgramme par litre (µg/L) pour être considérée comme sûre pour la plupart des écosystèmes aquatiques.
o Si la concentration en nitrate est en dessous du niveau normal, cela peut signifier qu'il y a peu de sources de pollution par les nitrates à proximité.
o Si la concentration en nitrate est au-dessus du niveau normal, cela peut être un signe de pollution comme les déchets agricoles ou les eaux usées non traitées. Des niveaux élevés de nitrates peuvent entraîner plusieurs problèmes écologiques, notamment des effets sur la santé des organismes aquatiques et risque pour la santé humaine.
Étape 3 : Mise en forme des résultats sur PowerPoint
- Vous devez compléter la présentation PowerPoint en ajoutant vos graphiques dans les emplacements prévus : pH, turbidité, conductivité et concentration en nitrate. Pour cela faite un copier-coller de vos graphiques que vous avez créé de votre fichier Excel. Attention pour garder le bon code couleur, vous devez faire copier Ctrl+C et un collage spécial image avec le raccourci Ctrl+Alt+V.
- Pour finir, remplacer les XXX par le nom du Pays qui a le cours d’eau le plus pollué d’après vos résultats.
Félicitation vous avez réussi votre mission et
identifié le cours d’eau le plus pollué parmi les échantillons d’eau !!
Vous devez avoir obtenu une présentation qui ressemble à celle ci-dessous :
Matériel et Plateforme standards pour la robotique éducative
Où acheter des composants et cartes électroniques :
- https://www.lextronic.fr/
- https://fr.rs-online.com/
- https://www.conrad.fr
- https://www.generationrobots.com/
- https://www.robot-maker.com/
- https://eu.robotshop.com/fr/
Composant standards choisis et plateformes robotiques possibles :
Fonction |
Composant |
LittleBot |
K2024 |
Référence |
Prix unitaire (€) |
Microcontrôleur |
Arduino Nano | 1 | 1 |
https://www.lextronic.fr/carte-seeeduino-nano-102010268-59340.html | 10 |
Carte de développement |
Sensor Shield Nano compatible UNO |
1 |
1 |
https://www.amazon.fr/Expansion-sensor-Shield-compatible-Arduino/dp/B072FCNF54 | 3 |
Câble Alim + Prog |
USB C |
1 |
1 |
1 |
|
Actionneur |
servomoteur à rotation 360° | 2 |
0 |
DM-S0090D-R 9g/0.08s/1.6kg.cm | 2 |
servomoteur à rotation 180° | 0 |
1 |
|||
Capteur |
module ultrason |
1 |
0 |
HC-SR04 | 1 |
Capteur de ligne |
0 |
1 |
Source en lecture seule (accès en écriture interne IUT, ou sur demande)
- 1 x Arduino Nano ou compatible (seeeduino, funduino,...) : ~10€
- 1 x câble USB C : ~1€
- 1 x Sensor Shield pour Arduino Nano : ~3€
- 2 x servomoteur à rotation 360° (DM-S0090D-R 9g/0.08s/1.6kg.cm) : ~2€
- 1 x Module ultrason (HC-SR04) : ~2€
- 2 x élastique pour les roues (diamètre Xmm)