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

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 :

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 :

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.

maxresdefault.jpg

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.

Sélection_999(227).png

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".

image.pngKit-Robot-Araign-e-Quadrup-de-Bionique-pour-Ardu37-Bricolage-WiFi-Robot-Inoling-STEM-ESP8266-NodeMCU.jpg

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

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 :

Savoir-être :

Compétences transversales :

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 : 

image.png

  1. Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge.
  2. 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".
  3. Étapes de la programmation :
    • Créer une séquence de base pour faire avancer le robot.
    • Ajouter des commandes pour faire tourner le robot.
  4. Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
  5. Discussion de groupe : Échanger sur les difficultés rencontrées et les solutions trouvées.
  6. Correction : 

    image.png

Parcours 2 :

image.png

  1. Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge.
  2. 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".
  3. Étapes de la programmation :
    • Créer une séquence de base pour faire avancer le robot.
    • Ajouter des commandes pour faire tourner le robot.
  4. Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
  5. Bilan collectif : Échanger sur les difficultés rencontrées et les solutions trouvées.
  6. Correction :

    image.png

Parcours 3 :

image.png

  1. Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge..
  2. 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".
  3. Étapes de la programmation :
    • Créer une séquence de base pour faire avancer le robot.
    • Ajouter des commandes pour faire tourner le robot.
  4. Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
  5. Présentation finale : Échanger sur les difficultés rencontrées et les solutions trouvées.
  6. Correction : 

    image.png

Conclusion et retour d'expérience

À la fin de l'activité, chaque groupe fera un retour sur son expérience :

Club Robotique Cycle 0 - Codey Rocky

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 :

Savoir-être :

Compétences transversales :

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

image.png

  1. 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.

  2. 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.

  3. É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.

  4. 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.

  5. 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.*

  6. Correction : 

    image.png

Parcours 2 : Utilisation du capteur de détection d’obstacles

image.png

  1. 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.

  2. 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.

  3. É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.

  4. 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.

  5. 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.

  6. Correction : 

    image.png

Conclusion et retour d’expérience

À la fin de l'activité, chaque groupe partagera son expérience avec la classe :

Club Robotique Cycle 0 - Codey Rocky

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 :

Compétences transversales :

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

  1. 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).

  2. 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.

  3. É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.

  4. 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.

  5. 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.

  6. Correction : 

    image.png

Parcours 2 : Suivi de ligne fluide

  1. 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.

  2. 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.

  3. É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.

  4. 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.

  5. 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.
  6. Correction :

    image.png

Conclusion et retour d’expérience

À la fin de l’activité, chaque groupe pourra partager ses observations :

Club Robotique Cycle 1 - LittleBot

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.

maxresdefault.jpg

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

Description du déroulé

11 séances :

Matériel

Projet inspiré de : https://www.thingiverse.com/thing:2417739

Une imprimante 3D pour imprimer les pièces suivantes (~5€ de filament) :

Club Robotique Cycle 1 - LittleBot

Phase 1 - Conception - 3 x 1H30

Conception 3D avec TinkerCAD

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, électronique, mécanique, outils, matériaux, code...

Préparation :

Matériel par participant sur un poste PC en début de séance :

  • PC allumé
  • Codes d'accès session Windows/Linux
  • Création d'une activité avec le tutoriel animateur TinkerCAD
  • Lien d'invitation à l'activité
  • Numérotation des PCs pour que les élèves sachent quel compte utiliser
  • Temps de préparation : 5min

Documentation / Tutoriels :

Déroulement de la séance

  • Consignes : Sécurité, précautions matériel :
    • Travail individuel
  • Phases et méthodes d’animation
    1. Présentation du club et du cycle 1 (10min)
    2. Tutoriel TinkerCAD (15min)
    3. Présentation de la phase de conception (5min)
    4. Présentation du cahier des charges pour la conception
      1. Contraintes sur les dimensions
    5. Charges 

Conclusion / Rangement / Démontage :

Club Robotique Cycle 1 - LittleBot

Phase 2 - Câblage et programmation du LittleBot - 4 x 1h30

Prérequis Participant

Prérequis Animateur

Compétences techniques

Soft skills

Matériels nécessaires

logiciel, électronique, mécanique, outils, matériaux, code...

Préparation

Matériel par participant sur un poste PC en début de séance :

  • PC allumé
  • Codes d'accès session Windows/Linux
  • Création d'une activité avec le tutoriel animateur Arduino IDE
  • Vérifier que le téléversement de programme sur la carte fonctionne depuis Arduino IDE
  • Temps de préparation : 5min

Documentation / Tutoriels :

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) :

Exemple de déroulé pour la séance 1

  • Consignes : Sécurité, précautions matériel :
    • Travail individuel

  • Phases et méthodes d’animation

    1. Mise en contexte de la séance précédente(10min)

    2. Tutoriel Arduino IDE (15min)

    3. Présentation de la phase de programmation (5min)

    4. Présentation du cahier des charges pour la programmation

      1. Contraintes sur les alimentations (5v ou 3.3v)
      2. Quelles pins sont à utiliser pour les capteurs ultrasons ?
      3. Comment brancher un servo-moteur ?
      4. Contrainte du sens de rotation des servo-moteurs
      5. Rendre le changement de sens du robot aléatoire

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 :

  • 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
Club Robotique Cycle 1 - LittleBot

Phase 3 - Assemblage et réctification - 2 x 1h30

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, électronique, mécanique, outils, matériaux, code...

Préparation :

Matériel par participant sur un poste PC en début de séance :

  • PC allumé
  • Codes d'accès session Windows/Linux
  • Création d'une activité avec le tutoriel animateur Arduino IDE
  • Matériels électroniques et corps du LittleBot désassemblé 
  • Temps de préparation : 5min

Documentation / Tutoriels :

Déroulement de la séance

  • Consignes : Sécurité, précautions matériel :
    • Travail individuel

 

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 !

 

Club Robotique Cycle 1 - LittleBot

Fiche Séance 2 - 1H30

Introduction aux servo-moteurs

Fiche Animateur

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, électronique, mécanique, outils, matériaux, code...

Préparation :

Matériel par participant sur un poste PC en début de séance :

  • Rassembler le matériel électronique
  • PC allumé avec MBlock et arduino IDE ouvert
  • Temps de préparation : 1H

Documentation :

Fiche participant

Objectifs

Compétences techniques :

Savoir-être, compétences transversales :

Déroulement de la séance

  • Consignes : Sécurité, précautions matériel :
    • Travail individuel
    • Ne pas plier les pattes des composants plus que nécessaire : risque de casse
    • Tout est fragile
  • Phases et méthodes d’animation
    1. Présentation de l'activité du jour (5min)
    2. Présentation Différent servo (15min)
    3. Présentation Servo moteur - PWM - fonctionnement méca (15min)
    4. Branchement servo à la carte (5min)
    5. Programmer et faire tourner le servo (30min)

Conclusion / Rangement / Démontage :

Club Robotique Cycle 1 - LittleBot

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:

ori-moteur-miniature-rm260-20767.jpg

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 :

NEMA17-001-1.jpg

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 :

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! :

tiptopboards.com_169-thickbox_mini-servo-moteur-sg90-9g-mod_c3_a9lisme-arduino.jpg

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:

upload.wikimedia.org_wikipedia_commons_d_d3_micro_servo.jpg

vue-interne-dun-servomoteur-sans-lelectronique-de-commande.jpg

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:

TiemposServo.png

Source : https://upload.wikimedia.org/wikipedia/commons/thumb/f/f6/TiemposServo.svg/220px-TiemposServo.svg.png 

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. 

Club Robotique Cycle 1 - LittleBot

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".

Connecter.JPG

Puis sur la carte qui nous intéresse, ici c'est l'Arduino Nano.

nano.JPG

co.JPG

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

Servo.JPG

III/ Code

code.JPG

Club Robotique Cycle 1 - LittleBot

Fiche Séance 3 - 1H30

Introduction au capteur à ultrasons

Fiche Animateur

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, électronique, mécanique, outils, matériaux, code...

Préparation :

Matériel par participant sur un poste PC en début de séance :

  • Rassembler le matériel électronique
  • PC allumé avec MBlock et Arduino IDE
  • Temps de préparation : 1H

Documentation :

Fiche participant

Objectifs

Compétences techniques :

Savoir-être, compétences transversales :

Déroulement de la séance

  • Consignes : Sécurité, précautions matériel :
    • Travail individuel
    • Ne pas plier les pattes des composants plus que nécessaire : risque de casse
    • Tout est fragile
  • Phases et méthodes d’animation
    1. Présentation de l'activité du jour 
    2. Présentation Capteur ultrason
    3. Branchement servo +
    4.  capteur ultrasons
    5. Programmation Mblock et Arduino

Conclusion / Rangement / Démontage :

Club Robotique Cycle 1 - LittleBot

Qu'est ce qu'un capteur à ultrasons ?


ori-module-de-detection-us-hc-sr04-20912.jpgHC-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 :

  1. 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).
  2. Lorsque une impulsion sonore atteint un objet, elle rebondit et est renvoyée vers le récepteur ultrasonore comme un écho.
  3. Le capteur mesure le temps entre le moment où l’impulsion a été émise et celui où l’écho a été reçu.
  4. 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.
  5. Le résultat est ensuite converti en une distance numérique et envoyé au Arduino via une sortie numérique

Principe_Ultrasons_1.jpg

sonar_signal.jpg

Description du capteur HC-SR04

Ultrason.JPG

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 :

  1. 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.
  2. 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.
  3. 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.
  4. 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.

utlra.JPG

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

https://www.carnetdumaker.net/articles/mesurer-une-distance-avec-un-capteur-ultrason-hc-sr04-et-une-carte-arduino-genuino/

Club Robotique Cycle 1 - LittleBot

Câblage et programmation du LittleBot

Le câblage

Pour le câblage et la programmation du LittleBot, il nous faut :

Le branchement ce présente comme ceci :

Branchement littlebot.png

Transl

Translator


  1. 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.
  2. Nous allons a présent brancher notre capteur à ultrason :

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.

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);
}
}

      

Club Robotique Cycle 1 - LittleBot

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

1.png

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. 

2.png

3.png

Nous allons utilisé un pseudo prédéfini par le professeur.

4.png

Club Robotique Cycle 1 - LittleBot

Programme MBLOCK

Image4.jpg

Club Robotique Cycle 2 - Station de mesure (T°, H)

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:

Savoir-être, compétences transversales:

Déroulement de la séance:

  1. Consignes: Sécurité, précautions matériel:

    • Travail individuel.

    • Rappel: Tout est fragile.

  2. Phases et méthodes d’animation:

     

  3. 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é.

  1. 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.

  2. 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.
      • Câblage :
      • VCC(+) sur une pin 5V.
      • DAT(out) sur le pin 2 S.
      • GND(-) sur une pin GNDimage.png
      • Et par la suite dès que vous aurez programmer la carte vous pourrez branchez une batterie pour que votre station fonctionne.
  2. Prendre en main le logiciel TinkerCad:
  3. La conception du fichier :
    1. Création du Boîtier Principal:

Création du Passage pour le Capteur:

Conception du Capot:

Ajustements Finaux:

Validation et Export:


Conclusion / Rangement / Démontage:

Club Robotique Cycle 2 - Station de mesure (T°, H)

Phase 2 - Impression 3D

Phase 2 - Impression 3D

Objectifs :

Compétences techniques :

Savoir-être et compétences transversales :

Déroulement de la séance :

1.Exportation de la boite :

2.Préparation du fichier pour l'impression :

Conclusion / Rangement :

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 !

Club Robotique Cycle 2 - Station de mesure (T°, H)

Phase 3 - Programmation

Phase 3 - Programmation de la station

Objectifs

Compétences techniques:

Déroulement de la séance

  1. Introduction:

    • Présentation des éléments nécessaires pour la programmation.
    • Importance de la programmation dans le projet de station météo.

  2. Programmation:

    • Commençons par la programmation sur Mblock.
    • N'oubliez pas d'installer l'extension pour le capteur en cliquant sur ce boutonimage.png,puis taper dans la barre de recherche "DHT22" et ensuite juste besoin de l'ajouter.

      image.png

    •  

      Maintenant vous avez juste besoin de faire le code qui permet de mesuré la température grâce au DHT 22 et qui la renvoie sur le moniteur série.

    • image.png

    • 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.

    •  

      image.png

    • 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

image.png

#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é) en octets
const int NUM_ENTRIES = EEPROM_SIZE / ENTRY_SIZE; // Nombre d'entrées que l'on peut stocker

int currentAddress = 0; // Adresse actuelle pour stocker

void setup() {
  Serial.begin(9600);
  dht.begin();
  Serial.println("Démarrage du système...");

  // Stocker des données dans l'EEPROM en mode circulaire
  for (int i = 0; i < NUM_ENTRIES; i++) {
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();
    if (!isnan(temperature) && !isnan(humidity)) {
      EEPROM.put(currentAddress, temperature);
      currentAddress += sizeof(float);
      EEPROM.put(currentAddress, humidity);
      currentAddress += sizeof(float);
      
      if (currentAddress >= EEPROM_SIZE) {
        currentAddress = 0; // Revenir au début si on dépasse la taille de l'EEPROM
      }
    }
    delay(60000); // Attendre 1 heure entre chaque mesure
  }
}

void loop() {
  // Pas besoin de code dans loop pour cette démonstration
}

             3. Validation:

             4. Conclusion:

Résolution de problèmes

image.png

image.png

image.png

Club Robotique Cycle 2 - Station de mesure (T°, H)

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 :

Compétences techniques :

Savoir-être :

Compétences transversales :

Déroulement de la séance :

  1. 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.).

  2. 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).

  3. 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.

       

      image.png

      image.png


       

    • 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, si vous avez collez votre texte dans la case A1, ensuite si vous êtes sur Exel n'oubliez pas de les convertir en valeurs.
    • image.png
    • 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é".

      image.png


      Et ensuite appuyer sur "OK".
    • Faire de même pour les valeurs de l'humidité.

  4. 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.

      image.png


    • 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".

    • image.png

    • 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é.

  5. 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

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 :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, électronique, mécanique, outils, matériaux, code...

Préparation :

Matériel par participant sur un poste PC en début de séance :

  • PC allumé
  • Codes d'accès session Windows/Linux
  • Création d'une activité avec le tutoriel animateur TinkerCAD et OnShape
  • Lien d'invitation à l'activité
  • Numérotation des PCs pour que les élèves sachent quel compte utiliser
  • 1 feuille + 1 crayon + 1 gommes + 1 règle par élèves
  • 1 moteur à courant continu
  • Temps de préparation : 5min

Documentation / Tutoriels :

Déroulement de la séance

  • Consignes : Sécurité, précautions matériel :
    • Travail individuel
    • Travail collaboratif 
  • Phases et méthodes d’animation
    1. Présentation du cycle 3 (10min)
    2. Présentation du cahier des charges de la voiture RC (10min)
    3. Présentation du fonctionnement d'une direction de voiture RC avec un servomoteur. (10min)
    4. Création de la voiture RC sur papier.
      1. Châssis
        1. Création d'un modèle de châssis pouvant accueillir deux moteurs CC en vue du dessus avec un système d'accroche des moteurs (imaginé par l'élèves)
        2. Création de la vue de côté pour permettre une meilleure visualisation du système d'accroche des moteurs.
        3. Création du système de direction avec un servomoteur
        4. Création du système d'accroche du châssis à la carrosserie. 
      2. Châssis
        1. Création de la carrosserie
        2. Création du système d'accroche de la carrosserie au châssis 
    5. Tutoriel TinkerCAD / OnShape (15min)
    6. Création des différentes parties en CAO 
      1. Création du châssis en CAO avec tout les systèmes.
      2. Création de la carrosserie avec tout les systèmes.
      3. Assemblage des deux parties.

 

 

Nous allons donc créer notre châssis, pour commencer voici la forme ainsi que les cotations de notre pièce.

Plan.JPG

 

Puis une extrusion sur 3mm.

 

3d.JPG

 

 

 

Conclusion / Rangement / Démontage :

Club Robotique Cycle 3 - Voiture RC

Phase 2 - Électronique et programmation

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, électronique, mécanique, outils, matériaux, code...

Préparation :

Matériel par participant sur un poste PC en début de séance :

  • PC allumé
  • Codes d'accès session Windows/Linux
  • Temps de préparation : 5min

Documentation / Tutoriels :

Déroulement de la séance

  • Consignes : Sécurité, précautions matériel :
    • Travail individuel
    • Travail collaboratif 
  • Phases et méthodes d’animation
    1. Présentation du cycle 3 (10min)
    2. Présentation du cahier des charges de la voiture RC (10min)
    3. Présentation du fonctionnement d'un moteur CC. (10min)
    4. Tutoriel Module Bluetooth + Moteur CC
    5. Câblage des composant
    6. Programmation des modules

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
Club Robotique Cycle 3 - Voiture RC

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

Club Robotique Cycle 3 - Voiture RC

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 :

PXL_20240522_131216458_1080p.jpg

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/

Club Robotique Cycle 3 - Voiture RC

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

image.png

//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

Club Robotique Cycle 3 - Voiture RC

Le module Bluetooth HC-05

Test et configuration du module

https://www.aranacorp.com/fr/votre-arduino-communique-avec-le-module-hc-05/

image.png

//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

image.png

//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

voir : https://innovation.iha.unistra.fr/books/robotique-educative/page/rc-car-voiture-modelisme-radiocommandee#bkmrk-depuis-le-moniteur-s 

Depuis une application bluetooth de smartphone Android

Voici les caractères Android :

Voici le fonctionnement du joystick de l'application E&E: Arduino Automation par Engineers & Electronics

L'application E&E: Arduino Automation par Engineers & Electronics est testée ne semble pas fonctionner avec les Android récents ni iOS :

Sources

https://knowledge.parcours-performance.com/arduino-bluetooth-hc-05-hc-06/

Club Robotique Cycle 3 - Voiture RC

RC Car - Voiture modélisme radiocommandée

Pilotage depuis le clavier d'un PC

via la liaison série Arduino-USB

//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

voir : https://innovation.iha.unistra.fr/books/robotique-educative/page/le-module-bluetooth-hc-05#bkmrk-application-bluetoot 

Depuis le moniteur série d'Arduino IDE

Source : https://www.instructables.com/View-Serial-Monitor-Over-Bluetooth/# 

image.png

image.png

image.png

image.png

//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

Club Robotique Cycle 3 - Voiture RC

Code voiture RC

image.png

//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

Club Robotique Cycle 4 - Bras Robotique

Phase 1 - Assemblage des pièces

Phase 1 - Assemblage des pièces

Objectifs pédagogiques

Compétences techniques visées

Savoir être (compétences comportementales)

Compétences transversales

Montage du bras robotique :

Matériel Nécessaire :

Tournevis : 1                                                                                                   Arduino Nano : 1                                                           

Grand Vis : 1                                                                                                  Shield : 1

M3*6 : 1                                                                                                         Câbles Mâle Femelle : 3

Vis Servomoteur : 10                                                                                      Servomoteur : 4

M3*12 : 29                                                                                                      Hélice Servomoteur : 2

M3*20 : 6                                                                                                         Demi Hélice Servomoteur : 3

Ecrou M3 : 13                                                                                                  Câble USB-A vers USB-C : 1

image.png            image.png

Montage de la Pince :

Matériel :

M3*12 : 7

M3*6 : 1

Vis servomoteur : 2

Servomoteur : 1

Demi Hélice Servomoteur : 1

image.png

Etape 1 :                                                                    

Placer votre Servomoteur dans A1, bien faire attention                             

à ce que le câble soit placé là où se trouve le petit espace                        Etape 2 :                                                                                                                    

de l'encoche puis placé D1 dans l'encoche sur le coté droit.                      Placer de la même façon la pièce D2 de l'autre coté.

image.png                                          image.png

Etape 3 :                                                                                             

Attacher la pièce B1 en plaçant la partie la plus                                Etape 4 :

longue vers la sortie du fil.                                                                 Fixer les pièces E1 et E2.

image.png                                          image.png

Etape 5 :                                                                                                             

Mettre la demi hélice sur G1 et la fixer sur le servomoteur ;                             Etape 6 :

La butée du servomoteur doit être à l'arrière de la pince                                 Mettre les dernières pièces (C1, F1) comme sur 

mais faire en sorte qu'il tourne vers E2.                                                             l'image ci-dessous. Et la pince est finie.

image.png                          image.png

Montage de la Base :

Matériel :

 

image.png

    

Club Robotique Cycle 5 - Poubelle Connectée

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 :

Matériel nécessaire :

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 :

  1. Capteur à ultrasons (HC-SR04) :

    • VCC → 5V de l’Arduino
    • GND → GND de l’Arduino
    • TRIG → D9 de l’Arduino
    • ECHO → D10 de l’Arduino

  2. 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 :

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 :

image.png

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.

Club Robotique Cycle 5 - Poubelle Connectée

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 :

Matériel nécessaire :

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 :

  1. 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

  2. É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
}

  3. 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 :

  1. 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

  2. É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
}

  3. 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é :

É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 :

  1. Demandez aux élèves de télécharger le code final sur leur Arduino.
  2. Placez un objet à moins de 5 cm du capteur à ultrasons.
  3. Observez le servomoteur se déplacer à 180 degrés pendant 1 seconde, puis revenir à sa position initiale.

5. Conclusion et discussion 

Synthèse :

Questions de réflexion :

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 :

Stages de Robotique pour les collégiens - Station Mesure Eau

Fiche résumé

Intitulé de l'atelier

Illustration / Image

Durée de l'atelier

Objectifs pédagogiques

Autres objectifs (si applicable)

image.png

Préparation

Outillage (investissement)

Ex. Imprimante 3D

Matériaux (consommable pour un stage)

Consommable

Financement

Local / Lieu / Équipement

Équipe

Normes / Sécurité

Stages de Robotique pour les collégiens - Station Mesure Eau

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

Stages de Robotique pour les collégiens - Station Mesure Eau

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

Stages de Robotique pour les collégiens - Station Mesure Eau

Atelier de formation des animateurs

Fiche de documentation de conduite d'atelier

Exécution

  1. Accueil des enfants + Jeu "brisure de la glace"
  2. Atelier pédagogique (~ 1h30 max)
  3. Activité ludique (jeux de société/en extérieur/etc...)
  4. Goûter
  5. Rituel de départ

Accueil

Consignes

Préparation des Matériaux / Kits

Pauses

Fabrication / Assemblage

Etapes avec les participants

Matin

Après-midi

Exemples d'activités ludiques

Rangement

Photo de Groupe

Après l'Atelier

Communication

Documentation

Contact Documentation / Atelier

Stages de Robotique pour les collégiens - Station Mesure Eau

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 :

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.

image.png   image.png

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.

image.png

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.

image.png

Déplacez-le sur votre rectangle rouge.

image.png

Pour assembler les deux, utilisez les raccourcis clavier : Ctrl+A puis Ctrl+G

Voici le rendu que vous devriez avoir :

image.png

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.

image.png

Déplacez-le pour le mettre au bon endroit.

L’outil « règle » sera votre meilleur ami pour placer correctement le cylindre.

image.png

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 :

image.png

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.
image.png

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 :

image.png

Tutoriel des capteurs : 

image.png

image.png

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.

image.png

image.png

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.

image.png

image.png

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.

 image.png

 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
É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.image.png

É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.

image.png

Connecter les capteurs et l'afficheur sur la carte d'extension DFR0762 selon les indications ci-dessous :

image.png

image.png

image.png
image.png image.png

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

image.png

image.png

image.png

Étape 2 : Assignation des pins des capteurs dans le code

image.png

Étape 3 : Compiler et charger le code dans l’ESP32 

image.png

image.png

image.png
Étape 4 : Correction de l'affichage pour une lecture claire des informations des capteurs

image.png

Étape 5 : Activation d’un message d’alerte sur l’afficheur

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

image.png

Étape 2 : Analyses physique des échantillons d’eau A, B, C et T

image.png

Étape 3 : Analyses chimiques des échantillons d’eau A, B, C et T

image.png

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".

image.png

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 

image.png

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

image.png

Étape 2 : Interprétation et conclusion

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

 

 

 

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).    

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.

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

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 :

image.png

Matériel et Plateforme standards pour la robotique éducative

Où acheter des composants et cartes électroniques :

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)