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
- Composants Electronique
- Qu'est ce qu'un servo-moteur ?
- Programmation d'un servomoteur
- Qu'est ce qu'un capteur à ultrasons ?
- Batterie et Shield 18650 & Co
- Séance Thématique
- Club Robotique Cycle 0 - Codey Rocky
- Phase 1 - Découverte des Codey Rocky et de Mblock
- Phase 2 - Approfondissement des fonctionnalités du Codey Rocky
- Phase 3 - Suivi de ligne avec Codey
- Club Robotique Cycle 1 - LittleBot
- Description du projet
- Programmation d'actionneurs et de capteur
- Modification du châssis du LittleBot
- Montage et Câblage du LittleBot
- Programmation du LittleBot
- Club Robotique Cycle 2 - Station de mesure (T°, H)
- Phase 1 - Assemblage des Composants et Introduction à la Modélisation 3D
- Phase 2 - Impression 3D
- Phase 3 - Programmation
- Phase 4 - Mesure et Analyse des Données de Température avec le Capteur DHT22
- 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
- Club Robotique Cycle 4 - Bras Robotique
- Club Robotique Cycle 5 - Poubelle Connectée
- Phase 1 - Théorie et fonctionnement des composants
- Phase 2 - Utilisation des composants et programmation de la poubelle connectée
- Club Robotique Cycle 6 - Plieur de Linge
- Stages de Robotique pour les collégiens - Station Mesure Eau
- Fiche résumé
- Conception technique du stage
- Conception de la formation des animateurs
- Ateliers de développement de la station de mesure de l'eau (5 jours)
- Atelier de formation des animateurs
- Matériel et Plateforme standards pour la robotique éducative
- Club Robotique - Robot Araignée
- Sélection de ressources sur la robotique éducative
- Pour les animateurs et la création pédagogique des clubs
- Mblock
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.
Composants Electronique
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:
Servomoteur contrôlé en position "180°" ou en vitesse "360°"
Programmation d'un servomoteur
Programmation des Servomoteurs avec mBlock et Arduino IDE
Objectif :
Comprendre le fonctionnement des servomoteurs et apprendre à les programmer avec mBlock et Arduino IDE.
1. Introduction aux Servomoteurs
Qu’est-ce qu’un servomoteur ?
Un servomoteur est un moteur à rotation limitée, généralement 180°, qui est contrôlé par un signal PWM (Pulse Width Modulation). Il est utilisé dans de nombreux projets tels que les bras robotisés, les portes automatiques et les robots éducatifs.
➡️ Pour en savoir plus sur les servomoteurs, cliquez ici.
2. Configuration et Programmation avec mBlock
Présentation des blocs spécifiques à la gestion des servomoteurs
Dans mBlock, la gestion des servomoteurs se fait à l’aide d’un bloc dédié permettant de définir un angle précis entre 0° et 180°.
Pour un servomoteur 360 on va utiliser le bloc ci-dessous que l'on peut trouver dans l'extensions "Servo360" ou ici "servo.mext" à télécharger.
Numéro de broche vitesse du servomoteur (dans un sens entre [-100 et 0[ et dans l'autre entre 0] et 100])
Branchement d'un servomoteur à un Arduino Nano
Un servomoteur possède trois câbles :
-
Noir ou Marron → GND (Masse)
-
Rouge → 5V (Alimentation)
-
Jaune ou Orange → Signal (Entre les broches 2 et 13 du Nano)
Exercice 1 : Programmer un servomoteur en boucle
Consigne : Programmer un servomoteur 180° pour qu'il effectue en boucle un mouvement de 0° à 180° puis de 180° à 0°, avec une pause de 2 secondes entre chaque mouvement.
Correction :
Exercice 2 : Inverser le sens de rotation
Consigne : Programmer un servomoteur 360 pour qu'il effectue en boucle un changement de sens de rotation à vitesse maximale et cela toute les 2 secondes.
Correction :
3. Programmation d’un Mouvement Automatisé avec mBlock
Exercice 1 :
Créer un programme permettant :
✅ De faire bouger le servomoteur progressivement de 0° à 180° et inversement.
✅ De répéter le mouvement avec une boucle continue.
Correction :
4. Configuration et Programmation avec Arduino IDE
Exercice 1 : Programmer un servomoteur pour un mouvement en boucle
Consigne : Faire osciller un servomoteur de 0° à 180° et inversement, avec une pause de 2 secondes entre chaque mouvement.
Correction : Code Arduino IDE
#include <Servo.h>
Servo monServo; // Création de l'objet Servo
void setup() {
monServo.attach(9); // Connexion du servomoteur sur la broche D9
}
void loop() {
monServo.write(0); // Position à 0°
delay(2000); // Pause de 2 secondes
monServo.write(180); // Position à 180°
delay(2000); // Pause de 2 secondes
}
Exercice 2 : Inverser le sens de rotation
Consigne : Programmer un servomoteur 360 pour qu'il effectue en boucle un changement de sens de rotation à vitesse maximale et cela toute les 2 secondes.
Correction :
#include <Servo.h>
Servo monServo; // Création de l'objet Servo
void setup() {
monServo.attach(9); // Connexion du servomoteur sur la broche D9
}
void loop() {
monServo.writeMicroseconds(2000); // Vitesse maximale dans un sens
delay(2000); // Tourne pendant 2 secondes
monServo.writeMicroseconds(1000); // Vitesse maximale dans l'autre sens
delay(2000); // Tourne pendant 2 secondes
}
5. Programmation d’un Mouvement Automatisé avec Arduino IDE
Exercice 1 :
Créer un programme permettant :
✅ De faire bouger progressivement le servomoteur de 0° à 180° et inversement.
✅ D’utiliser une boucle pour répéter ce mouvement en continu.*
Correction :
#include <Servo.h>
Servo monServo;
void setup() {
monServo.attach(9);
}
void loop() {
for (int pos = 0; pos <= 180; pos++) { // De 0° à 180°
monServo.write(pos);
delay(15); // Ajuste la vitesse du mouvement
}
for (int pos = 180; pos >= 0; pos--) { // De 180° à 0°
monServo.write(pos);
delay(15);
}
}
6. Discussion et Applications
Applications pratiques
-
🤖 Bras robotisé
-
🗑️ Poubelle connectée
-
🤖 Little Bot
Questions et suggestions d’amélioration
✅ Ajouter un potentiomètre pour contrôler l’angle du servomoteur.
✅ Utiliser un bouton poussoir pour déclencher le mouvement.
✅ Remplacer le servomoteur 180° par un servomoteur à rotation continue.
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 moniteur série du Mblock.
Ce code permet de mesurer une distance et de l'afficher sur le moniteur série 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);
delay(2000);
}
Source :
https://www.moussasoft.com/hc-sr04-capteur-ultrason-avec-arduino
Batterie et Shield 18650 & Co
Carte de charge et décharge
Les shields de charge et décharge des batteries 18650, Lithion-Ion, 3.7V permettent :
- INput : charge de la batterie via ports
- USB-C ou micro-USB
- 1.8A 5V (max 6.5V)
- OUTput : décharge de la batterie (alimentation d'une carte électronique) via ports
- USB-C, USB-A
- pins 5V (3A) / 3.3V (1A) dispos sur les bords de la carte
- Bouton noir SW1 :
- "Vers l'intérieur de la carte " : Alimentation permanente
ALWAYS ON
- "Vers l'extérieur de la carte" : Mise en veille automatique au bout de 40s
AUTO-OFF
. Consommation 3uA après la mise en veille.
- "Vers l'intérieur de la carte " : Alimentation permanente
- Bouton blanc Power ON/OFF :
- Appuyer pour allumer
ON
- Appuyer 2 fois pour éteindre
OFF
- Appuyer pour allumer
On a une version simple accu "V3" et une double accu "V8" :
1. simple accu "V3" :
2. double accu "V8" :
Séance Thématique
Séance Pâques
Club Robotique Cycle 0 - Codey Rocky
Phase 1 - Découverte des Codey Rocky et de Mblock
Phase 1 - Découverte des Codey Rocky et de Mblock
Objectif général :
L'objectif de cette activité est d'initier les élèves à la robotique et à la programmation à travers l’utilisation du robot Codey Rocky et du logiciel mBlock. Ils apprendront à concevoir des algorithmes pour programmer le robot et effectuer différentes missions. À travers trois parcours progressifs, ils développeront des compétences en logique, en résolution de problèmes et en collaboration.
Compétences techniques :
-
Programmation visuelle avec mBlock : Les élèves apprendront à utiliser l'interface de blocs pour créer des programmes simples.
-
Manipulation du robot Codey Rocky : Savoir piloter le robot en utilisant ses moteurs pour réaliser des tâches spécifiques comme se déplacer.
-
Débogage : Les élèves seront amenés à tester leurs programmes et corriger les erreurs rencontrées. Cette compétence est cruciale pour améliorer leur compréhension de la logique algorithmique et de la robotique.
-
Algorithmes et logique : Les élèves devront structurer leurs programmes de façon à exécuter les tâches demandées de manière optimale, en tenant compte des défis présentés dans chaque parcours.
Savoir-être :
-
Persévérance : Les élèves devront faire preuve de persévérance pour tester, corriger et améliorer leurs programmes. Ils apprendront que les échecs font partie du processus d'apprentissage.
-
Collaboration : Les élèves seront amenés à travailler en groupes ou en binômes pour résoudre les problèmes ensemble, échanger des idées et trouver des solutions innovantes.
-
Patience : La création d’un programme, sa mise en œuvre, et son ajustement nécessitent du temps et de la concentration. Les élèves devront apprendre à être patients pour surmonter les défis.
-
Créativité : Ils auront l’opportunité de faire preuve de créativité, en particulier dans les tâches plus ouvertes, pour trouver des solutions innovantes et personnelles à des problèmes techniques.
Compétences transversales :
-
Résolution de problèmes : Chaque parcours présente des défis spécifiques. Les élèves devront analyser les problèmes rencontrés et ajuster leur programme pour les résoudre de manière autonome ou en groupe.
-
Pensée logique et algorithmique : Organiser des instructions dans un ordre cohérent pour atteindre les objectifs fixés, en tenant compte des conditions et des événements du parcours.
-
Gestion du temps et organisation : Les élèves devront apprendre à gérer leur temps pour tester et ajuster leurs programmes tout en respectant le cadre temporel de l'activité.
-
Autonomie et prise d’initiative : Bien que le travail collaboratif soit encouragé, les élèves devront également montrer de l’autonomie dans la recherche de solutions et dans la mise en œuvre de leurs programmes.
Déroulement des parcours
Les élèves devront accomplir trois parcours progressifs avec le robot Codey Rocky. Pour chaque parcours, ils devront suivre des étapes précises de programmation à l’aide du logiciel mBlock et adapter leur code en fonction des résultats observés sur le terrain. Voici comment organiser les trois parcours :
Parcours 1 :
- Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge.
- Objectif du parcours : Les élèves ont pour but d'aller du point vert jusqu'au point rouge en utilisant que les blocs se trouvant dans les onglets "Action" et "Evénements".
- Étapes de la programmation :
- Créer une séquence de base pour faire avancer le robot.
- Ajouter des commandes pour faire tourner le robot.
- Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
- Discussion de groupe : Échanger sur les difficultés rencontrées et les solutions trouvées.
- Correction :
Parcours 2 :
- Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge.
- Objectif du parcours : Les élèves ont pour but d'aller du point vert jusqu'au point rouge en utilisant que les blocs se trouvant dans les onglets "Action" et "Evénements".
- Étapes de la programmation :
- Créer une séquence de base pour faire avancer le robot.
- Ajouter des commandes pour faire tourner le robot.
- Créer une séquence de base pour faire avancer le robot.
- Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
- Bilan collectif : Échanger sur les difficultés rencontrées et les solutions trouvées.
- Correction :
Parcours 3 :
- Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge..
- Objectif du parcours : Les élèves ont pour but d'aller du point vert jusqu'au point rouge en utilisant que les blocs se trouvant dans les onglets "Action" et "Evénements".
- Étapes de la programmation :
- Créer une séquence de base pour faire avancer le robot.
- Ajouter des commandes pour faire tourner le robot.
- Créer une séquence de base pour faire avancer le robot.
- Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
- Présentation finale : Échanger sur les difficultés rencontrées et les solutions trouvées.
- Correction :
Conclusion et retour d'expérience
À la fin de l'activité, chaque groupe fera un retour sur son expérience :
- Quelles étaient les difficultés rencontrées ?
- Quelles solutions ont été trouvées ?
- Quelles compétences ont été développées ?
L’enseignant pourra également faire une synthèse des compétences acquises et des progrès réalisés.
Phase 2 - Approfondissement des fonctionnalités du Codey Rocky
Phase 2 - Approfondissement des fonctionnalités du Codey Rocky
Objectif général :
L'objectif de cette activité est d'initier les élèves à la robotique et à la programmation à travers l’utilisation du robot Codey Rocky et du logiciel mBlock. Ils apprendront à concevoir des algorithmes pour programmer le robot et effectuer différentes missions. À travers deux parcours progressifs, ils développeront des compétences en logique, en résolution de problèmes et en collaboration.
Compétences techniques :
-
Programmation visuelle avec mBlock : Les élèves apprendront à utiliser l'interface de blocs pour créer des programmes simples, incluant des boucles de répétition et l’utilisation des capteurs du robot.
-
Manipulation du robot Codey Rocky : Savoir piloter le robot en utilisant ses moteurs pour réaliser des tâches spécifiques comme se déplacer, détecter des obstacles ou effectuer des boucles de mouvement.
-
Débogage : Les élèves seront amenés à tester leurs programmes et corriger les erreurs rencontrées. Cette compétence est essentielle pour améliorer leur compréhension de la logique algorithmique et de la robotique.
-
Algorithmes et logique : Les élèves devront structurer leurs programmes de manière optimale en intégrant des boucles de répétition ou en répondant à des conditions basées sur les capteurs.
Savoir-être :
-
Persévérance : Les élèves devront faire preuve de persévérance pour tester, corriger et améliorer leurs programmes. Ils apprendront que les échecs font partie du processus d'apprentissage.
-
Collaboration : Travailler en binômes ou en groupe pour résoudre les problèmes ensemble, partager des idées et collaborer pour trouver des solutions.
-
Patience : Apprendre à prendre le temps d’analyser les résultats, ajuster les paramètres et modifier les programmes en conséquence.
-
Créativité : Les élèves auront l’opportunité d’utiliser leurs idées pour résoudre les défis proposés de manière personnelle et originale.
Compétences transversales :
-
Résolution de problèmes : Chaque parcours présente des défis spécifiques. Les élèves devront analyser les problèmes rencontrés et ajuster leur programme pour les résoudre de manière autonome ou en groupe.
-
Pensée logique et algorithmique : Organiser des instructions dans un ordre cohérent et adapté aux objectifs fixés, notamment en utilisant des boucles de répétition et des conditions liées aux capteurs.
-
Gestion du temps et organisation : Les élèves devront gérer leur temps pour tester, ajuster et valider leurs programmes tout en respectant les délais de l’activité.
-
Autonomie et prise d'initiative : Bien que le travail collaboratif soit encouragé, les élèves devront également faire preuve d’autonomie pour trouver des solutions et tester leurs propres idées de programmation.
Déroulement des parcours
Les élèves réaliseront deux parcours en utilisant le robot Codey Rocky. Pour chaque parcours, ils devront suivre des étapes précises de programmation à l’aide du logiciel mBlock, puis ajuster leur code en fonction des résultats observés.
Parcours 1 : Utilisation d’une boucle de répétition
-
Présentation du défi : Expliquer aux élèves le but du premier parcours, qui consiste à programmer Codey Rocky pour effectuer un trajet spécifique en boucle, ici une boucle répétitives de 3.
-
Objectif du parcours : Utiliser une boucle de répétition pour faire en sorte que le robot répète une séquence de mouvements de manière continue. Le nombre de blocs maximum dans ce programme est de 5.
-
Étapes de la programmation :
- Créer une séquence de base pour faire avancer le robot et tourner à différents points.
- Intégrer une boucle de répétition pour que le robot répète cette séquence plusieurs fois.
-
Test et ajustements : Laisser les élèves tester leur programme et ajuster les paramètres si nécessaire pour garantir que le robot complète le parcours sans erreur.
-
Discussion de groupe : Échanger sur les difficultés rencontrées et les solutions trouvées. Comparer les différentes manières dont les élèves ont utilisé les boucles pour optimiser leurs programmes.*
- Correction :
Parcours 2 : Utilisation du capteur de détection d’obstacles
-
Présentation du défi : Expliquer aux élèves que le second parcours consiste à programmer le robot pour se déplacer en détectant et en évitant des obstacles grâce à son capteur de distance.
-
Objectif du parcours : Utiliser le capteur de détection d’obstacles pour permettre à Codey Rocky de réagir à son environnement en modifiant son comportement lorsqu’il rencontre un obstacle.
-
Étapes de la programmation :
- Créer une séquence de base pour faire avancer le robot.
- Intégrer le capteur de distance pour détecter les obstacles et faire en sorte que le robot s’arrête lorsqu’il en rencontre un.
- Utiliser des blocs de conditions (« si... alors... ») pour que le robot prenne des décisions en fonction de ce qu’il détecte.
-
Test et ajustements : Permettre aux élèves de tester leur programme sur un parcours avec des obstacles. Ils devront observer comment le robot réagit et ajuster les conditions et distances de détection si nécessaire.
-
Bilan collectif : Faire un retour en groupe sur les difficultés rencontrées, notamment sur l’utilisation des capteurs, et discuter des solutions trouvées pour que le robot puisse naviguer correctement dans un environnement rempli d’obstacles.
- Correction :
Conclusion et retour d’expérience
À la fin de l'activité, chaque groupe partagera son expérience avec la classe :
- Quelles difficultés ont-ils rencontrées ?
- Quelles solutions ont été mises en place ?
- Quelles compétences ont-ils développées (persévérance, logique, collaboration) ?
Phase 3 - Suivi de ligne avec Codey
Phase 3 - Suivi de ligne avec Codey
Objectif général :
Dans cette phase, les élèves vont approfondir leurs compétences en programmation et robotique en apprenant à créer un suiveur de ligne avec le robot Codey Rocky. Ils vont programmer deux types de suivi de ligne : un suivi basique basé sur des conditions simples, et un suivi fluide, qui optimise les mouvements du robot pour un déplacement plus souple.
Compétences techniques :
-
Utilisation des capteurs de lumière : Les élèves apprendront à utiliser les capteurs de détection de couleur du robot pour différencier les surfaces noires et blanches.
-
Programmation conditionnelle : Ils utiliseront des blocs de conditions (« si... alors... ») pour réagir à la détection de couleurs et ajuster les mouvements du robot en conséquence.
-
Optimisation du mouvement : Pour le second parcours, les élèves découvriront comment améliorer la fluidité des déplacements du robot en ajustant la sensibilité des capteurs et la vitesse des roues.
-
Débogage et ajustement de paramètres : Les élèves devront tester, corriger et ajuster leurs programmes pour que le robot suive la ligne de manière efficace, qu’il s’agisse d’un suivi de ligne basique ou fluide.
Compétences transversales :
-
Résolution de problèmes : Les élèves devront ajuster leurs algorithmes et leur logique en fonction des résultats obtenus lors des tests.
-
Précision et ajustement des paramètres : Pour le parcours fluide, ils apprendront à affiner les réglages de vitesse et la sensibilité des capteurs pour obtenir un comportement plus naturel et efficace.
-
Gestion du temps : Organiser leur temps pour concevoir, tester, ajuster et valider leur programme dans les délais impartis.
-
Esprit d’équipe : Travailler en binôme ou en groupe pour résoudre les défis de suivi de ligne, partager des idées et améliorer les solutions ensemble.
Déroulement des parcours
Les élèves réaliseront deux parcours distincts avec des niveaux de difficulté croissants pour programmer Codey Rocky à suivre une ligne tracée au sol.
Parcours 1 : Suiveur de ligne basique
-
Présentation du défi : Le robot doit suivre une ligne en alternant les actions des roues en fonction de la couleur détectée (noir ou blanc).
-
Objectif du parcours :
- Si le capteur de gauche détecte la couleur noire, seule la roue gauche s'active pour tourner vers la droite.
- Si le capteur de droite détecte la couleur blanche, seule la roue droite s'active pour tourner vers la gauche.
-
Étapes de la programmation :
- Utiliser les blocs conditionnels pour définir les actions des roues selon la couleur détectée par les capteurs de Codey Rocky.
- Assigner les actions des roues en fonction de la couleur noire pour tourner à droite et de la couleur blanche pour tourner à gauche.
-
Test et ajustements :
- Laisser les élèves tester leur programme sur une piste simple avec une ligne noire sur fond blanc.
- Ils ajusteront les vitesses des roues et les conditions si le robot dévie ou ne suit pas correctement la ligne.
-
Discussion de groupe : Échanger sur les stratégies utilisées pour améliorer le suivi de la ligne et résoudre les problèmes de déviation ou de perte de la ligne.
- Correction :
Parcours 2 : Suivi de ligne fluide
-
Présentation du défi : Cette fois-ci, les élèves doivent programmer le robot pour qu'il suive la ligne de manière plus fluide, avec des virages progressifs et sans arrêts brusques.
-
Objectif du parcours :
- Utiliser les capteurs pour ajuster progressivement la vitesse des roues, afin de maintenir le robot centré sur la ligne et éviter des mouvements saccadés.
- Utiliser les capteurs pour ajuster progressivement la vitesse des roues, afin de maintenir le robot centré sur la ligne et éviter des mouvements saccadés.
-
Étapes de la programmation :
- Utiliser les capteurs de lumière pour détecter la position du robot par rapport à la ligne.
- Ajuster la vitesse des roues de façon continue (par exemple, faire ralentir une roue au lieu de l'arrêter complètement).
- Éviter les changements de direction trop brusques en ajustant les conditions de manière plus douce et progressive.
-
Test et ajustements :
- Les élèves testeront le robot sur une piste avec des courbes plus complexes.
- Ils ajusteront la vitesse des roues en fonction des courbes et de la réactivité des capteurs pour rendre les mouvements plus fluides.
- Les élèves devront tester plusieurs configurations pour atteindre un suivi fluide.
-
Bilan collectif :
- Comparer les différences entre les deux méthodes de suivi (basique vs fluide).
- Discuter des réglages qui ont permis d'améliorer la fluidité du robot et de l'impact des ajustements sur la vitesse et la précision des mouvements.
- Correction :
Conclusion et retour d’expérience
À la fin de l’activité, chaque groupe pourra partager ses observations :
- Quelles étaient les principales différences entre le suivi de ligne basique et fluide ?
- Quels ajustements étaient nécessaires pour améliorer la précision et la fluidité ?
- Quelles compétences techniques et transversales ont été développées ?
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
- classe de CM1 à 5ème
- Notions de base en électricité et circuit électronique
- Notions de base en géométrie
- Des bases en Langage de programmation par bloc "scratch" et pour les collégiens en langage "C"
-
Logiciels :
- Programmation : MBlock (scratch) et Arduino IDE (C)
- Modélisation CAO : TinkerCAD, ONSHAPE, FreeCAD
- Préparation impression 3D (slicer) : Bambu Studio, Cura
-
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é
~9 séances :
- Introduction Arduino et MBlock
- Actionneur : servomoteur (déplacement)
- Capteur : ultrason (distance)
- Couplage capteur moteur
- ~2 séances sur TinkerCAD (modification de certaines pièces du Little Bot)
- ~1 séances sur l'impression 3D
- 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)
- 1 x porte pile 4xaa : ~2€
Une imprimante 3D pour imprimer les pièces suivantes (~5€ de filament) :
- Châssis
- Capot
- Roues avec rainure pour insertion élastique
Programmation d'actionneurs et de capteur
Programmation d'un servomoteur :
Avant de passer au vif du sujet je vous invite à consulter cette page pour savoir comment fonctionne un servomoteur et cette page pour programmer un servomoteur.
Programmation d'un capteur Ultrasons :
Je vous conseille de faire de même pour connaître le fonctionnement et comment savoir programmer ce capteur, vous trouverez tous ca sur cette page.
Programmation d'un servomoteur et d'un capteur Ultrasons :
Vous avez vu comment programmer un servomoteur 180, un servomoteur 360 et un capteur ultrasons, donc maintenant je vais vous proposer quelques exercices à faire pour utiliser ces 3 composants en même temps .
Programmation sur Mblock
Exercice 1 : Changer d'angle d'un servomoteur 180 grâce au capteur ultrasons
Consigne :
Programmez votre carte Arduino pour que le servomoteur réagisse en fonction de la distance mesurée par le capteur à ultrasons :
-
Si la distance mesurée est supérieure à 10 cm, le servomoteur doit se positionner à 180°.
-
Si la distance mesurée est inférieure ou égale à 10 cm, le servomoteur doit se positionner à 0°.
Correction :
Exercice 2 : Changer le sens d'un servomoteur 360 grâce au capteur ultrasons
Consigne :
Programmez votre carte Arduino pour que le servomoteur réagisse en fonction de la distance mesurée par le capteur à ultrasons :
-
Si la distance mesurée est supérieure à 10 cm, le servomoteur doit tourner dans un sens à la vitesse maximale.
-
Si la distance mesurée est inférieure ou égale à 10 cm, le servomoteur tourner dans l'autre sens à la vitesse maximale.
Correction :
Programmation sur Arduino IDE
Exercice 1 : Changer d'angle d'un servomoteur 180 grâce au capteur ultrasons
Consigne :
Programmez votre carte Arduino pour que le servomoteur réagisse en fonction de la distance mesurée par le capteur à ultrasons :
-
Si la distance mesurée est supérieure à 10 cm, le servomoteur doit se positionner à 180°.
-
Si la distance mesurée est inférieure ou égale à 10 cm, le servomoteur doit se positionner à 0°.
Correction :
#include <Servo.h>
// Définir les broches du capteur HC-SR04
const int trigPin = 2;
const int echoPin = 3;
// Définir la broche du servomoteur
const int servoPin = 9;
Servo monServo;
void setup() {
Serial.begin(9600); // Initialisation du moniteur série
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
monServo.attach(servoPin); // Attache le servomoteur à la broche 6
}
void loop() {
// Mesure de la distance
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
long duree = pulseIn(echoPin, HIGH);
float distance = duree * 0.034 / 2; // Conversion en centimètres
Serial.print("Distance : ");
Serial.print(distance);
Serial.println(" cm");
// Contrôle du servomoteur
if (distance > 10) {
monServo.write(180);
} else {
monServo.write(0);
}
delay(200); // Petite pause pour éviter les mesures trop rapides
}
Exercice 2 : Changer le sens d'un servomoteur 360 grâce au capteur ultrasons
Consigne :
Programmez votre carte Arduino pour que le servomoteur réagisse en fonction de la distance mesurée par le capteur à ultrasons :
-
Si la distance mesurée est supérieure à 10 cm, le servomoteur doit tourner dans un sens à la vitesse maximale.
-
Si la distance mesurée est inférieure ou égale à 10 cm, le servomoteur tourner dans l'autre sens à la vitesse maximale.
Correction :
#include <Servo.h>
// Définir les broches du capteur HC-SR04
const int trigPin = 9;
const int echoPin = 10;
// Définir la broche du servomoteur
const int servoPin = 6;
Servo monServo;
void setup() {
Serial.begin(9600); // Initialisation du moniteur série
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
monServo.attach(servoPin); // Attache le servomoteur à la broche 6
}
void loop() {
// Mesure de la distance
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
long duree = pulseIn(echoPin, HIGH);
float distance = duree * 0.034 / 2; // Conversion en centimètres
Serial.print("Distance : ");
Serial.print(distance);
Serial.println(" cm");
// Contrôle du servomoteur
if (distance > 10) {
monServo.writeMicroseconds(2000);
} else {
monServo.writeMicroseconds(1000);
}
delay(200); // Petite pause pour éviter les mesures trop rapides
}
Modification du châssis du LittleBot
Modification du châssis du LittleBot
Le LittleBot dispose déjà de ses fichiers STL, comprenant la tête, la base, deux types de roues, ainsi qu’une demi-sphère permettant de le stabiliser. Toutefois, un problème a été identifié sur le fichier correspondant à la base, que nous allons corriger aujourd’hui.
Problème rencontré
La base du LittleBot a pour fonction de fixer les servomoteurs, de maintenir la batterie en place et de permettre l'installation de la carte Arduino Nano. Cependant, dans le fichier actuel, les trous de fixation du shield pour Arduino Nano ne sont pas positionnés correctement. C’est pourquoi nous allons modifier ce fichier.
Objectif
L’objectif de cette séance est de corriger le positionnement des trous de fixation dans le fichier STL de la base du LittleBot.
Ressources disponibles
Vous pouvez retrouver l’ensemble des fichiers STL du LittleBot ici.
Modification du Fichier :
Avant de commencer la modification, je vous invite à consulter :
- Cette page expliquant comment utiliser Tinkercad pour modifier un fichier 3D
- Cette page expliquant comment créer une classe sur Tinkercad (utile pour le travail en groupe ou en classe).
Étape 1 : Préparation de l’environnement
Une fois la classe créée sur Tinkercad, avec le fichier de référence correctement chargé, et que tous les élèves sont connectés, nous pouvons passer à la phase de modification.
Sur l’interface principale de Tinkercad :
-
Regardez dans la barre de recherche située à droite de l’écran.
-
Tapez le mot "shield" dans le champ de recherche.
-
Sélectionnez le troisième élément proposé dans la liste (il s’agit du modèle de shield compatible avec l’Arduino Nano).
Glisser le sur votre forme comme sur l'image ci-dessous.
Etape 2 :
Positionnez le de manière à ce que le trou en haut à gauche du shield soit parfaitement centré sur celui de la base.
Faire un cylindre de 3mm x 1.5mm x 1.5mm
Puis le placer dans le trou en haut à droite du shield.
Reste juste à sélectionner le cylindre et la base puis à les regrouper avec ce bouton .
Etape 3 :
Pour la dernière étape, il faut percer le bas du châssis afin qu’il puisse bien se caler.
Prendre un carré de 7mm x 3mm x 6 mm.
Et placer le comme les images ci-dessous.
Mettre le cube en mode Perçage et le Regrouper avec la base.
Et voilà le tour et jouer!!!
Montage et Câblage du LittleBot
Le montage :
Etape 1 :
Placez les servomoteurs dans la base du LittleBot en vous référant aux images ci-dessous.
⚠️ Attention : veillez à ce que l’axe des servomoteurs soit bien centré dans le trou prévu pour la roue.
Etape 2 :
Viser les servomoteurs.
Nous allons maintenant passer au câblage du robot, car continuer le montage sans cette étape pourrait compliquer le branchement de certains composants.
Le câblage :
Pour le câblage 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 broche 5V.
- Trig sur la broche 6.
- Echo sur la broche 7.
- GND sur une broche GND
3. Nous allons brancher nos Servomoteurs, les câbles de nos servos sont tous reliés à un raccord. Celui ci ne peut être branché que dans un seul sens. Nous brancherons donc un servo sur la broche 10 et un servo sur la broche 11.
- Le fil marron sur la broche G
- Le fil rouge sur la broche V
- Le fil orange sur la broche S
Ainsi le servo qui est sur la broche 10 sera notre roue droite et le Servo sur la pin 11 sera notre roue gauche.
Votre câblage est terminé.
Dès que vous avez comme l'image ci-dessous nous pouvons de nouveau passer au montage.
Le montage :
Etape 3 :
Fixer le shield à la base du LittleBot avec 2 vis.
Etape 4 :
Mettre les palonniers dans les roues.
Puis fixer les palonniers sur les servomoteurs.
Etape 5 :
Mettre la batterie comme sur l'image ci-dessous et ne pas oublier de passer le câble dans le trou de la tête.
Placer le capteur ultrasons dans le tête du LittleBot
Et maintenant placer la tête du LittleBot
Tout est bon pour cette partie, félicitation pour le montage et le câblage du LittleBot!!!
Passons maintenant à la programmation sur la prochaine page.
Programmation du LittleBot
Le Programme en Mblock :
Objectifs :
Le robot doit tout le temps avancer sauf si il rencontre un obstacle à moins de 10 cm il doit reculer puis tourner vers la gauche.
Tout d'abord commençons par ajouter les extensions que nous auront besoin, dans la barre des extensions taper "ultrasons" et ajouter l'extension (il y en aura que une) et pour la 2ème extensions la voici servo.mext.
Dès que les 2 extensions sont installées on peut commencer à programmer.
Dans un premier temps nous allons faire la condition "si il voit un obstacle à moins de 10 cm".
Mettre le bloc d'évènement pour pouvoir jouer le code.
Ensuite mettre le bloc "pour toujours" pour faire une boucle infinie.
Mettre le bloc de conditions "si ... alors ...".
Maintenant on va réaliser la condition.
Ne pas oublier d'initialiser notre capteur de distance et de calculer la distance en continue.
Maintenant si la condition est correct alors il doit d'abord reculer pendants 2 secondes puis tourner à gauche pendant 2 sec.
Les valeurs 100 et -100 sont les vitesse maximale dans un sens différents, c'est tout à fait normal que le valeurs sont égales à ces nombres car les servomoteurs pas fixés dans le même sens.
Il manque juste que si la conditions n'est pas réalisé les servomoteurs avance tout le temps.
Programmation sur Arduino IDE :
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 servos :
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);
}
}
Club Robotique Cycle 2 - Station de mesure (T°, H)
Phase 1 - Assemblage des Composants et Introduction à la Modélisation 3D
Phase 1 - Conception
Compétences techniques:
- Assembler des composants électroniques et utiliser un logiciel de modélisation 3D.
- Modéliser une boîte adaptée pour contenir les composants.
- Travailler en groupe et présenter les solutions conçues.
Savoir-être, compétences transversales:
-
Travail individuel et collectif.
-
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:
-
Présentation de l'activité du jour ( Présentation de l'Arduino et des composants utilisé durant la séance : https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-que-larduino ).
-
Importance de la modélisation 3D dans le projet.
- Objectifs rappelés.
-
- Assemblage des Composants:
Fonctionnement du DHT22:
Le capteur DHT22 est un dispositif utilisé pour mesurer la température et l'humidité de l'air. Il fonctionne grâce à deux composants principaux : un thermistor pour la mesure de la température et un capteur capacitif pour l'humidité.
-
Température : Le thermistor, qui change de résistance en fonction de la température, permet de mesurer celle-ci avec une précision d'environ ±0.5°C dans une plage de -40°C à 80°C.
-
Humidité : Le capteur capacitif d'humidité détecte les variations dans la capacité électrique causées par l'humidité dans l'air, offrant une précision d'environ ±2 à 5% pour une humidité relative comprise entre 0% et 100%.
Le DHT22 communique les données via une seule broche numérique (data). Après une courte initialisation, il envoie les informations sous forme de bits, codées dans un protocole spécifique. L'appareil peut être interrogé à des intervalles d'environ 2 secondes, car il a une période de rafraîchissement des données assez lente.
Ce capteur est populaire pour sa simplicité d'utilisation, notamment avec des microcontrôleurs comme Arduino ou Raspberry Pi, et est très utilisé dans des projets de domotique ou de surveillance de l'environnement.
-
- Distribution des Composants : Fournir les cartes Arduino Nano, Shields, capteurs DHT22, et piles accus à chaque groupe.
- Essai en Autonomie : Les élèves assemblent les composants selon les instructions. L'enseignant aide si nécessaire.
- Explication de l'Assemblage : Montrer les différentes broches du capteur DHT22, comment le connecter au Shield et comment alimenter le système avec la pile accu.
- Prendre en main le logiciel TinkerCad:
- Présentation de l'Outil de Modélisation : Introduction rapide à un logiciel de modélisation 3D comme Tinkercad.
- Démonstration : Montrer comment créer une forme de base pour la boîte et ajouter des ouvertures pour les composants.
- Exercice Pratique : Les élèves réalisent un exercice simple pour se familiariser avec les outils de modélisation ( ici faire le tuto : https://innovation.iha.unistra.fr/books/2-fablab-activites-logiciels/page/initiation-3d-tinkercad ).
- La conception du fichier :
-
- Création du Boîtier Principal:
-
Ouvrir TinkerCad et démarrer un nouveau projet.
-
Placer un cube de base de 10*10*5 cm depuis la bibliothèque d'objets.
-
Ajouter un deuxième cube de 9.8*9.8*4.8 cm (Ne pas oublier à le convertir en perçage!).
- Venir centrer le 2ème cube au premier en sélectionnant les 2 cubes puis appuyez sur ce bouton
- Et ensuite appuyer sur ces 3 points noir.
-
Venir percer le deuxième cube au premier (Bien sélectionner les 2 cubes en même temps).
-
Création du Passage pour le Capteur:
- Créer un cube de 2*2*1.5 cm.
- Puis venir percer une paroi latéral de la boîte avec l'outil utiliser comme précédemment.
-
- Placer le trou à l'emplacement souhaité pour le passage du capteur.
Conception du Capot:
- Créer un nouveau cube de 9.8*9.8*0.3 cm.
- Ajouter un deuxième cube de 9.6*9.6*0.3 cm en mode perçage et venir percer ce dernier au premier grâce à l’outil "perçage".
- Puis ensuite ajouter un cube en dessous de 10*10*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.
1.Exportation de la boite :
- Pour exporter un fichier de Tinkercad il suffit de cliquer sur ce bouton
puis sur celui la
et le voilà qu'il se retrouve dans vos téléchargement.
2.Préparation du fichier pour l'impression :
- Dans un premier temps lancez le logiciel "Ultimaker Cura".
- Cherchez votre fichier dans votre explorateur et faite le glisser dans Cura.
- Par la suite configurez les paramètres d'impression :
- Ajustements éventuels des paramètres pour optimiser l'impression.
- Pour la génération du code G pour l'imprimante 3D appuyez sur ce bouton
- Maintenant vous avez plus qu'a transférer ce fichier sur la carte SD de l'imprimante utilisée et lancer 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 - Programmation
Phase 3 - Programmation de la station
Objectifs
Compétences techniques:
- 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 la programmation.
- Importance de la programmation dans le projet de station météo.
-
Programmation:
- Commençons par la programmation sur Mblock.
- N'oubliez pas d'installer l'extension pour le capteur en cliquant sur ce bouton
,puis taper dans la barre de recherche "DHT22" et ensuite juste besoin de l'ajouter.
-
-
Avant de téléverser le code n'oubliez pas de décocher ces 2 cases ci-dessous qui se situe dans le moniteur série.
-
- Pour la suite nous allons passer sur le logiciel "Arduino IDE" car il nous offre plus de possibilités.
- Dans un premier temps 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
#include <SoftwareSerial.h>
#include <DHT.h>
#include <EEPROM.h>
#define DHTPIN 9
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
const int EEPROM_SIZE = 512; // Taille de l'EEPROM en octets
const int ENTRY_SIZE = sizeof(float) * 2; // Taille d'une entrée (température + humidité)
const int NUM_ENTRIES = EEPROM_SIZE / ENTRY_SIZE; // Nombre total d'entrées possibles
int currentAddress = 0; // Adresse actuelle pour stocker
bool storageFull = false; // Indique si l'EEPROM est pleine
unsigned long previousMillis = 0; // Dernier temps de stockage
const unsigned long interval = 3600000; // Intervalle d'une heure (en millisecondes)
void setup() {
Serial.begin(9600);
dht.begin();
Serial.println("Démarrage du système...");
}
void loop() {
unsigned long currentMillis = millis();
// Vérifie si une heure s'est écoulée
if (!storageFull && currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
// Lecture des données du capteur
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();
if (!isnan(temperature) && !isnan(humidity)) {
// Vérifie si suffisamment d'espace reste dans l'EEPROM
if (currentAddress + ENTRY_SIZE <= EEPROM_SIZE) {
// Stocker la température
EEPROM.put(currentAddress, temperature);
currentAddress += sizeof(float);
// Stocker l'humidité
EEPROM.put(currentAddress, humidity);
currentAddress += sizeof(float);
// Affichage des données
Serial.print("Données stockées à l'adresse ");
Serial.print(currentAddress - ENTRY_SIZE);
Serial.print(": Température = ");
Serial.print(temperature);
Serial.print(" °C, Humidité = ");
Serial.println(humidity);
} else {
storageFull = true; // Indiquer que l'EEPROM est pleine
Serial.println("EEPROM pleine. Arrêt du stockage.");
}
} else {
Serial.println("Erreur de lecture du capteur DHT22.");
}
}
}
-
- Ce code va nous permettre de stocker la température et l'humidité dans la mémoire de notre Arduino nano et ca toute les heures.
- après avoir stocker les température et l'humidité il faut les récupérer, voici le code :
#include <EEPROM.h> const int EEPROM_SIZE = 512; // Taille totale de l'EEPROM en octets const int ENTRY_SIZE = sizeof(float) * 2; // Taille d'une entrée (température + humidité) const int NUM_ENTRIES = EEPROM_SIZE / ENTRY_SIZE; // Nombre total d'entrées (température + humidité) void setup() { Serial.begin(9600); Serial.println("Lecture des données stockées dans l'EEPROM..."); for (int i = 0; i < NUM_ENTRIES; i++) { int address = i * ENTRY_SIZE; // Lecture des données de l'EEPROM float storedTemperature, storedHumidity; EEPROM.get(address, storedTemperature); EEPROM.get(address + sizeof(float), storedHumidity); // Vérification et affichage des données Serial.print("Entrée "); Serial.print(i + 1); Serial.print(" à l'adresse "); Serial.print(address); Serial.print(": "); if (!isnan(storedTemperature) && !isnan(storedHumidity)) { Serial.print("Température = "); Serial.print(storedTemperature); Serial.print(" °C, Humidité = "); Serial.print(storedHumidity); Serial.println(" %"); } else { Serial.println("Valeurs non valides ou non initialisées."); } } } void loop() { // Pas besoin de code dans loop pour cette démonstration }
3. Validation:
-
- Vérification du programme pour s'assurer du bon fonctionnement.
- Test du stockage des valeurs dans la mémoire EEPROM.
4. 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"
Phase 4 - Mesure et Analyse des Données de Température avec le Capteur DHT22
Phase 4 - Mesure et Analyse des Données de Température avec le Capteur DHT22
Objectifs de la séance :
- Apprendre à utiliser des stations de mesure de température équipées de capteurs DHT22 et d’une carte Arduino Nano.
- Collecter des données de température à différents endroits sur une période donnée.
- Analyser les données recueillies grâce à Excel et réaliser des courbes de tendance.
- Comprendre l’impact des conditions environnementales sur la température.
Compétences techniques :
- Utilisation de capteurs et d’Arduino Nano : Installation, branchement et paramétrage des stations de mesure.
- Manipulation de données avec Excel : Importer des fichiers de données, organiser les informations en tableaux, tracer des graphiques (courbes de tendance, histogrammes, etc.).
- Traitement des données : Analyser les écarts de température selon les endroits et périodes de mesure.
Savoir-être :
- Rigueur : Suivre les étapes de mesure et d'analyse de façon précise et méthodique.
- Travail en équipe : Collaborer pour installer les stations, récolter les données et partager les résultats.
- Autonomie : Être capable d’installer la station de mesure et d’effectuer des relevés de manière indépendante.
Compétences transversales :
- Résolution de problèmes : Interpréter les anomalies ou incohérences dans les données et adapter les mesures.
- Communication scientifique : Présenter de manière claire et synthétique les résultats sous forme de graphiques et de conclusions.
- Esprit critique : Analyser les données avec discernement pour en tirer des conclusions pertinentes.
Déroulement de la séance :
-
Introduction
- Présentation des objectifs de la séance.
- Rappel du fonctionnement du capteur DHT22 et de l'Arduino Nano.
- Explication des points de mesure : définir les différents endroits où seront placées les stations (intérieur, extérieur, pièces fermées, etc.).
-
Installation des stations de mesure
- Mise en place des stations avec le capteur DHT22 à différents endroits prédéfinis.
- Vérification de la connectivité et du bon fonctionnement de chaque station.
- Lancement de la collecte des données (durée de mesure à définir : quelques heures ou une journée complète).
-
Collecte des données
- Chaque participant vérifie régulièrement les stations et enregistre les données (extraction via l’Arduino).
- Récupération des température via l'Arduino IDE, puis exportation sur Excel ou Open Office.
- Pour récupérer les température facilement il y a cette formule =DROITE(GAUCHE(A1; NBCAR(A1)-23); 5).
- Pour récupérer la valeur de l'humidité vous pouvez utiliser cette formule =DROITE(GAUCHE(A1; NBCAR(A1)-2); 5) si vous avez collez votre texte dans la case A1, ensuite si vous êtes sur Exel n'oubliez pas de les convertir en valeurs.
- Attention si vous êtes sur Libre Office, il faut copier vos valeur puis les coller en "collage spécial" et ensuite sur "Texte non formaté".
Et ensuite appuyer sur "OK". - Faire de même pour les valeurs de l'humidité.
-
Analyse des données sur Excel
- Importation des données dans Excel ou Libre Office.
- Structuration des informations sous forme de tableau.
- Création des graphiques : courbes de tendance pour visualiser les écarts de température selon les points de mesure.
-
Pour créer un graphique sur Excel sélectionnez votre tableau et allez dans "Insertion" puis "Graphiques Recommandés".
-
Sur Libre Office sélectionnez vos valeurs puis allez dans "Insertion", "Diagrammes", "Ligne", et prenez le 2ème.
- Après avoir obtenue l'image ci-dessus, faites un clic droit sur le graphique et ensuite dans "plage de données" allez dans "séries de données".
- Et vous avez juste à supprimer les données des heures.
- Sur Excel n'oubliez pas de changer l'échelle des température en mettant la température la plus basse à 0.
- Analyse des résultats : interpréter les différences entre les différents points de mesure.
- Faire la même chose pour l'humidité.
-
Conclusion et échanges
- Chaque participant présente ses résultats sous forme de graphiques.
- Discussion autour des facteurs qui peuvent influencer les écarts de température (environnement, exposition au soleil, ventilation, etc.).
- Synthèse des principaux apprentissages de la séance.
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);
}
Club Robotique Cycle 4 - Bras Robotique
Phase - 1
Phase 2 - Assemblage des pièces
Phase 1 - Assemblage des pièces
Objectifs pédagogiques
- Découverte de la mécanique et de la robotique : Initier les élèves à la construction d’un système mécanique articulé.
- Travail en équipe : Encourager la collaboration entre les élèves pour atteindre un objectif commun en temps limité.
- Précision et méthode : Apprendre à assembler un objet technique en suivant des étapes précises, avec soin et rigueur.
- Pratique des compétences manuelles et techniques : Familiariser les élèves avec l’utilisation d’outils de montage et la lecture d’un schéma d’assemblage.
Compétences techniques visées
- Assemblage mécanique : Être capable d'assembler les pièces du bras robot (structure, axes, moteurs, etc.) de manière précise et dans un ordre logique.
- Utilisation d’outils : Apprendre à manier correctement les outils nécessaires (tournevis, clé Allen, etc.).
- Lecture d’un schéma technique : Savoir interpréter un plan d'assemblage et identifier les différentes pièces et leur emplacement.
- Montage des éléments motorisés : Installer correctement les moteurs et éléments mécaniques du bras robot.
Savoir être (compétences comportementales)
- Travail en équipe : Répartir les tâches de manière équitable et efficace au sein du groupe.
- Rigueur et précision : Être attentif aux détails lors de l’assemblage pour éviter les erreurs.
- Gestion du temps : Apprendre à respecter le temps imparti pour finaliser le projet.
- Adaptabilité : Savoir réagir en cas de difficulté ou de problème technique, et adapter sa méthode de travail.
Compétences transversales
- Collaboration et communication : Travailler efficacement en groupe, en partageant les responsabilités et en communiquant clairement.
- Organisation : Organiser les étapes de l'assemblage de manière logique et structurée.
- Résolution de problèmes : Trouver des solutions rapidement en cas de dysfonctionnements ou de blocages lors de l'assemblage.
- Apprentissage pratique : Développer des compétences en manipulant des objets techniques et en résolvant des problèmes concrets.
Montage du bras robotique :
FICHE DE RÉFÉRENCE RAPIDE DES PARTIES STRUCTURELLES :
- 12 pièces - Écrou M3
- 32 pièce - Vis M3 x 12
- 4 pièces - Vis M3 x 20
Montage de la Base :
Matériel nécessaire :
Etape 1 :
Fixez d'abord un palonnier double face à l'aide des petites vis fournies avec les servomoteurs.
Faites attention à l'orientation des pièces. Notez la petite flèche gravée sur la pièce, qui pointe vers l'avant du bras. Positionnez le palonnier comme indiqué, puis retournez les deux pièces et fixez les deux petites vis.
Positionnez toujours les vis à mi-distance ou plus loin du moyeu central du palonnier. Cela permet d'éviter une éventuelle interférence entre les têtes des vis et certains boîtiers de servomoteurs.
Etape 2 :
SI LES ENCOCHES NE S'ALIGNENT PAS
VÉRIFIEZ BIEN QUE LA PIÈCE EST ORIENTÉE COMME INDIQUÉ.
NE FIXEZ PAS ENCORE LES ÉCROUS ET LES BOULONS.
Etape 3 :
INSTALLEZ LA BARRE CENTRALE COMME INDIQUÉ.
AVEC LE DERNIER CÔTÉ INSTALLÉ, IL NE RESTE PLUS QU'À FIXER LES BOULONS ET LES ÉCROUS.
Pour le coté Gauche :
Placez le cercle du palonnier dans le trou correspondant du servomoteur.
Retournez les deux pièces et fixez à nouveau la vis du palonnier vers l'extrémité la plus éloignée afin d'éviter d'éventuels problèmes de dégagement avec le boîtier du servomoteur.
Pour la suite quelques petite précisions, il faut bien faire la différence entre l'avant du servomoteur et l'arrière.
Pour fixer le palonnier sur le servomoteur il faut d'abord donner ce code via l'Arduino nano pour connaître sa position 0.
Arrivé à la position 0 mettez le palonnier à l'horizontal vers l'avant du servomoteur.
Coté droit :
Matériel :
Pour le servomoteur du coté droit, dans un premier temps le mettre à la position 0, puis placer le palonnier à l'horizontal vers l'arrière.
ASSEMBLAGE DU SERVOMOTEUR DU CÔTÉ DROIT AVEC LA BASE :
Matériel de l'assemblage de la poutre du lien supérieur :
Fixez la renfort de la poutre du lien supérieur comme indiqué ci dessous :
L'assemblage principal du bras est maintenant terminé et prêt à recevoir l'assemblage de la pince.
Assemblage du servomoteur de la pince :
Matériel nécessaire :
Assemblage du reste de la pince :
Matériel nécessaire :
Mettre le servomoteur de la pince à la position 0 et mettre le palonnier à l'horizontal vers l'arrière.
Montage de la pince sur le bras :
Fixer la pince au lien supérieur gauche du bras avec une vis de 3 mm x 10 mm. ne pas trop serrer, car les vis pourraient comprimer le boîtier du moteur servo, ce qui entraînerait le blocage du train d'engrenages.
Fixer le lien parallèle à la pince avec un écrou et une vis de 3 mm x 10 mm. Ajuster le serrage pour permettre un mouvement libre.
assemblage de la base et du roulement :
Quand vous fixer le servomoteur mettez le à la position 90 puis vous avez juste à mettre votre bras robotique vers l'arrière à l'inverse de la dernière image.
Vous pouvez rajouter les extensions de la pince avec les pièces 31 et 32 comme ci-dessus.
Et voilà le montage de votre bras robotique est fini!!!
Source : Armuno A1Hd -V0.5-Assembly-7-22-2015-copy
Phase 3 - Programmation du bras robotique
Cinématique d'un bras robot
La cinématique est un domaine de la mécanique qui se concentre sur l’étude des mouvements. Ça tombe bien, le but d'un robot étant de bouger ! L'étude cinématique consiste donc à déterminer les positions, vitesses et accélérations des différentes parties d’un robot, sans prendre en compte les forces qui causent ces mouvements (puissance des moteurs par exemple). Un robot, souvent décrit comme une machine automatisée, peut effectuer des tâches complexes apportant une réelle valeur ajoutée dans divers secteurs.
Notre robot a 4 moteurs, l'objectif est de les actionner pour :
- Fermer la pince pour saisir un objet
- Déplacer la pince pour déplacer l'objet
- Ouvrir la pince pour lâcher l'objet
Les 4 moteurs contrôlent 4 mouvements possibles :
- Moteur 1 : Base
- Moteur 2 : Coude
- Moteur 3 : Épaule
- Moteur 4 : Pince
https://www.youtube.com/watch?v=xQkPjDEbFoU
Attention chaque Servomoteur possède des positions maximums et minimums à bien respecter pour pas que ce dernier ne fonctionne plus.
Voici un tableau qui regroupe ces valeurs si vous l'avez monter comme dans la phase 1 :
Pour ouvrir et fermer la pince c'est donc facile, on actionne le moteur 4.
Espace Cartésien : les mouvements de la pince et des objets
Espace articulaire : les mouvements des moteurs
La question principale qu'on se pose c'est comment actionner mes moteurs pour faire bouger ma pince comme je veux ? C'est le modèle cinématique inverse.
On peut aussi se demander : si je bouge mes moteurs à telle position, quelle sera la position de ma pince ? C'est le modèle cinématique direct.
Voici un code mblock qui permet de prendre un objet à une où le coude est à la position 140 et l'épaule à la position 150.
Epaule : Pin 6
Coude : Pin 9
Base : Pin 3
Pince : Pin 13
Partie 1 :
Partie 2 :
Code traduit en Arduino
#include <Servo.h>
Servo monServo1;
Servo monServo2; // Création de l'objet Servo
Servo monServo3;
Servo monServo4;
void setup() {
monServo1.attach(3);
monServo2.attach(6);
monServo3.attach(9);
monServo4.attach(13); // Attache le servomoteur à la broche définie
monServo1.write(0);
monServo2.write(90);
monServo3.write(180);
monServo4.write(90);
}
void loop() {
delay(1000);
// Balayage de 0° à 180°
for (int angle =0; angle <= 90; angle++) {
monServo1.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =180; angle >= 140; angle--) {
monServo3.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =90; angle <= 150; angle++) {
monServo2.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =90; angle <= 150; angle++) {
monServo4.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =150; angle >= 90; angle--) {
monServo2.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =140; angle <= 180; angle++) {
monServo3.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =90; angle >= 0; angle--) {
monServo1.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =180; angle >= 140; angle--) {
monServo3.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =90; angle <= 150; angle++) {
monServo2.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =150; angle >= 90; angle--) {
monServo4.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =90; angle <= 150; angle++) {
monServo4.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =150; angle >= 90; angle--) {
monServo2.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
for (int angle =140; angle <= 180; angle++) {
monServo3.write(angle); // Déplace le servo à l'angle spécifié
delay(10); // Pause pour que le servo ait le temps de bouger
}
delay(1000);
}
Sources
Cinématique des robots série :
https://howtomechatronics.com/tutorials/arduino/diy-arduino-robot-arm-with-smartphone-control/
https://learn.ros4.pro/fr/theory/
https://files.ros4.pro/theorie.pdf
https://www.youtube.com/watch?v=vKD20BTkXhk
Robot série à parallélogramme :
https://www.youtube.com/watch?v=GnrRk9mWv7A
https://www.youtube.com/watch?v=xQkPjDEbFoU
https://www.youtube.com/watch?v=Z7HWoh_MR1s
https://drive.google.com/drive/folders/1zaOw2QcZatylyqQoVnYhIK7iysyCOY2d
https://www.youtube.com/watch?v=Q9JOKQaIR1w
Un peu complexe :
Club Robotique Cycle 5 - Poubelle Connectée
Phase 1 - Théorie et fonctionnement des composants
Phase 1 - Théorie et fonctionnement des composants
Objectifs pédagogiques :
- Comprendre le fonctionnement de l’Arduino Nano et son Shield.
- Découvrir le rôle d’un capteur à ultrasons (HC-SR04).
- Apprendre comment fonctionne un servomoteur et comment le contrôler.
- Apprendre à câbler ces composants ensemble correctement pour un projet Arduino.
Matériel nécessaire :
- 1 x Arduino Nano
- 1 x Shield pour Arduino Nano (ou une breadboard pour faciliter les connexions)
- 1 x Capteur à ultrasons HC-SR04
- 1 x Servomoteur SG90
- Fils de connexion
- 1 x Câble USB pour programmer l’Arduino Nano
- 1 x Ordinateur avec l’IDE Arduino installé
1. Introduction à l'Arduino Nano
Qu'est-ce que l'Arduino ?
https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-que-larduino
2. Capteur à ultrasons HC-SR04
Comment fonctionne le capteur à ultrasons ?
https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-quun-capteur-a-ultrasons
3. Fonctionnement du servomoteur SG90
Comment fonctionne un servomoteur ?
https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-quun-servo-moteur
Explication du câblage complet
Maintenant que nous avons vu chaque composant individuellement, voici un résumé du câblage complet :
-
Capteur à ultrasons (HC-SR04) :
- VCC → 5V de l’Arduino
- GND → GND de l’Arduino
- TRIG → D9 de l’Arduino
- ECHO → D10 de l’Arduino
-
Servomoteur :
- VCC (fil rouge) → 5V de l’Arduino
- GND (fil noir) → GND de l’Arduino
- Signal (fil jaune) → D12 de l’Arduino
Conclusion et exercices pratiques
Synthèse :
- Nous avons vu comment l’Arduino Nano fonctionne avec un shield pour faciliter les connexions.
- Nous avons compris comment le capteur à ultrasons mesure des distances et comment nous allons utiliser ces informations pour contrôler un servomoteur.
- Le servomoteur répond à des signaux PWM pour se déplacer selon des angles précis.
Exercice pratique :
Pour terminer la séance, les participants peuvent reproduire le câblage décrit ci-dessus sur leur propre montage.
Correction de L'exercice :
Code à utiliser : Le code sera introduit dans la prochaine séance, mais vous pouvez donner un aperçu du fonctionnement et les amener à réfléchir sur la façon dont les composants vont interagir ensemble.
Phase 2 - Utilisation des composants et programmation de la poubelle connectée
Phase 2 - Utilisation des composants et programmation de la poubelle connectée :
Objectifs pédagogiques :
- Apprendre à utiliser le capteur à ultrasons (HC-SR04) pour mesurer des distances.
- Apprendre à contrôler le servomoteur en fonction des signaux PWM.
- Assembler les deux composants pour que le servomoteur se déplace lorsque la distance mesurée est inférieure à 5 cm.
- Comprendre l'interaction entre les capteurs et les actionneurs dans un projet Arduino.
Matériel nécessaire :
- 1 x Arduino Nano
- 1 x Shield pour Arduino Nano ou une breadboard
- 1 x Capteur à ultrasons HC-SR04
- 1 x Servomoteur SG90
- Fils de connexion
- 1 x Câble USB pour programmer l’Arduino
- 1 x Ordinateur avec l’IDE Arduino installé
1. Utilisation du capteur à ultrasons HC-SR04
Objectif :
Les élèves vont apprendre à écrire un programme qui utilise le capteur à ultrasons pour mesurer la distance.
Instructions :
-
Câblage :
- Suivez le câblage décrit dans la première séance :
- VCC → 5V de l’Arduino
- GND → GND de l’Arduino
- TRIG → D9 de l’Arduino
- ECHO → D10 de l’Arduino
- Suivez le câblage décrit dans la première séance :
-
Écriture du code : Demandez aux élèves d'écrire ou de copier le code suivant dans l’IDE Arduino :
// Déclaration des pins du capteur à ultrasons const int trigPin = 9; const int echoPin = 10; void setup() { Serial.begin(9600); // Initialiser la communication série pinMode(trigPin, OUTPUT); // Définir le trigPin comme une sortie pinMode(echoPin, INPUT); // Définir l'echoPin comme une entrée } void loop() { // Envoi d'un signal digitalWrite(trigPin, LOW); delayMicroseconds(2); digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); // Lecture de la durée du signal de retour long duration = pulseIn(echoPin, HIGH); int distance = duration * 0.034 / 2; // Calcul de la distance // Afficher la distance dans le moniteur série Serial.print("Distance: "); Serial.print(distance); Serial.println(" cm"); delay(500); // Attendre un peu avant la prochaine mesure }
-
Tester le code :
- Demandez aux élèves de télécharger le code sur leur Arduino.
- Ouvrir le moniteur série (dans l'IDE Arduino) pour voir les distances mesurées.
2. Utilisation du servomoteur SG90
Objectif :
Les élèves vont apprendre à contrôler le servomoteur en utilisant des signaux PWM.
Instructions :
-
Câblage :
- Câblez le servomoteur selon le schéma précédent :
- Rouge (VCC) → 5V de l’Arduino
- Noir (GND) → GND de l’Arduino
- Jaune (Signal) → D6 de l’Arduino
- Câblez le servomoteur selon le schéma précédent :
-
Écriture du code : Demandez aux élèves d'écrire ou de copier le code suivant dans l’IDE Arduino :
#include <Servo.h> // Inclure la bibliothèque Servo Servo myServo; // Créer un objet Servo void setup() { myServo.attach(6); // Attacher le servomoteur à la pin D6 myServo.write(0); // Position initiale à 0 degrés } void loop() { // Faire tourner le servomoteur à 90 degrés myServo.write(90); delay(1000); // Attendre 1 seconde myServo.write(0); // Retourner à 0 degrés delay(1000); // Attendre 1 seconde }
-
Tester le code :
- Demandez aux élèves de télécharger le code sur leur Arduino.
- Observez le mouvement du servomoteur, qui devrait osciller entre 0 et 90 degrés.
3. Assemblage du capteur à ultrasons et du servomoteur
Objectif :
Les élèves vont assembler les deux composants pour que le servomoteur se déplace lorsque la distance mesurée est inférieure à 5 cm.
Câblage :
Utiliser les connexions précédemment définies. Les deux composants doivent être câblés en parallèle à l'Arduino. Voici un résumé :
- Capteur à ultrasons :
- VCC → 5V de l’Arduino
- GND → GND de l’Arduino
- TRIG → D9 de l’Arduino
- ECHO → D10 de l’Arduino
- Servomoteur :
- VCC (fil rouge) → 5V de l’Arduino
- GND (fil noir) → GND de l’Arduino
- Signal (fil jaune) → D6 de l’Arduino
Écriture du code final :
Demandez aux élèves d'écrire ou de copier le code suivant, qui intègre le capteur et le servomoteur :
#include <Servo.h> // Inclure la bibliothèque Servo
// Déclaration des pins
const int trigPin = 9;
const int echoPin = 10;
Servo myServo;
void setup() {
Serial.begin(9600); // Initialiser la communication série
pinMode(trigPin, OUTPUT); // Définir le trigPin comme sortie
pinMode(echoPin, INPUT); // Définir l'echoPin comme entrée
myServo.attach(6); // Attacher le servomoteur à la pin D6
myServo.write(0); // Position initiale à 0 degrés
}
void loop() {
// Envoyer un signal
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Lire la durée du signal de retour
long duration = pulseIn(echoPin, HIGH);
int distance = duration * 0.034 / 2; // Calculer la distance
// Afficher la distance dans le moniteur série
Serial.print("Distance: ");
Serial.print(distance);
Serial.println(" cm");
// Si la distance est inférieure à 5 cm, déplacer le servomoteur
if (distance < 5) {
myServo.write(140); // Positionner le servomoteur à 180 degrés
delay(1000); // Attendre 1 seconde
myServo.write(0); // Retourner à 0 degrés
}
delay(500); // Attendre un peu avant la prochaine mesure
}
4. Tester le projet
Instructions :
- Demandez aux élèves de télécharger le code final sur leur Arduino.
- Placez un objet à moins de 5 cm du capteur à ultrasons.
- Observez le servomoteur se déplacer à 180 degrés pendant 1 seconde, puis revenir à sa position initiale.
5. Conclusion et discussion
Synthèse :
- Les élèves ont appris à utiliser le capteur à ultrasons pour mesurer des distances.
- Ils ont contrôlé un servomoteur en fonction des signaux PWM.
- Ils ont assemblé les deux composants pour créer un projet fonctionnel où le servomoteur se déplace en réponse à la détection d’un objet à moins de 5 cm.
Questions de réflexion :
- Comment pourrait-on améliorer ce projet ? (ex. : ajouter une LED qui s'allume lorsque l'objet est détecté)
- Quelles autres applications pourraient utiliser un capteur à ultrasons et un servomoteur ensemble ?
Projet similaire
https://www.hackster.io/FANUEL_CONRAD/automatic-soap-dispenser-75abd6
Club Robotique Cycle 6 - Plieur de Linge
Phase 1 - Conception du fichier 2D avec Inkscape
Phase 1 - Conception 2D avec Inkscape
Compétences techniques :
-
Utiliser Inkscape pour créer des fichiers vectoriels destinés à la découpe laser.
-
Concevoir un fichier adaptée à un projet spécifique.
-
Travailler en groupe et présenter les solutions conçues.
Savoir-être, compétences transversales :
-
Travail individuel et collectif.
-
Lire et suivre un tutoriel détaillé.
Déroulement de la séance :
Consignes: Sécurité, précautions matériel :
-
Travail individuel.
-
Rappel: Respecter les consignes de sécurité liées à la découpe laser.
Phases et méthodes d’animation :
-
Présentation de l'activité du jour (Introduction à Inkscape et explication des fichiers vectoriels pour la découpe laser).
-
Importance de la modélisation 2D dans le projet.
-
Objectifs rappelés.
Prise en main du logiciel Inkscape :
Présentation de l’Outil de Modélisation :
-
Introduction rapide à Inkscape, un logiciel de dessin vectoriel.
-
Explication des principes de base : chemins, objets, calques et opérations booléennes.
Démonstration :
-
Comment créer des formes de base (rectangles, cercles, polygones).
-
Comment modifier les dimensions et les alignements.
-
Utilisation de l'outil "Aligner et distribuer" pour organiser les objets.
-
Paramétrage des contours pour la découpe (ligne rouge 0,01 mm) et pour la gravure (ligne noire ou remplissage).
Création du premier fichier de découpe :
Création des volets du plieur de linge :
-
Ouvrir Inkscape et créer un nouveau document.
-
Définir la taille de la page en fonction du matériau utilisé ( ici une plaque de 600 mm x 300 mm).
-
Utiliser l’outil rectangle pour créer le volet du plieur (370 mm x 150 mm).
- Aller dans "Fond et Contour" et enlever le fond, mettre le contour en rouge d'une épaisseur de 0,260 mm.
-
Ajouter un deuxième rectangle plus petit pour créer un contour extérieur (140 mm x 60 mm), puis utiliser la fonction "Union".
Ajout des encoches et trous pour les Servomoteurs :
- Pour les encoches créer un rectangle de dimensions ( 3 mm x 10 mm ).
-
Ensuite la dupliquer ( CTRL D ) et la déplacer avec les flèches du clavier.
- Résultat :
Création des cales des volets :
- Créer un rectangle de 12 mm x 100 mm.
- Le placer comme ceci :
- Dupliquer les encoches et ensuite sélectionner le rectangle avec.
- Plus qu'à utiliser l'outil "Union".
- Pour surélever la cale on vient créer un autre rectangle de 16 mm x 35 mm et le placer comme l'image.
- Et pour le final utiliser l'outil "Union sur les 2 formes.
Puis y placer un cercle de 2,9 mm x 2,9 mm.
Création des boites pour surélever les servomoteurs :
- Aller sur boxes.py pour créer une "Basedbox" de 35 mm x 35 mm x 15 mm.
- Ajouter cette boite au fichier et rajouter des trous de 2,9 mm sur la face du dessus.
- Dupliquer la boite 3 fois pour en avoir 4 au total.
Création du deuxième fichier de découpe :
- Faire un copier-coller du 1er volet sur le 1er fichier de découpe.
Création de la partie du milieu :
- Créer un rectangle de 225 mm x 300 mm sans oublier d'enlever le fond et de mettre les contours en rouge.
- Créer un rectangle de 40 mm x 50 mm.
- Placer le rand rectangle en x = 0 et Y = 0 et le petit rectangle en x = 0 et y = 150.
- Sélectionner les 2 rectangle et réaliser une différence.
- Pour les encoches du milieu, pointés ci-dessous faire comme pour les cales des volets ci-dessus.
- Pour les encoches de cotés faire un carré de 30 mm x 250 mm et le placer à coté des encoches.
- Dupliquer les encoches et faire une union.
- Résultat :
Création du troisième fichier de découpe :
- Créer 2 rectangles de dimensions 370 mm x 150 mm, qui vont permettre à rallonger les volets du plieur.
Ajustements Finaux :
-
Vérifier l’alignement et les dimensions de chaque pièce.
-
Vérifier que les contours sont aux bonnes dimensions pour la machine (ici 0,260 mm).
Validation et Export :
-
Vérifier visuellement la modélisation en 2D.
-
Exporter le fichier au format SVG ou DXF pour la découpe laser.
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.
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
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(x, y, "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).
- ATTENTION si vous êtes sur open office cliquer sur le graphique jusqu'à ce que vous ayez ces 8 points verts, puis faites un clic droit.
-
Cliquez sur "plage de données" et remplacer chacun des deux "C" par un "B" .
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.
- ATTENTION si vous êtes sur open office cliquer sur le graphique jusqu'à ce que vous ayez ces 4 points verts, puis faites un clic droit.
- Cliquez sur "Insérer des étiquettes de données".
-
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é".
- ATTENTION si vous êtes sur open office cliquer sur le graphique jusqu'à ce que vous ayez ces 8 points verts, puis faites un clic droit.
- Cliquez sur "Type de diagramme" et sélectionner le premier qui se nomme "Normal".
É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 :
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
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)
Club Robotique - Robot Araignée
Ressources
- Ressources de Williams https://seafile.unistra.fr/smart-link/e4252684-7103-47dc-8e07-496ef497a856/
- https://www.instructables.com/4-Legged-Spider-Robot-With-3D-Printed-Parts-8-Serv/
- https://www.instructables.com/ARDUINO-SPIDER-ROBOT-QUADRUPED/
- https://robotlk.com/how-to-make-spider-robot-12dof-sg90-servo-arduino-nano/
Sélection de ressources sur la robotique éducative
Arduino
- blog Eskimon https://eskimon.fr/tuto-arduino-602-un-moteur-qui-a-de-la-t%C3%AAte-le-servomoteur
- Lycée Blaise Pascal de Clermont-Ferrant : https://arduino.blaisepascal.fr/presentation/site-internet/ (https://si.blaisepascal.fr/uc-arduino/ )
- Cours de GEII : https://intra.iha.unistra.fr/doku.php?id=intranet_geii:cours
Pour les animateurs et la création pédagogique des clubs
Création d'extensions MBlock
Voir https://forum.makeblock.com/t/how-to-add-an-extension-for-mblock/2280
Mblock est normalement installé dans C:\ProgramData
Sur mon PC il est installé dans C:\Users\USER\mblock
(voir aussi dans C:\Users\Public\Programs
Les extensions sont installées dans : C:\Users\USER\mblock\exts
Les sources sont en JavaScript... Il faut trouver comment remonter aux sources C (fichiers .c et .h) qui appellent les librairies dont dépendent les blocs de programmation et définissent le code C équivalent à chaque bloc. A défaut, trouver si les fournisseurs de l'extensions ont mis le code source sur une forge logicielle publique.
Avec des librairies de dépendance
Pour inspiration, on importe une librairie existante :
Pour créer une nouvelle librairie :
Scroller jusqu'en bas et importer un dossier src
contenant les fichiers .h
et .cpp
de votre lib