Robotique Educative
Ateliers dans le primaire et le secondaire. Documentation de projets réalisés avec des écoles, collèges, lycées.
- Qu'est ce que CréaBot ? Le club robotique de l'IUT de Haguenau
- Année scolaire 2023-2024
- Club Robotique Cycle 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
- Phase 1 - Conception - 3 x 1H30
- Phase 2 - Câblage et programmation du LittleBot - 4 x 1h30
- Phase 3 - Assemblage et réctification - 2 x 1h30
- Fiche Séance 2 - 1H30
- Qu'est ce qu'un servo-moteur ?
- Piloter un servomoteur avec Mblock
- Fiche Séance 3 - 1H30
- Qu'est ce qu'un capteur à ultrasons ?
- Câblage et programmation du LittleBot
- Apprendre à utiliser TinkerCad (classe)
- Programme MBLOCK
- 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
- Stages de Robotique pour les collégiens - Station Mesure Eau
- Fiche résumé
- Conception technique du stage
- Conception de la formation des animateurs
- Atelier de formation des animateurs
- Ateliers de développement de la station de mesure de l'eau (5 jours)
- Matériel et Plateforme standards pour la robotique éducative
- Club Robotique - Robot Araignée
Qu'est ce que CréaBot ? Le club robotique de l'IUT de Haguenau
Voir aussi le Club Robotique CréaBot sur le site de l'IUT de Haguenau
Objectifs et compétences
Tous les mercredis après midi, en période scolaire, le club robotique CréaBot accueille des collégiens passionnés par les technologies du numérique pour explorer et développer leur intérêt pour les robots au sein du Fablab d'Alsace-Nord (FAN) de l'IUT de Haguenau .
Ce club a pour objectif d’initier un jeune public à la robotique et la programmation afin de les sensibiliser aux métiers et aux enjeux technologiques d'aujourd'hui et de demain. Il contribue au développement des apprentissages fondamentaux que sont les mathématiques, la physique, la technologie, l'informatique sous forme ludique.
Plusieurs activités sont proposées durant toute l'année autour de la conception, la fabrication, l'assemblage et la programmation de robots où différents aspects techniques seront abordés sur chaque robot tels que la mécanique, l'électronique et la programmation.
Au-delà des compétences techniques, le club de robotique favorise également le développement de compétences transversales telles que la créativité, la résolution de problèmes et le travail d’équipe. Les collégiens seront amenés à collaborer et à partager leurs idées pour atteindre un objectif commun. Notre club de robotique est un véritable espace de partage, d’apprentissage et d’expérimentation autour des STIM (science, technologie, ingénierie et mathématiques).
Encadrés par le Fab-Manager du FAN, compétent et passionné, ils apprennent à concevoir et construire des éléments mécaniques et électroniques du robot à partir de modèles ou de leur propre création.
À travers ce club, les collégiens exploitent l'informatique (programmation, comparaison de stratégies) et travaillent la démarche d'investigation : mise en situation d'autonomie, mettre en place une stratégie, réaliser des essais, valider ou invalider la méthode, comprendre d'où vient le problème et corriger en conséquence le programme.
Les collégiens découvrent les différentes fonctionnalités des capteurs, pour prendre connaissance de l'environnement, ainsi que des moteurs permettant les déplacements du robot (avancer, reculer, tourner à droite ou à gauche, suivre une trajectoire).
Différents types de robots seront fabriqués durant l'année pour assurer des opérations selon les applications et les missions à mener : robot mobile à 2 ou 4 roues, bras robotique, robot à 4 ou 6 pattes....
A qui s'adresse-t-il ?
Ce club s'adresse principalement aux collégiens de la 6ème à la 3ème.
Horaires
Les activités du club sont organisées en période scolaire sur les horaires suivants :
- 6ème-5ème : 14h-15h30
- 4ème-3ème : 16h-17h30
Pas d'activité au club pendant les vacances scolaires.
Lieu et encadrement
Fablab de l'IUT de Haguenau
30 rue du Maire André Traband
67500 Hagueanu
Encadré par le Fab-Manager du Fablab
Année scolaire 2023-2024
Planning de l'année scolaire 2023-2024
Le planning se décompose en 3 cycles de 3 mois avec un robot par cycle. Les difficultés de chaque cycle est progressif.
1er cycle : Le contenu est entièrement donné, du schéma de câblage aux instructions de construction en passant par les programmes informatique du robot.
2ème cycle : Les participants doivent réfléchir comment créer la pièce, quelle forme est optimal, le programme est pré-construit et une aide leur est proposée.
3ème cycle : Seul le "type de robot" leur est donné, ils devront réfléchir à quelle esthétique lui donner, quels capteurs utiliser, comment l'assembler et comment le programmer.
Pour chaque cycle, les participants sont amenés à travailler sur 3 domaines :
- La conception mécanique et électronique.
- La fabrication mécanique et électronique
- La programmation (Scratch, Python, langage C...)
Les 3 domaines sont abordés en parallèle, afin d'introduire les notions et techniques progressivement et de manière didactique.
1er cycle : Little Bot
Le premier cycle sera consacré à la fabrication du robot appelé LittleBot.
Pour ce cycle, nous utiliserons l'environnement Mblock de programmation informatique par bloc (Scratch) ainsi que le logiciel de dessin 3D assisté par ordinateur TinkerCAD (CAO).
Durant ce cycle, nous apprendrons à utiliser une imprimante 3D mais aussi des composants pour de l'électronique.
Nous découvrirons les principes et le fonctionnement du capteur ultrason ainsi que des servomoteurs.
Le programme, le câblage et l'assemblage est fourni pour la réalisation de ce projet.
L'objectif final de ce cycle est de faire avancer le robot, le faire tourner et de lui faire éviter des objets.
2ème cycle : Segway
Le deuxième cycle sera consacré à la fabrication d'un robot de type segway.
Pour ce robot, nous utiliserons le langage C++ (Arduino) pour le faire fonctionner ainsi que l'utilisation du logiciel Fusion360.
Durant ce cycle, nous apprendrons à utiliser plusieurs types de capteurs tel quel l'infrarouge et le gyroscopique.
Nous apprendrons comment fonctionne une télécommande et nous ferons fonctionner notre robot avec celle-ci.
Le programme, le câblage et l'assemblage vous sera donné partiellement pour ce projet.
L'objectif final de ce cycle est de comprendre la cinématique d'un "segway", garder une stabilité avec ce robot et faire avancer celui-ci.
3ème cycle : Araignée ou Traceur de découpe
Le troisième cycle sera consacré à la fabrication d'un robot de type "araignée" et/ou type "traceur de découpe".
Pour ce robot, nous utiliserons le langage C++ (Arduino) pour le faire fonctionner ainsi que l'utilisation du logiciel Fusion360.
Durant ce cycle, nous utiliserons plusieurs servomoteur ainsi qu'un capteur ultrason, un haut parleur et un micro
L'objectif final de ce cycle est de comprendre la cinématique d'un robot à 4 pattes et ses déplacement ainsi que le déplacer en utilisant uniquement le son de notre voix.
En ce qui concerne le traceur, nous le coderons en C++ et nous utiliserons fusion 360 pour l'impression 3D.
Nous utiliserons des moteurs pas à pas ainsi que des servomoteurs pour le déplacement du crayon.
L'objectif est de construire un traceur de découpe permettant de dessiner avec une image vectoriel.
Le programme, le câblage et l'assemblage vous sera pas donné pour la réalisation de ce projet. Seul le type de robot vous sera donné, à vous de le contruire de A à Z.
Club Robotique Cycle 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
- Age 10-15
- Notions de base en électricité et circuit électronique
- Notions de base en géométrie
- Des bases en Langage de programmation par bloc "scratch" est un plus
-
Logiciels :
- Programmation : MBlock (scratch) et Arduino IDE (C)
- Modélisation CAO : TinkerCAD, ONSHAPE, FreeCAD
- Préparation impression 3D (slicer) :
-
Compétences et technologies :
- Programmer une Carte microcontrôleur Arduino depuis MBlock et Arduino IDE
- Stocker dans une variable la valeur d'un Capteur de distance ultrason HC-SR04
- Piloter un Servomoteur en donnant la valeur de sa vitesse de rotation
- Télécharger le modèle 3D d'une pièce sur internet
- Modifier le modèle 3D d'une pièce avec TinkerCAD
- Préparer un fichier d'impression 3D avec ...
- Lancement d'une impression 3D sur l'imprimante ...
Description du déroulé
11 séances :
- 4 séances Conception électronique et câblage : Arduino et MBlock
- Introduction Arduino et MBlock
- Actionneur : servomoteur (déplacement)
- Capteur : ultrason (distance)
- Couplage capteur moteur
- 4 séances Conception mécanique et assemblage : TinkerCAD et impression 3D
- 2 séances sur TinkerCAD
- 2 séances sur l'impression 3D
- 3 séances d'assemblage et de programmation : Arduino IDE
- Assemblage du LittleBot
- Programmation de la cinématique du véhicule
- Algorithmie pour stratégie d'évitement d'obstacle
Matériel
Projet inspiré de : https://www.thingiverse.com/thing:2417739
- 1 x Arduino Nano ou compatible (seeeduino, funduino,...) : ~10€
- 1 x câble USB C : ~1€
- 1 x Sensor Shield pour Arduino Nano : ~3€
- 2 x servomoteur à rotation 360° (DM-S0090D-R 9g/0.08s/1.6kg.cm) : ~2€
- 1 x Module ultrason (HC-SR04) : ~2€
- 2 x élastique pour les roues (diamètre Xmm)
Une imprimante 3D pour imprimer les pièces suivantes (~5€ de filament) :
- Châssis :
- Capot :
- Roues avec rainure pour insertion élastique :
Phase 1 - Conception - 3 x 1H30
Conception 3D avec TinkerCAD
Prérequis participant :
- Travail sur ordinateur
- Manipulation avec la souris (clic droit, clic gauche, sélection,...)
Compétences Animateur :
Compétences techniques et soft skills :
- Pratique du logiciel TinkerCAD ou autre logiciel de CAO (Solidworks, Fusion360,...)
- Animation
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- Connexion et navigateur internet (Firefox)
- Session invité ou nominative
- Connexion et navigateur internet (Firefox)
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation / Tutoriels :
- Tutoriel animateur TinkerCAD - création d'une activité
- Tutoriel élève TinkerCAD - modélisation d'une pièce
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Débrancher et ranger les composants
- Chaque participant vérifie la boite du voisin (check-list)
- Remettre ordinateur dans l'état initial
- Programme de la prochaine séance
Phase 2 - Câblage et programmation du LittleBot - 4 x 1h30
Prérequis Participant
- Travail sur ordinateur
- Manipulation avec la souris (clic droit, clic gauche, sélection,...)
- Manipulation du clavier
- Notions d'électricité
- Notions de programmation par bloc (scratch)
Prérequis Animateur
Compétences techniques
- Pratique du logiciel Arduino IDE, connaissance en programmation C++
- Gestion des drivers sous Windows ou Expérience avec Ubuntu / Linux Mint
- Circuits et branchements électrique
Soft skills
- Animation
- Gestion de la Motivation et de l'attention
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
-
12 PCs (1 par participant)
- Windows ou Linux
- Connexion et navigateur internet (Firefox)
- Session invité ou nominative
- Logiciel Arduino IDE pré-installé
-
Composants éléctroniques
- Carte Arduino Nano (x12)
- Shield (extension Arduino Nano) (x12)
- Capteur Ultrasons HRC-SR04 (x12)
- Servo-Moteur DM-S0090D (x24)
- Câble Dupont (x48 - 4/participants)
-
Programmes du LittleBot et des composants
Préparation
Matériel par participant sur un poste PC en début de séance :
Documentation / Tutoriels :
- Tutoriel animateur Arduino IDE-
création d'une activité - Tutoriel élève Arduino IDE-
modélisation d'une pièce - Tutoriel Arduino Nano
- Tutoriel Capteur Ultrason
- Tutoriel Servo moteur
Exemple de déroulement pédagogique
Exemple indicatif de déroulé par séance
Déroulé effectué en 2023-2024 au club robotique de l'IUT de Haguenau (1H30/séance, collégiens 6ème-3ème) :
- Séance 1 : Câblage et programmation d'une LED sur ? Arduino IDE ou MBlock ?
- Séance 2 : Principe physique, Câblage et programmation d'un câbleur ultrason
- Séance 3 : Principe physique, câblage, et programmation d'un servomoteur
- Séance 4 : Câblage complet du LittleBot
- Séance 5 : Programmation du LittleBot
Exemple de déroulé pour la séance 1
Déroulement pédagogique complet
Pour la découverte du câblage et de la programmation, nous allons découvrir petit-à-petit les différents composants électroniques, logiciels et programmes informatiques (code) nécessaire au fonctionnement du LittleBot. Commençons pas la découverte de la carte microcontrôleur "Arduino Nano" et sa carte de développement "Sensor Shield v3".
Tutoriel : Qu'est-ce que l'"Arduino"
Maintenant que nous sommes experts en microcontrôleur, voyons comment l'utiliser pour de la robotique.
Tutoriel : Qu'est-ce qu'un robot ?
Un robot est composé de capteurs et d'actionneurs. Nous allons d'abord découvrir et apprendre à utiliser un capteur de distance :
Tutoriel : Qu'est-ce qu'un capteur ultrason ?
Ce capteur peut être utilisé pour modifier le mouvement du robot qui est actionné par des servomoteurs :
Tutoriel : Qu'est-ce qu'un servomoteur ?
Maintenant que nous savons capter notre environnement et actionner des moteurs, nous allons pouvoir programmer le mouvement des moteurs en fonction de ce que le capteur reçoit :
Tutoriel : Câblage et programmation du LittleBot
Conclusion / Rangement / Démontage :
Phase 3 - Assemblage et réctification - 2 x 1h30
Prérequis participant :
- Travail manuel et sur ordinateur
- Manipulation avec la souris (clic droit, clic gauche, sélection,...)
- Manipulation du clavier
Compétences Animateur :
Compétences techniques et soft skills :
- Pratique du logiciel Arduino IDE, connaissance en programmation C++
- Animation
- Compétences manuelles
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- Connexion et navigateur internet (Firefox)
- Session invité ou nominative
- Logiciel Arduino IDE pré-installé
- Connexion et navigateur internet (Firefox)
- Composants éléctroniques
- Carte Arduino Nano (x12)
- Shield (extension Arduino Nano) (x12)
- Capteur Ultrasons HRC-SR04 (x12)
- Servo-Moteur DM-S0090D (x24)
- Câble Dupont (x48 - 4/participants)
- Programme du LittleBot
- Châssis et capot imprimés en 3D (x12)
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation / Tutoriels :
- Tutoriel Arduino Nano
- Tutoriel Capteur Ultrason
- Tutoriel Servo moteur
- Tutoriel Câblage et Programmation
Déroulement de la séance
Lors de notre première séance, nous allons câbler et assembler le robot. Tout d'abord, nous allons câbler notre capteur ultrasons à notre shield. Par la suite, nous allons assembler le robot dans sont châssis avec le tutoriel d'assemblage.
Puis nous allons brancher nos servo-moteurs à notre Shield en passant par les emplacements prévu sur notre châssis.
Pour se faire, nous allons utiliser le tutoriel de Câblage et programmation ainsi que le tutoriel d'assemblage du LittleBot. TUTO EN COURS DE RÉDACTION
Puis nous allons programmer notre robot pour vérifier son fonctionnement via le tutoriel de Câblage et programmation.
Une fois ceci fait nous assemblons complètement notre robot. Il ne manque plus qu'à le brancher et le faire tourner !
Lors de notre seconde séance nous allons rectifier / améliorer notre robot.
Avec le code que nous avons donné à notre carte, le robot ne tourne que dans un sens lors de la rencontre d'un obstacle.
Nous allons donc améliorer le programme pour rendre la direction aléatoire. Pour se faire nous allons utiliser le tutoriel Amélioration du LittleBot.
De plus notre LittleBot étant branché par USB à notre ordinateur, il ne pourrait pas aller bien loin. Nous lui installerons alors une batterie qui se représente ici par une pile. Voici comment la brancher. TUTO EN COURS DE RÉDACTION.
A la fin de ces 2 séances, notre LittleBot est totalement autonome et peu se déplacer pendant des heures. Félicitation !
Fiche Séance 2 - 1H30
Introduction aux servo-moteurs
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience avec les composants de base Arduino
- Bases de la Programmation Arduino IDE
- Animation
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- MBlock et Arduino IDE installés
- configuration port série et modèle carte
- MBlock et Arduino IDE installés
- arduino Nano + Sensor shield + servomoteur
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un servo-moteur ?"
- Tutoriel branchement
- Check-list composants présents dans la boite. Pour vérification en début et en fin de séance.
Fiche participant
Objectifs
Compétences techniques :
- Prendre en main servo et Logiciel
- Faire tourner un servo moteur
Savoir-être, compétences transversales :
- Travail individuel
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Débrancher et ranger les composants
- Chaque participant vérifie la boite du voisin (check-list)
- Remettre ordinateur dans l'état initial
- Programme de la prochaine séance
Qu'est ce qu'un servo-moteur ?
I Introduction
Lorsque vous créez un projet qui intègre des éléments robotique vous arrivez forcément à devoir faire un choix de moteur pour automatiser votre création. Plusieurs solutions existent, comme par exemple des moteurs à courant continu:
Ceux-ci ont l'avantage d'être très simple d'utilisation. Il suffit de connecter leurs deux fil d'alimentation à une batterie et ils se mettent à tourner.
Une autre solution serait d'utiliser des moteurs pas à pas :
Ces moteurs sont très pratique pour déplacer quelque-chose à un endroit précis, du fait que vous pouvez précisément le positionner à un angle donné. Par contre leur utilisation n'est pas aussi triviale que pour un moteur à courant continu.
Ce que je vous propose dans ce tutoriel c'est de découvrir les Servomoteurs. il en existe deux type :
- A contrôle d'angle
- A contrôle de vitesse de rotation
Les premiers ne tournent pas en continu, mais en général entre 0° et 180° et vous pouvez contrôler leur angle de rotation. Très pratique quand vous voulez faire un bras robotisé, piloter l’orientation des roues avant d'une voiture, ou bien contrôler un petit mécanisme. Les Servomoteurs suivants sont très pratiques lorsque vous souhaitez faire tourner un objet en contrôlant sa vitesse, par exemple des roues! :
Ce sont des Servomoteurs à contrôle d'angle sur 180° et le tutoriel va donc porter sur ce type de moteur.
II Fonctionnement
https://fr.wikipedia.org/wiki/Servomoteur --> fonctionnement
Les Servomoteurs intègrent au sein d'un même boitier un moteur à courant continu, un potentiomètre, un réducteur et un circuit de contrôle. L'idée est que la valeur d'angle est mesurée grâce au potentiomètre et le circuit de contrôle fait tourner le moteur et corrige l'orientation. Voila une image qui donne une idée du fonctionnement interne:
Vous l'avez surement remarqué, le Servomoteur a trois fils. Le fil marron correspond à la masse, le fil rouge au 5 Volts et le fil orange à l'envoi de données. C'est par le fil orange que nous allons envoyer le signal pour la commande de l'angle voulu au Servomoteur.
L’instruction par le fil orange s'envoie sous la forme d'un signal PWM (Pulse Width modulation=Modulation en largeur d'impulsion). Le principe est que l'envoi d'instruction se fait par un signal électrique qui passe de façon régulière et rapide (30-50Hz ou 300Hz) de 0 à 5 Volts. La valeur de l'angle voulu est définie par le rapport entre le temps où le signal est à 5 Volts et le temps où celui-ci est à 0 Volt. Par exemple pour un angle de 0°, on envoie 5V pendant 1ms puis 0V pendant 19ms : Le signal est à 5V pendant 5% du temps (1ms/20ms). Une image vous donnera une meilleure idée:
III Mise en pratique
Pour consolider votre compréhension nous allons mettre en pratique avec un Arduino. L'Arduino permet de générer des signaux PWM avec la fonction AnalogWrite() mais nous ne pouvons pas l'utiliser avec un Servomoteur, car sa fréquence est trop élevée (environ 500Hz). Pour ce faire nous allons plutôt utiliser la librairie servo.h qui est disponible de base avec le programme Arduino.
Connectez d'abord un Servomoteur à l'Arduino comme sur l'image:
et on utilisera pour l'exemple le code suivant
#include <Servo.h>
Servo myservo; // On créé un objet MyServo par lequel on envoie les instructions au servo
void setup()
{
pinMode(6,OUTPUT);
myservo.attach(6); // On associe notre objet au Pin connecté au fil de données du servo
}
void loop()
{
myservo.write(0); //donne l'ordre de mettre le Servo à son angle minimum
delay(1000);
myservo.write(255); //donne l'ordre de mettre le Servo à son angle maximum
delay(1000);
}
Si tout se passe bien, vous devriez voir le Servomoteur tourner de 180° toutes les secondes. Après ça, je vous conseille de vous amuser en modifiant les valeurs et/ou le code afin de vous familiariser avec son utilisation.
Vous savez maintenant le minimum nécessaire pour correctement utiliser un Servomoteur.
Piloter un servomoteur avec Mblock
I/ Introduction
Pour ce faire nous allons utiliser Mblock.
Après avoir lancé le logiciel, nous allons ajouter la carte que nous utilisons :
Cliquez sur "Ajouter".
Puis sur la carte qui nous intéresse, ici c'est l'Arduino Nano.
Puis cliquez sur connecter, cette fenêtre s'ouvrira.
Cochez "Afficher tous les appareils disponibles", puis selectionnez le port COM de votre carte.
Votre carte Arduino est maintenant connectée au logiciel.
II/ Branchement du servo
III/ Code
Fiche Séance 3 - 1H30
Introduction au capteur à ultrasons
Fiche Animateur
Prérequis participant :
- Travail sur ordinateur
Compétences Animateur :
Compétences techniques et soft skills :
- Expérience avec les composants de base Arduino
- Bases de la Programmation Arduino IDE
- Animation
Matériels nécessaires
logiciel, électronique, mécanique, outils, matériaux, code...
- 12 PCs (1 par participant)
- MBlock et Arduino IDE installés
- configuration port série et modèle carte
- MBlock et Arduino IDE installés
- Capteur à ultrasons (HC-SR04) + carte Sensor shield + arduino Nano + X cables dupont
Préparation :
Matériel par participant sur un poste PC en début de séance :
Documentation :
- Tutoriel introduction "Qu'est ce qu'un capteur à ultrasons ?"
- Check-list composants présents dans la boite. Pour vérification en début et en fin de séance.
Fiche participant
Objectifs
Compétences techniques :
- Introduction générale, objectifs du club et du cycle 1
- Prendre en main capteur ultrasons
- Faire tourner un servo selon une distance
Savoir-être, compétences transversales :
- Travail individuel
- Lire un tutoriel détaillé
Déroulement de la séance
Conclusion / Rangement / Démontage :
- Rangement en fin de séance
- Débrancher et ranger les composants
- Chaque participant vérifie la boite du voisin (check-list)
- Remettre ordinateur dans l'état initial
- Programme de la prochaine séance
Qu'est ce qu'un capteur à ultrasons ?
HC-SR04 est un capteur à ultrasons qui est principalement utilisé pour la mesure de distance. En émettant des ondes ultrasonores et en mesurant le temps pris par ces ondes pour rebondir après avoir frappé un objet, le HC-SR04 peut déterminer avec précision la distance à laquelle cet objet se trouve. De par son coût abordable et sa facilité d’intégration avec des plateformes telles qu’Arduino, le HC-SR04 est devenu un choix prisé parmi les amateurs de bricolage et les professionnels.
Principe de fonctionnement
Le fonctionnement d'un capteur à ultrason comme le HC-SR04 est assez simple. Il comporte deux éléments principaux : un émetteur ultrasonore et un récepteur ultrasonore. Voici les étapes clés du fonctionnement du capteur :
- Lorsque le capteur est alimenté, l’émetteur envoie une série de 8 impulsions ultrasoniques de 10µs à une fréquence spécifique (généralement de 40 kHz).
- Lorsque une impulsion sonore atteint un objet, elle rebondit et est renvoyée vers le récepteur ultrasonore comme un écho.
- Le capteur mesure le temps entre le moment où l’impulsion a été émise et celui où l’écho a été reçu.
- En utilisant la vitesse connue du son dans l’air (environ 343 m/s ou 34,3 cm/µs) et la durée de l’écho mesurée, le capteur calcule la distance jusqu’à l’objet en utilisant la formule : distance = (durée de l’écho / 2) * vitesse du son.
- Le résultat est ensuite converti en une distance numérique et envoyé au Arduino via une sortie numérique
Description du capteur HC-SR04
Broche | Description |
---|---|
VCC | Il s’agit de la broche d’alimentation. Elle nécessite généralement une entrée de 5V Courant Continu, la rendant directement compatible avec des cartes comme Arduino. |
Trig (Déclenchement) | Cette broche est utilisée pour initier le capteur à émettre une onde ultrasonore. En envoyant une impulsion haute d’au moins 10µs à cette broche, le HC-SR04 émettra une série de 8 impulsions d'ultrasons à 40 kHz. |
Echo | Une fois l’onde ultrasonore émise et qu’elle rebondit après avoir frappé un objet, la broche Echo fournit une impulsion de sortie. La largeur de cette impulsion est proportionnelle à la distance de l’objet par rapport au capteur. En mesurant la durée de cette impulsion, Arduino peut déterminer la distance jusqu’à l’objet. |
GND (Masse) | Cette broche est connectée à la masse du circuit. |
Le câblage :
Pour connecter le capteur HC-SR04 à une carte Arduino, suivez ces étapes :
- Connectez la broche VCC du HC-SR04 à la broche 5V sur la carte arduino uno. Cela assure que le capteur reçoive la puissance nécessaire pour son fonctionnement.
- Reliez la broche GND (Masse) du HC-SR04 à l’une des broches de masse (GND) d’Arduino. Cela établit une masse électrique commune entre le capteur et arduino.
- Connectez la broche Trig du HC-SR04 à une broche numérique d’Arduino, par exemple, la broche D12. Cette broche est responsable de l’envoi d’un signal pour déclencher le capteur afin qu’il émette les ondes ultrasonores.
- Reliez la broche Echo du HC-SR04 à une autre numérique sur l’Arduino, comme la broche D11. Cette broche détecte l’onde ultrasonore écho après réflexion sur un objet.
Programmer un HC-SR04
Ce code permet de mesurer une distance et de l'afficher sur le serial print du logiciel Arduino IDE.
// définition des numéros de broches
const int trigPin = 12;
const int echoPin = 11; // définition des variables
long duration;
int distance;
void setup()
{
pinMode(trigPin, OUTPUT); // Définit le trigPin comme sortie
pinMode(echoPin, INPUT); // Définit le echoPin comme entrée
Serial.begin(9600); // Commence la communication série
}
void loop()
{
// Efface le trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2); // Met le trigPin à l'état HIGH pendant 10 microsecondes
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW); // Lit le echoPin, renvoie le temps de trajet de l'onde sonore en microsecondes
duration = pulseIn(echoPin, HIGH); // Calcul de la distance
distance = duration * 0.034 / 2; // La vitesse du son est d'environ 0.034 cm par microseconde
Serial.print(“Distance: “); // Affiche la distance sur le moniteur série
Serial.println(distance);
}
Source :
https://www.moussasoft.com/hc-sr04-capteur-ultrason-avec-arduino
Câblage et programmation du LittleBot
Le câblage
Pour le câblage et la programmation du LittleBot, il nous faut :
- Un Arduino Nano (ou équivalant)
- Un Sensor Shield
- Un capteur à ultrason (HC-SR04)
- 2 Servomoteur / Moteur (DM-S0090D)
Le branchement ce présente comme ceci :
- Tout d'abord nous branchons l'Arduino Nano sur notre Sensor Shield. Attention, il y a un sens. Le port de charge doit être sur l'extérieur de votre Shield.
- Nous allons a présent brancher notre capteur à ultrason :
- VCC sur une pin 5V.
- Trig sur la pin 6.
- Echo sur la pin 7.
- GND sur une pin GND
3. Nous allons brancher nos Servomoteur, les câbles de nos servo sont tous reliés à un raccord. Celui ci ne peut être branché que dans un seul sens. Nou brancherons donc un servo sur la pin 10 et un servo sur la pin 11.
- Le fil marron sur la pin G
- Le fil rouge sur la pin V
- Le fil orange sur la pin S
Ainsi le servo qui est sur la pin 10 sera notre roue droite et le Servo sur la pin 11 sera notre roue gauche.
Votre câblage est terminé.
Passons maintenant à la programmation.
Le programme
Ici nous décomposerons notre programme pour bien l'écrire.
Tout d'abord, nous déclarons la librairie et les servo que nous utiliserons :
#include <Servo.h>
#define trigPin 6
#define echoPin 7
Servo servo1;
Servo servo2;
Puis nous déclarons sur quelles pins sont branchés nôtre capteur et nos servo :
void setup() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
servo1.attach(11);
servo2.attach(10);
}
Rentrons dans le vive du sujet :
void loop() {
long duration, distance; // Nous déclarons notre variable que nous retrouverons plus tard
digitalWrite(trigPin, LOW); //Ici notre capteur à ultrason est en "position 0"
delayMicroseconds(2); // Pendant 2 Microsecondes
digitalWrite(trigPin, HIGH); //Ici notre capteur à ultrason est "activé"
delayMicroseconds(10); //Pendant 10 Microsecondes
digitalWrite(trigPin, LOW); //Puis nous le retournons en position "0"
duration = pulseIn(echoPin, HIGH); // Nous déclarons notre variable "duration" qui est la durée du trajet du son.
distance = (duration*0.034) / 2; // Nous déclarons notre variables "distance" par la duréé multiplié par la vitesse du son le tout divisé par 2.
if (distance < 20) { // Nos déplacement commence ici, "Si la distance est inférieur à 20cm alors..."
servo1.writeMicroseconds(1000);//Servo Gauche tourne à l'envers
servo2.writeMicroseconds(2000);//Servo Droit tourne à l'envers
delay (2000);// pendant 2 sec
servo1.writeMicroseconds(1000);//Servo Gauche tourne à l'envers
servo2.writeMicroseconds(1500);//Arrêt du Servo Droit
delay (2000);// pendant 2 sec
}
else { //Sinon...
servo1.writeMicroseconds(2000);//Servo Gauche tourne
servo2.writeMicroseconds(1000);//Servo Droit tourne
delay (2000);// pendant 2 sec
}
}
Puis nous assemblons le tout, voici à quoi cela devrait ressembler :
#include <Servo.h>
#define trigPin 6
#define echoPin 7
Servo servo1;
Servo servo2;
void setup() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
servo1.attach(11);
servo2.attach(10);
}
void loop() {
long duration, distance;
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration*0.034) / 2;
if (distance < 20) {
servo1.writeMicroseconds(1000);
servo2.writeMicroseconds(2000);
delay (2000);
servo1.writeMicroseconds(1000);
servo2.writeMicroseconds(1500);
delay (2000);
}
else {
servo1.writeMicroseconds(2000);
servo2.writeMicroseconds(1000);
delay (2000);
}
}
Apprendre à utiliser TinkerCad (classe)
Utiliser Tinkercad
TinkerCad est un "logiciel" de modélisation 3D simple d'utilisation.
Il permet aussi de programmer et de créer des câblages avec des Arduino numérique.
Tout d'abord il vous faudra, avec un compte enseignant, créer une classe sur le site web : https://www.tinkercad.com/
Dans ce tuto nous allons apprendre les bases de ce logiciel avec la fonction perçage.
Voici les étapes pour que les utilisateurs puisse se connecter à la classe.
Rejoindre une classe
La première étapes sera d'aller sur le site web https://www.tinkercad.com/joinclass.
Puis d'entrer le code de classe fourni par le professeur.
Nous allons utilisé un pseudo prédéfini par le professeur.
Programme MBLOCK
Club Robotique 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.
Coté droit :
Matériel :
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 :
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 :
Cette plaque se place entre le bas de la tourelle et la plaque de montage du servo de base.
Placez le cercle comme sur l'image ci-dessus, puis fixer le servomoteur comme ci-dessous.
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
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
Stages de Robotique pour les collégiens - Station Mesure Eau
Le stage se déroule de la manière suivante : 1. Conception de la formation des animateurs 2. Conception du contenu technique du stage 3. Journée de formation des animateurs (1 jour) 4. Ateliers de robotique éducative pour jeunes (3 jours) Coût :
Fiche résumé
Intitulé de l'atelier
Illustration / Image
Durée de l'atelier
Objectifs pédagogiques
Autres objectifs (si applicable)
- Défis Résilience des territoires ADEME (si applicable)
Préparation
Outillage (investissement)
Ex. Imprimante 3D
- Coût d'un robot :
Matériaux (consommable pour un stage)
Consommable
Financement
- Coût par enfant : 5000€/24
Local / Lieu / Équipement
- 1 PC par élève (minimum 1 PC pour deux)
- 1 animateur pour 4 participants
Équipe
- animateurs ayant participé à la formation
- 1 animateur pour 4 participants
Normes / Sécurité
- Autorisation parentale -> sortie de bâtiment sans les parents
- Droit à l'image -> photos pour la com'
- Carnet de vaccination
- Fiche sanitaire
Conception technique du stage
Exécution
Accueil
Consignes
Préparation des Matériaux / Kits
Pauses
Fabrication / Assemblage
Etapes avec les participants
Matin
Après-midi
Rangement
Photo de Groupe
Après l'Atelier
Communication
Documentation
Contact Documentation / Atelier
Conception de la formation des animateurs
Exécution
Accueil
Consignes
Préparation des Matériaux / Kits
Pauses
Fabrication / Assemblage
Etapes avec les participants
Matin
Après-midi
Rangement
Photo de Groupe
Après l'Atelier
Communication
Documentation
Contact Documentation / Atelier
Atelier de formation des animateurs
Fiche de documentation de conduite d'atelier
Exécution
- Accueil des enfants + Jeu "brisure de la glace"
- Atelier pédagogique (~ 1h30 max)
- Activité ludique (jeux de société/en extérieur/etc...)
- Goûter
- Rituel de départ
Accueil
Consignes
Préparation des Matériaux / Kits
Pauses
- Pauses du goûter
Fabrication / Assemblage
Etapes avec les participants
Matin
Après-midi
Exemples d'activités ludiques
- Jeux de société
- Loup-garou
- Jeux pour découvrir l'IUT
- Geogesser
- Exemple de badge
- Geogesser
Rangement
Photo de Groupe
Après l'Atelier
Communication
Documentation
Contact Documentation / Atelier
Ateliers de développement de la station de mesure de l'eau (5 jours)
Mission Otez l’eau
Depuis quelques mois, un changement soudain dans la qualité de l'eau a été signalé dans plusieurs régions du monde, ce qui soulève des inquiétudes. Les premières enquêtes révèlent une contamination progressive de l'eau, liée à des défaillances dans les systèmes de traitement et de rejets des eaux usés par une usine. Face à cette menace environnementale et sanitaire, l'association Savoirs Vivants, et l’IUT de Haguenau, ont été missionné par les services secrets français pour monter une équipe de roboticiens et de chercheurs pour identifier l’usine à la source de ces contaminations.
En tant que nouveaux membres de ce consortium de chercheurs votre première mission sera de vous trouver un nom d’équipe pour réussir à communiquer facilement avec le reste des autres chercheurs et votre chef d’équipe.
Votre mission consiste à concevoir, assembler, et programmer la Station AquaLife pour qu'elle soit capable de détecter les contaminants dans l'eau avec précision et efficacité. Pour cela, vous utiliserez des technologies de pointe en robotique, en informatique et en analyse chimique.
La Station AquaLife que vous allez concevoir pour collecter et analyser des échantillons d'eau en temps réel, fournira des données essentielles pour identifier les sources d’eau contaminé et ainsi trouver la source de ces contaminations.
Déroulement du projet :
- Lundi : Conception 3D - Initiez-vous au design assisté par ordinateur pour concevoir la pièce manquante de la Station AquaLife, permettant d’afficher les données sur l’écran.
- Mardi : Assemblage et Pratique - Construisez le prototype de votre Station AquaLife en assemblant les capteurs et les circuits nécessaires.
- Mercredi : Programmation Fonctionnelle - Implémentez le code informatique qui permettra à la Station AquaLife de collecter et d'analyser les données.
- Jeudi : Tests chimiques - Testez votre Station AquaLife avec différents échantillons d'eau récoltés autours des usines ciblés.
- Vendredi : Analyse et Présentation - Interprétez les données collectées, identifiez les tendances et préparez une présentation de vos résultats. Cette étape sera cruciale pour identifier la source de la contamination.
En participant à la Mission Otez l’eau, vous apportez une contribution concrète à la résolution d'un problème environnemental d’envergure. Vous acquerrez des compétences en robotique, en analyse de données et en travail d'équipe, tout en aidant à protéger la ressource la plus précieuse de notre planète : l'eau. Prêts à relever ce défi vital ?
Préparation des Matériaux / Kits
Station de mesure de l'eau
Liste du matériel de la station : Liste_materiel.pdf
Connexion des capteurs sur la carte d'extension DRF0762 : connexion_capteurs_carte_DFR0762.pdf
Arduino
Installation de la carte ESP2 et des bibliothèques pour la station d'eau dans l'IDE Arduino : Arduino_Installation_Cartes_Bibliotheques.pdf
Programme Arduino complet de la station d'eau : 2024_stage_collegiens_v5_Station_Eau.ino
Ci-dessous, le programme simplifié :
/// CODE SIMPLIFIE SANS TDS ET TURBIDITE
// #include <Arduino.h>
#include <U8g2lib.h> // by oliver <olikraus@gmail.com> testé 2.34.22
#include <DHT.h>
#include <OneWire.h>
#include <DallasTemperature.h>
//****************************************************************************************//
// Constante de temps et broches de connexion des capteurs //
//****************************************************************************************//
const int pause_affichage_ms = 100; // temps de pause d'affichage en milliseconde
// #define TDS_Sensor_Pin_Num A2 // TDS sensor on Analog pin Ax
// #define Turbidity_Sensor_Pin_Num A3 // Turbidity sensor on Analog pin Ax
#define pH_Sensor_Pin_Num A4 // pH sensor on Analog pin Ax
#define DS18S20_Pin_Num_v2 D2 // DS18B20 sensor on digital pin Dx <======= Zone d'affectation des capteurs et actionneurs
#define DHT_Sensor_Pin_Num D6 // DHT on Digital pin Dx
//****************************************************************************************//
//Données et configuration pour le capteur DHT
#define ref_DHT DHT22 // référence du DHT (DHT11, DHT22...)
char Hum_DHT[8], Temp_DHT[8];
DHT dht(DHT_Sensor_Pin_Num, ref_DHT);
// Données pour le capteur pH meter (v2) ==> site DFRobot
const int numMeasure = 10;
char pH_2[8];
float offset_pH2 = 0; // valeur standard = -1.8 avec la carte pH alimentée en 3.3V et -2.5 avec carte alimentée en 5V
// Donnée TDS meter (v1)
// char TDS_1[8];
// float temperature = 25;
// Données pour le capteur de turbidité
// char Turbi_volt[8], NTU_strg[8];
// float Turbi_val = 0;
// Configuration pour le capteur de température DS18B20 (v2)
OneWire ds(DS18S20_Pin_Num_v2); //on digital pin 2
char Temp_DS_2[8];
// Configuration de l'afficheur SSD1315
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(/* rotation=*/ U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); //Low spped I2C
/*
U8g2lib Example Overview:
Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
*/
void get_DHT()
{
float h = 0.0;
float t = 0.0;
h = dht.readHumidity();
dtostrf(h, 5, 1, Hum_DHT); // conversion digital to string
t = dht.readTemperature();
dtostrf(t, 5, 1, Temp_DHT);
Serial.print("DHT ==> Humidité : ");
Serial.print(Hum_DHT);
Serial.print(" Température (°C) : ");
Serial.println(Temp_DHT);
}
void get_pH_2()
{
int buf[10],temp;
for(int i=0;i<numMeasure;i++) //Get 10 sample value from the sensor for smooth the value
{
buf[i]=analogRead(pH_Sensor_Pin_Num);
delay(10);
}
for(int i=0;i<numMeasure-1;i++) //sort the analog from small to large
{
for(int j=i+1;j<numMeasure;j++)
{
if(buf[i]>buf[j])
{
temp=buf[i];
buf[i]=buf[j];
buf[j]=temp;
}
}
}
unsigned long int sumValue = 0; //Store the average value of the sensor feedback
for(int i=2;i<numMeasure-2;i++) //take the average value of 6 center sample
sumValue+=buf[i];
float phValue=(float)sumValue*5.0/4096/(numMeasure-4); //convert the analog into millivolt
// phValue=3.5*phValue + offset_pH2; //convert the millivolt into pH value avec carte pH alimentée en 5v
phValue=5.3*phValue + offset_pH2; //convert the millivolt into pH value avec carte pH alimentée en 3.3v
dtostrf(phValue, 5, 1, pH_2);
Serial.print("pH_2 value: ");
Serial.println(phValue,2);
}
// void get_TDS_1()
// {
// int TDS_ADC = 0;
// float TDS_volt = 0;
// float compensationCoefficient = 1.0+0.02*(temperature-25.0); //temperature compensation formula: fFinalResult(25^C) = fFinalResult(current)/(1.0+0.02*(fTP-25.0));
// float compensationVolatge = 0; //temperature compensation
// float TDS_val = 0;
// TDS_ADC = analogRead(TDS_Sensor_Pin_Num);
// TDS_volt = TDS_ADC/4096.0*5.0;
// compensationVolatge = TDS_volt/compensationCoefficient;
// TDS_val=(133.42*compensationVolatge*compensationVolatge*compensationVolatge - 255.86*compensationVolatge*compensationVolatge + 857.39*compensationVolatge)*0.5; //convert voltage value to tds value
// dtostrf(TDS_val, 5, 1, TDS_1);
// Serial.print("TDS_1 valADC (0 à 4095) : ");
// Serial.print(TDS_ADC);
// Serial.print(" voltage (V) : ");
// Serial.print(TDS_volt);
// Serial.print(" ppm : ");
// Serial.println(TDS_val);
// }
// void get_Turbidity()
// {
// int sensorValue = 0;
// float voltage = 0, NTU = 0;
// sensorValue = analogRead(Turbidity_Sensor_Pin_Num); // read the input on analog pin
// voltage = sensorValue * (5.0 / 4096); // Convert the analog reading (which goes from 0 - 4095) to a voltage (0 - 5V)
// dtostrf(voltage, 5, 1, Turbi_volt);
// NTU = -1120.4*voltage*voltage + 5742.3*voltage - 4352.9; //
// dtostrf(NTU, 5, 0, NTU_strg);
// Serial.print("Turbidity (volt) : "); // print out the value you read:
// Serial.print(voltage); // print out the value you read:
// Serial.print(" Turbidity (NTU) : "); // print out the value you read:
// Serial.println(NTU); // print out the value you read:
// Turbi_val = voltage;
// }
void get_TempDS_2()
{
//returns the temperature from one DS18S20 in DEG Celsius
byte data[12];
byte addr[8];
if (!ds.search(addr))
{
//no more sensors on chain,reset search
Serial.println("No more addresses.");
Serial.println();
ds.reset_search();
}
Serial.print("ROM =");
for(int i = 0; i < 8; i++)
{
Serial.write(' ');
Serial.print(addr[i], HEX);
}
Serial.println();
if (OneWire::crc8(addr,7)!=addr[7])
{
Serial.println("CRC is not valid!");
}
// the first ROM byte indicates which chip
byte type_s;
switch (addr[0])
{
case 0x10:
Serial.println(" Chip = DS18S20"); // or old DS1820
type_s = 1;
break;
case 0x28:
Serial.println(" Chip = DS18B20");
type_s = 0;
break;
case 0x22:
Serial.println(" Chip = DS1822");
type_s = 0;
break;
default:
Serial.println("Device is not a DS18x20 family device.");
break;
}
if (addr[0] != 0x10 && addr[0] != 0x28)
{
Serial.print("Device is not recognized");
}
ds.reset();
ds.select(addr);
ds.write(0x44,1); //start conversion, with parasite power on at the end
byte present = ds.reset();
ds.select(addr);
ds.write(0xBE); //ReadScratchpad
for(int i=0; i<9; i++) //weneed9bytes
{
data[i]=ds.read();
}
ds.reset_search();
byte MSB=data[1];
byte LSB=data[0];
float tempRead=((MSB<<8)|LSB); //using two's compliment
float TemperatureSum = tempRead/16;
// return TemperatureSum;
dtostrf(TemperatureSum, 5, 1, Temp_DS_2);
Serial.print("Temperature DS (en °C) : ");
Serial.println(TemperatureSum);
}
void setup()
{
// put your setup code here, to run once:
Serial.begin(115200);
Serial.println("**********************************************");
Serial.println("Setup Serial monitor OK");
u8g2.begin();
Serial.println("Setup écran OLED OK");
dht.begin();
pinMode(pH_Sensor_Pin_Num,INPUT); // Set pH sensor pin to input mode
// pinMode(Turbidity_Sensor_Pin_Num, INPUT); // Set the turbidity sensor pin to input mode
Serial.println("End of setup");
Serial.println("**********************************************");
}
void loop()
{
// put your main code here, to run repeatedly:
get_DHT();
get_pH_2();
// affichage des données
u8g2.setFont(u8g2_font_ncenB08_tr); // choose a suitable font
//****************************************************************************************//
// écran OLED SSD1315 :
// fonction U8g2.drawStr(n°colonne,n°ligne,string)
u8g2.clearBuffer(); // clear the internal memory
u8g2.drawStr(0,10,"Station eau"); // write something to the internal memory
u8g2.drawStr(0,25,"Humidity DHT :"); // affichage du texte "Humidity DHT:"
u8g2.drawStr(92,25,Hum_DHT); // affichage de la valeur de l'humidité
u8g2.drawStr(0,30,"Temp DHT :"); // affichage du texte "Temp DHT :"
u8g2.drawStr(68,30,Temp_DHT); // affichage de la valeur de température fournie par le capteur DHT <== zone à modifier (remplacer xx par des valeurs)
u8g2.drawStr(0,35,"pH :"); // affichage du texte "pH :"
u8g2.drawStr(20,35,pH_2); // affichage de la valeur du pH
u8g2.sendBuffer(); // transfer internal memory to the display
delay(pause_affichage_ms);
//****************************************************************************************//
// get_TDS_1();
// get_Turbidity();
get_TempDS_2();
//****************************************************************************************//
u8g2.clearBuffer(); // clear the internal memory
// u8g2.drawStr(0,25,"TDS :"); // affichage du texte "TDS :"
// u8g2.drawStr(35,25,TDS_1); // affichage de la valeur de conductivité TDS
// u8g2.drawStr(0,37,"Turbidity (V) :"); // affichage du texte "Turbidity (V) :"
// u8g2.drawStr(80,37,Turbi_volt); // affichage de la valeur de turbidité en volt <== zone à modifier
u8g2.drawStr(0,49,"Temp DS :"); // affichage du texte "Temp_DS :" à la position
u8g2.drawStr(57,49,Temp_DS_2); // affichage de la valeur de température du DS18B20
u8g2.sendBuffer();
//****************************************************************************************//
//****************************************************************************************//
// Code pour gérer une LED //
//****************************************************************************************//
// Affciher un message d'alerte selon la valeur de la turbidité
/*
float seuil = x; // valeur du seuil
if (Turbi_val > seuil) // comparaison par rapport au seuil
{
u8g2.drawStr(0,62,"Eau limpide !");
u8g2.sendBuffer();
}
else
{
u8g2.drawStr(0,62,"Eau trouble !");
u8g2.sendBuffer();
}
*/
delay(pause_affichage_ms);
Serial.println();
}
Calibration du capteur pH
Programme Arduino pour la calibration du capteur pH : 2024_calibration_materiel_capteur_pH.ino
Procédure de calibration matériel du capteur pH : Procedure_Calibration_Materiel_Capteur_pH.pdf
Jour 1 - Conception 3D
Mission :
Une dernière pièce est manquante pour la réalisation de la station. Vous allez devoir la concevoir et la produire sur mesure en utilisant un logiciel de conception 3D (TINKERCAD), ce qui permettra d'obtenir le boitier de la station AquaLife.
Conception Tinkercad T78-12G-PM4
TINKERCAD est un logiciel de conception 3D simple et efficace. Ce tutoriel vous aidera à l’utiliser : https://innovation.iha.unistra.fr/books/2-fablab-activites-logiciels/page/initiation-3d-tinkercad
Ouvrir Tinkercad à partir de la barre de recherche Windows de votre ordinateur.
Dans l'onglet 3, prenez l'outil nommé « boîtes », ensuite faites-le glisser sur le plan de construction.
Une fenêtre apparaîtra, vous permettant de régler différents paramètres de cette fenêtre (rayon, étapes, longueur, largeur et hauteur) pour voir ce qui se passe.
Vous êtes désormais prêt(e) à conceptualiser les pièces nécessaires pour finaliser notre station AquaLife. Celle-ci doit à la fin ressembler à la photo ci-dessous.
Création de la dernière pièce de la station : Pour commencer, il vous faut un rectangle avec les mesures suivantes : Longueur = 126 mm ; Largeur = 54 mm ; Hauteur = 3 mm.
Nous devons créer un emplacement pour l’afficheur. Pour ce faire, nous avons besoin d’un rectangle de perçage. Donnez-lui les dimensions suivantes : Longueur = 25 mm ; Largeur = 18 mm ; Hauteur = 4 mm.
Déplacez-le sur votre rectangle rouge.
Pour assembler les deux, utilisez les raccourcis clavier : Ctrl+A puis Ctrl+G
Voici le rendu que vous devriez avoir :
Par la suite, créez l’emplacement pour la vis qui maintiendra votre afficheur.
Pour ce faire, créez un cylindre de perçage.
Voici ses dimensions : Diamètre = 8 mm ; Hauteur = 5 mm.
Déplacez-le pour le mettre au bon endroit.
L’outil « règle » sera votre meilleur ami pour placer correctement le cylindre.
Placez cet outil dans le coin inférieur droit de l’emplacement de l’afficheur. Une fois placé, des cotes apparaîtront, comme sur l'image suivante :
Modifiez seulement les cotes en vert. La cote de gauche sera de 5 mm et celle du bas de 8 mm. Ensuite, assemblez les deux en faisant : Ctrl+A puis Ctrl+G.
Votre support pour l’afficheur est maintenant prêt !
Jour 2 - Assemblage mécanique et électronique
Mission :
Aujourd’hui, votre objectif est d’assembler les capteurs de votre station AquaLife. Pour réaliser l’assemblage et le montage, vous allez d’abord découvrir les différents capteurs, les fixer à votre station et les câbler à la carte ESP32 en fonction des recommandations de connexion. Ci-dessous une image du montage final :
Tutoriel des capteurs :
L'ESP32 (et son extension) est une carte microcontrôleur très performante qui permet de créer des projets électroniques connectés. Grâce à ses nombreux ports, tu peux y connecter des capteurs, des moteurs, ou d'autres composants pour réaliser des gadgets intelligents, des systèmes de domotique, ou des robots. |
Un afficheur est un écran qui permet de montrer des informations ou des données provenant du microcontrôleur. On peut l'utiliser pour afficher des textes, des chiffres... C'est très utile pour voir ce que fait le microcontrôleur en temps réel, comme la température d'une pièce, le score d'un jeu, ou l'état d'un système. |
Un conductimètre est un instrument qui mesure la capacité de l'eau à conduire l'électricité, ce qui nous informe sur la quantité de sels ou d'autres substances dissoutes dans l'eau. Plus l'eau contient de substances dissoutes, mieux elle conduit l'électricité. Cette mesure est très utile pour vérifier la pureté de l'eau. |
Un turbidimètre, permet de mesurer la turbidité, qui sert à évaluer la clarté de l'eau en détectant combien de petites particules sont suspendues dans celle-ci. Plus l'eau contient de particules comme de la terre, des micro-organismes, ou des substances chimiques, plus elle apparaît trouble. |
|
|
Un pH-mètre est un instrument utilisé pour mesurer l'acidité ou la basicité d'une solution. Il donne une valeur appelée "pH", qui varie généralement de 0 à 14. Un pH de 7 est neutre, des valeurs inférieures à 7 indiquent une acidité, et des valeurs supérieures à 7 révèlent une basicité. Le pH-mètre est essentiel, car il aide à comprendre l'équilibre chimique des solutions. |
Un thermomètre est un instrument qui permet de mesurer la température de l'eau. En mesurant la température, on peut s'assurer que l'eau est dans les conditions optimales, que ce soit pour assurer la santé des organismes aquatiques, garantir la sécurité des baigneurs, ou maintenir l'efficacité des processus industriels. |
Le DHT22 est un capteur qui mesure à la fois la température et l'humidité de l'air ambiant. Il fournit des informations précieuses pour contrôler les conditions environnementales. En mesurant l'humidité, le DHT22 aide à surveiller la quantité de vapeur d'eau dans l'air, ce qui est crucial pour maintenir une bonne qualité de l'air. Pour la température, il assure que les conditions soient confortables et sûres. |
Avec ces informations vous êtes prêts à assembler votre station.
Étape 1 : Aller chercher les composants auprès de l'animateur
- Un afficheur, avec des câbles femelle-femelle de toutes les couleurs.
- Un conductimètre avec sa carte d’interface, ainsi qu’un câble correspondant.
- Un turbidimètre, avec sa carte d’interface, ainsi qu’un câble correspondant.
- Un pH-mètre, avec sa carte d’interface, ainsi qu’un câble correspondant.
- Un thermomètre, avec sa carte d’interface, ainsi qu’un câble correspondant.
- Un DHT22, avec sa carte d’interface, ainsi qu’un câble correspondant.Un ESP32 et son extension, ainsi qu’un câble USB/USB-C pour alimenter votre station à l’ordinateur.
Étape 2 : Fixer les interfaces des capteurs à la station.
Fixer avec des vis adaptées, les interfaces des capteurs dans la boite de la station comme indiqué ci-dessous.
Étape 3 : Brancher l’afficheur et les capteurs à l’ESP32 via la carte d’extension présentée ci-dessous.
Observer l’organisation de la carte d’extension et repérer les différents signaux.
Connecter les capteurs et l'afficheur sur la carte d'extension DFR0762 selon les indications ci-dessous :
Jour 3 - Programmation Arduino
Mission :
Aujourd’hui, votre objectif est de programmer la station AquaLife. Vous allez écrire, modifier et tester le code nécessaire pour contrôler les différents capteurs selon les instructions décrites ci-dessous. Bonne chance.
Étape 1 : Lancement de l'IDE Arduino et configuration de l'application
-
Charger le fichier : 2024_stage_collegiens_v5.ino
-
Connectez votre station ESP32 à votre ordinateur via un câble USB-A/USB-C.
-
Vérifiez le port de connexion de votre ESP32 (CH340K), en consultant le gestionnaire de périphériques de votre ordinateur pour identifier le port de communication (dans notre exemple ci-dessous : COM10).
- Sélectionnez ce port de communication dans l'environnement Arduino en utilisant le menu déroulant situé en haut à gauche, comme indiqué dans l'exemple (indiqué comme "Unknown COM10" dans cet exemple).
- Choisissez le modèle de carte approprié pour votre ESP32 dans les options de carte disponibles. Pour cet exemple, sélectionnez "FireBeetle 2 ESP32-E" (voir dans l’exemple ci-dessous).
Étape 2 : Assignation des pins des capteurs dans le code
- Dans le code, de la ligne 13 à 17, remplacez les marqueurs "Ax" et "Dx" par les numéros de pin correspondants à votre câblage sur la carte d'extension de l'ESP32. Par exemple, si le pin analogique pour le capteur de TDS est 9, remplacez "TDS_Sensor_Pin_Num Ax" par "TDS_Sensor_Pin_Num A9".
Étape 3 : Compiler et charger le code dans l’ESP32
- Un message d’erreur apparaît, notez les numéros des lignes de code mentionnés.
- Remplacez les chaînes de caractères "xxxxx", "yyyyy" et "zzzzz" mentionnées dans les lignes d'erreur par l'identifiant du capteur spécifié. Ces identifiants, comme "TDS_Sensor_Pin_Num" pour le turbidimètre, sont indiqués en orange dans les lignes de code de 13 à 17.
- Assurez-vous que le capteur concerné par l'erreur est correctement décrit dans une fonction dont le nom est en adéquation avec ce capteur, située dans les lignes précédant l’erreur.
- Recompilez le code pour vérifier que les erreurs ont été corrigées.
Une fois le code compilé sans erreurs, chargez-le dans l'ESP32 en cliquant de nouveau sur le bouton encadré en rouge.
Étape 4 : Correction de l'affichage pour une lecture claire des informations des capteurs
- Modifiez la durée de pause entre chaque séquence d'affichage, qui se trouve à la ligne 11. Changez la valeur actuelle de 0,1 seconde à 2 secondes. Notez que cette valeur doit être saisie en millisecondes dans le code.
- Le code pour la première séquence d'affichage est situé entre les lignes 275 et 291. Vous remarquerez que les lignes de texte se superposent, rendant difficile la lecture des informations.
- Corrigez ce problème en ajustant le deuxième paramètre (x) dans la fonction d'affichage u8g2.drawStr(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 :
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/