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

Fiche Séance 4 - 1H30

Introduction au logiciel de modélisation 3D (TinkerCad)

Fiche Animateur

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, modélisation, mécanique, outils, matériaux, 

Préparation :

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

  • Création de compte élève sur TinkerCad. 
  • Préparation du fichier (supprimer certaine partie de la pièce)
  • Temps de préparation : 30min

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
    • Tout est fragile
  • Phases et méthodes d’animation
    1. Présentation de l'activité du jour 
    2. Prendre en main le logiciel TinkerCad
    3. Modifier un modèle 3D 
    4. Imaginer et créer des modifications du fichier

Conclusion / Rangement / Démontage :

Club Robotique Cycle 1 - LittleBot

Fiche Séance 5 - 1H30

Introduction au logiciel de modélisation 3D (TinkerCad)

Fiche Animateur

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, modélisation, mécanique, outils, matériaux, 

Préparation :

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

  • Création de compte élève sur TinkerCad. 
  • Préparation du fichier (supprimer certaine partie de la pièce)
  • Temps de préparation : 30min

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
    • Tout est fragile
  • Phases et méthodes d’animation
    1. Présentation de l'activité du jour 
    2. Prendre en main le logiciel TinkerCad
    3. Modifier un modèle 3D 
    4. Imaginer et créer des modifications du fichier

Conclusion / Rangement / Démontage :

Club Robotique Cycle 1 - LittleBot

Fiche Séance 6 - 1H30

Introduction à l'impression 3D

Fiche Animateur

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, modélisation, mécanique, outils, matériaux, 

Préparation :

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

  • Préparation du fichier (supprimer certaine partie de la pièce)
  • Temps de préparation : 30min
  • Préparation du diapo Kahoot 

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
    • Tout est fragile
  • Phases et méthodes d’animation
    1. Présentation de l'activité du jour 
    2. Faire le Kahoot
    3. Prendre en main un logiciel d'impression 3D
    4. Paramétrer une impression et la lancer 

Conclusion / Rangement / Démontage :

Club Robotique Cycle 1 - LittleBot

Fiche Séance 7 - 1H30

Introduction à l'impression 3D

Fiche Animateur

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, modélisation, mécanique, outils, matériaux, 

Préparation :

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

  • Préparation du fichier dans un slicer 
  • Temps de préparation : 30min

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 en duo
    • Tout est fragile
  • Phases et méthodes d’animation
    1. Présentation de l'activité du jour 
    2. Trouvez un fichier utilisable sur Thingiverse
    3. Paramétrer une impression et la lancer 

Conclusion / Rangement / Démontage :

Club Robotique Cycle 1 - LittleBot

Fiche Séance 8 - 1H30

Introduction à l'impression 3D

Fiche Animateur

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, modélisation, mécanique, outils, matériaux, 

Préparation :

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

  • Robot démonter 
  • Temps de préparation : 10min

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 en duo
    • Tout est fragile
  • Phases et méthodes d’animation
    1. Présentation de l'activité du jour 
    2. Résoudre le problème de programmation 
    3. Monter son robot
    4. Vérifier le fonctionnement du code

Conclusion / Rangement / Démontage :

Club Robotique Cycle 1 - LittleBot

Fiche Séance 9 - 1H30

Adaptation au contrainte du cahier des charges

Fiche Animateur

Prérequis participant :

Compétences Animateur :

Compétences techniques et soft skills :

Matériels nécessaires

logiciel, modélisation, mécanique, outils, matériaux, 

Préparation :

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

  • Robot démonter 
  • Temps de préparation : 10min

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 en autonomie
    • Tout est fragile
  • Phases et méthodes d’animation
    1. Présentation de l'activité du jour 
    2. Trouver la contrainte (pas assez de place pour ajouter une batterie dans le robot)
    3. Modifier le modèle 3d pour l'adapter 
    4. Vérifier l'assemblage finale en CAO

Conclusion / Rangement / Démontage :

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 collège Cycle 2 - Station de mesure (T°, H)

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

Phase 1 Conception (2 séances)

Phase 1 - Conception

Objectifs

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 a. Présentation de l'activité du jour

    • Objectifs rappelés.

    • Importance de la modélisation 3D dans le projet.

  3. Prendre en main le logiciel TinkerCad

    • Démonstration interactive.

    • Manipulation guidée des outils de base.

  4. La conception du fichier :

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 collège 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 :

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 collège Cycle 2 - Station de mesure (T°, H)

Phase 3 - Câblage et Programmation

Phase 3 - Câblage et Programmation de la station

Objectifs

Compétences techniques:

Déroulement de la séance

  1. Introduction:

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

  2. Câblage:

    • Branchement de l'Arduino Nano au Sensor Shield.
    • Connexion du capteur de température (DHT-11 ou DHT-22) aux broches spécifiques :
      • VCC sur une pin 5V.
      • DAT sur la pin 2.
      • GND sur une pin GND.

      • image.png

  3. Programmation:

image.png

    • Déclaration des librairies nécessaires et des adresses de stockage dans la mémoire EEPROM.
    • #include <DHT.h>
#include <EEPROM.h>

#define DHTPIN 2        // La broche à laquelle le capteur DHT est connecté
#define DHTTYPE DHT22   // Type de capteur DHT (DHT11 dans cet exemple)

void setup(){
Serial.begin(9600);

} 

DHT dht(DHTPIN, DHTTYPE);

int adresseEEPROM = 0; // Adresse de la mémoire EEPROM pour stocker la température (partie entière)
int adresseDecimaleEEPROM = 1; // Adresse suivante pour stocker la partie décimale
int adresseHumiditeEEPROM = 2; // Adresse suivante pour stocker l'humidité (partie entière)
int adresseDecimaleHumiditeEEPROM = 3; // Adresse suivante pour stocker la partie décimale de l'humidité
    • Fonctionnement de la fonction loop pour mesurer la température et l'humidité.
    • Stockage des valeurs dans la mémoire EEPROM avec gestion des adresses.
    • Réinitialisation des adresses lorsque la mémoire est pleine.
    • void loop() {
  // Mesurer la température et l'humidité
  float temperature = dht.readTemperature();
  float humidite = dht.readHumidity();

  // Vérifier si les mesures sont valides
  if (!isnan(temperature) && !isnan(humidite)) {
    // Stocker la température en interne (partie entière à adresse, partie décimale à adresseDecimaleEEPROM)
    EEPROM.write(adresseEEPROM, int(temperature));
    EEPROM.write(adresseDecimaleEEPROM, int((temperature - int(temperature)) * 100));

    // Stocker l'humidité en interne (partie entière à adresseHumiditeEEPROM, partie décimale à adresseDecimaleHumiditeEEPROM)
    EEPROM.write(adresseHumiditeEEPROM, int(humidite));
    EEPROM.write(adresseDecimaleHumiditeEEPROM, int((humidite - int(humidite)) * 100));

    // Incrémenter les adresses pour la prochaine mesure
    adresseEEPROM += 4;  // Incrémenter de 4 pour laisser un espace pour la prochaine paire (température et humidité)
    adresseDecimaleEEPROM += 4;
    adresseHumiditeEEPROM += 4;
    adresseDecimaleHumiditeEEPROM += 4;

    // Vérifier si nous avons atteint la fin de l'espace EEPROM
    if (adresseEEPROM >= EEPROM.length()) {
      adresseEEPROM = 0; // Revenir au début de l'espace EEPROM
      adresseDecimaleEEPROM = 1;  // Commencer à l'adresse suivante pour la partie décimale de la température
      adresseHumiditeEEPROM = 2;  // Commencer à l'adresse suivante pour la partie entière de l'humidité
      adresseDecimaleHumiditeEEPROM = 3;  // Commencer à l'adresse suivante pour la partie décimale de l'humidité
    }
  } else {
    Serial.println("Erreur de lecture du capteur.");
  }

  // Attendre avant la prochaine mesure
  delay(600000);  // Attendre temps de secondes entre les mesures (ajustez selon vos besoins)
}0
    • Maintenant il nous faut le code pour lire les valeurs stockées.  
      #include <EEPROM.h>

int adresseEEPROM = 0; // Adresse de la mémoire EEPROM pour la lecture des données

void lireDonneesEEPROM() {
  Serial.println("Lecture des données depuis l'EEPROM:");

  while (adresseEEPROM < EEPROM.length()) {
    // Lire la partie entière de la température
    int partieEntiereTemperature = EEPROM.read(adresseEEPROM);
    // Lire la partie décimale de la température
    int partieDecimaleTemperature = EEPROM.read(adresseEEPROM + 1);
    
    // Lire la partie entière de l'humidité
    int partieEntiereHumidite = EEPROM.read(adresseEEPROM + 2);
    // Lire la partie décimale de l'humidité
    int partieDecimaleHumidite = EEPROM.read(adresseEEPROM + 3);

    // Afficher les valeurs lues
    Serial.print("Température: ");
    Serial.print(partieEntiereTemperature);
    Serial.print(".");
    Serial.print(partieDecimaleTemperature);
    Serial.print(" °C, Humidité: ");
    Serial.print(partieEntiereHumidite);
    Serial.print(".");
    Serial.print(partieDecimaleHumidite);
    Serial.println(" %");

    // Incrémenter l'adresse pour la prochaine paire de valeurs
    adresseEEPROM += 4;
  }
}

void setup() {
  Serial.begin(9600);
  lireDonneesEEPROM();
}

void loop() {
  // Votre code principal ici
}
       

  2. Validation:

    • Vérification du programme pour s'assurer du bon fonctionnement.
    • Test du stockage des valeurs dans la mémoire EEPROM.

  3. Conclusion:

    • Récapitulation des points clés de la séance.
    • Réponses aux questions éventuelles.

Résolution de problèmes

image.png

image.png

image.png

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

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)