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

Club robotique - Explication et fonctionnement des logiciels

Club robotique - Explication et fonctionnement des logiciels

Découvre Arduino IDE et la logique d'un programme

🖥️ À quoi sert l’Arduino IDE ?

🔍 1. C’est quoi un microcontrôleur ?

Un microcontrôleur est un petit cerveau électronique.
Il est capable de recevoir des informations, de les traiter, et de faire des actions.

Par exemple :

🧠 Exemples de cartes avec microcontrôleur :

Ces cartes sont comme des mini-ordinateurs que l'on peut programmer :

Carte Caractéristiques
Arduino Uno Simple, idéale pour débuter
Arduino Nano Plus petite, mais similaire à l’Uno
ESP32

possède le Wi-Fi et Bluetooth intégrés
...

...

Chacune de ces cartes contient un microcontrôleur, c’est-à-dire un cerveau qui exécute les programmes.

💻 2. L’Arduino IDE : l’outil pour programmer ces cartes

L’IDE Arduino (IDE = Environnement de Développement Intégré) est le logiciel qui permet d’écrire des programmes pour ces cartes.

Avec l’Arduino IDE, on peut :

Si le logiciel n'est pas encore installé sur votre ordinateur.

Vous pouvez le télécharger ici :  https://www.arduino.cc/téléchargement

Il vous suffit ensuite de sélectionner le système d'exploitation que vous utilisez.

image.png

🧱 3. Structure d’un programme Arduino : les bases à connaître

Un programme Arduino est toujours organisé de la même manière, avec différentes parties bien définies :

// 1. Importation des librairies
// 2. Déclaration des variables et constantes
// 3. setup() : s’exécute une fois au démarrage
// 4. loop()  : s’exécute en boucle

📚 1. Importation des librairies (facultatif)

Une librairie est un morceau de code déjà écrit par d’autres, que l’on peut utiliser pour communiquer avec des capteurs, des écrans, des moteurs, etc.

👉 On les déclare tout en haut du programme. Et elle se note de cette façon

Exemple :

#include <Nom_de_la_librairie.h> 
🔢 2. Déclaration des constantes et variables globales

Juste sous les librairies, on déclare :

⚙️ 3. void setup() : au démarrage

void setup() {
     capteur(INPUT);  // Prépare le capteur en entrée. INPUT = entrée 

Attention :  Dans votre code vous pouvez écrire des commentaires. Ces commentaires sont donc du texte qui ne sera pas lu par le programme mais qui vous permettra d'expliquer votre programme au fur et a mesure.
Cela vous permettra donc de mieux vous repérez dans votre code, de mieux débugger votre code mais aussi de le rendre plus lisible pour un tier.
Comment faire ? : 
Il vous suffit d'écrire // devant chaque ligne de code. Si vous écrivez un commentaire sur plusieurs ligne vous pouvez commencer par /* et finir par */

🔁 4. void loop() : la répétition

Exemple :

void loop() {
     Allumer capteur;
     Attendre (10 secondes);
     Éteindre capteur;
}


Attention les codes que je vous indique ne sont pas fonctionnel pour le moment, ils permettent de comprendre petit à petit le fonctionnement et la structure d'un code sur arduino IDE.
Si vous avez bien fait attention. Vous pouvez voir que lorsque je déclare une fonction. Il y a des parenthèse à coté et pour ouvrir la fonction une { et pour la fermer une autre } mais dans l'autre sens.

4. Exercice 

Essayer sur papier (tableau, ardoise, etc...) de récapituler le fonctionnement et la structure d'un code arduino.

 

🔄 4. Comment téléverser un code dans notre microcontrôleur sur Arduino IDE

Une fois ton programme prêt dans l’Arduino IDE, il faut l’envoyer dans le microcontrôleur pour qu’il s’exécute "en vrai". C’est ce qu’on appelle le téléversement.

🧰 Matériel nécessaire

🪜 Étapes pour téléverser ton programme

  1. ✅ Connecte la carte au PC

    • Branche ta carte avec un câble USB

    • Une LED devrait s’allumer pour indiquer qu’elle reçoit de l’alimentation

  2. 🧭 Choisis le bon type de carte

    • Dans Arduino IDE, clique sur Outils > Type de carte

    • Sélectionne le modèle de ta carte (par ex. : Arduino Uno ou ESP32 ou Arduino Nano)

    • Si votre carte n'apparait pas vous pouvez télécharger les fichiers nécessaires en allant dans Outils > Type de carte > Gestionnaire de carte

  3. 🔌 Sélectionne le bon port

    • Va dans Outils > Port

    • Choisis le port série sur lequel est branchée ta carte ( COM3, COM4, etc.)

    • Si vous débrancher votre carte, un des ports disparaitra. Ce sera donc le port à utiliser.

  4. 🟢 Clique sur "Téléverser"

    • Appuie sur le bouton "->" avec une flèche vers la droite (en haut à gauche de l’IDE)

    • Attends quelques secondes : un message Téléversement terminé s’affiche

⚠️ Si ça ne fonctionne pas :

 

 

Vous pouvez retourner sur la page sur laquelle vous étiez afin de découvrir les codes à tester.

Club robotique - Explication et fonctionnement des logiciels

Mblock

Club robotique - Explication et fonctionnement des composants électroniques

Club robotique - Explication et fonctionnement des composants électroniques

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 

Servomoteur contrôlé en position "180°" ou en vitesse "360°"

https://www.makerguides.com/how-to-control-a-360-degree-servo-motor-with-arduino/#What_makes_a_continuous_servo_motor_special 

https://www.atelierdelarobotique.fr/servomoteur-standard-vs-servomoteur-a-rotation-continue-avec-arduino-programmation-et-applications#elementor-toc__heading-anchor-2 

 

Club robotique - Explication et fonctionnement des composants électroniques

Programmation d'un servomoteur 180°

Programmation des Servomoteurs avec mBlock et Arduino IDE

Objectif :

Comprendre le fonctionnement des servomoteurs et apprendre à les programmer avec mBlock et Arduino IDE.

1. Introduction aux Servomoteurs

Qu’est-ce qu’un servomoteur ?

Un servomoteur est un moteur à rotation limitée, généralement 180°, qui est contrôlé par un signal PWM (Pulse Width Modulation). Il est utilisé dans de nombreux projets tels que les bras robotisés, les portes automatiques et les robots éducatifs.

➡️ Pour en savoir plus sur les servomoteurs, cliquez ici.

2. Configuration et Programmation avec mBlock

Présentation des blocs spécifiques à la gestion des servomoteursimage.png

Dans mBlock, la gestion des servomoteurs se fait à l’aide d’un bloc dédié permettant de définir un angle précis entre 0° et 180°.

Branchement d'un servomoteur à un Arduino Nano

Un servomoteur possède trois câbles :

Exercice 1 : Programmer un servomoteur en boucle

Consigne : Programmer un servomoteur 180° pour qu'il effectue en boucle un mouvement de 0° à 180° puis de 180° à 0°, avec une pause de 2 secondes entre chaque mouvement.

Correction :

image.png

Exercice  2 :

Programmation d’un Mouvement Automatisé avec mBlock

Créer un programme permettant :
✅ De faire bouger le servomoteur progressivement de 0° à 180° et inversement.
✅ De répéter le mouvement avec une boucle continue.

Correction :

image.png

3. Configuration et Programmation avec Arduino IDE

Exercice 1 : Programmer un servomoteur pour un mouvement en boucle

Consigne : Faire osciller un servomoteur de 0° à 180° et inversement, avec une pause de 2 secondes entre chaque mouvement.

Correction : Code Arduino IDE
#include <Servo.h>

Servo monServo; // Création de l'objet Servo

void setup() {
  monServo.attach(9); // Connexion du servomoteur sur la broche D9
}

void loop() {
  monServo.write(0);   // Position à 0°
  delay(2000);         // Pause de 2 secondes
  monServo.write(180); // Position à 180°
  delay(2000);         // Pause de 2 secondes
}

Exercice 2 : 

Programmation d’un Mouvement Automatisé avec Arduino IDE

Créer un programme permettant :
✅ De faire bouger progressivement le servomoteur de 0° à 180° et inversement.
✅ D’utiliser une boucle pour répéter ce mouvement en continu.*

Correction :
#include <Servo.h>

Servo monServo;

void setup() {
  monServo.attach(9);
}

void loop() {
  for (int pos = 0; pos <= 180; pos++) { // De 0° à 180°
    monServo.write(pos);
    delay(15); // Ajuste la vitesse du mouvement
  }
  
  for (int pos = 180; pos >= 0; pos--) { // De 180° à 0°
    monServo.write(pos);
    delay(15);
  }
}


4. Discussion et Applications

Applications pratiques

Questions et suggestions d’amélioration

✅ Ajouter un potentiomètre pour contrôler l’angle du servomoteur.
✅ Utiliser un bouton poussoir pour déclencher le mouvement.
✅ Remplacer le servomoteur 180° par un servomoteur à rotation continue.

Club robotique - Explication et fonctionnement des composants électroniques

Programmation d'un servomoteur RC 360°

Objectif :

Comprendre le fonctionnement des servomoteurs et apprendre à les programmer avec mBlock et Arduino IDE.

1. Introduction aux Servomoteurs RC 360°

Qu’est-ce qu’un servomoteur RC 360° ?

Un servomoteur RC 360° (ou « continu ») est un petit moteur qui peut tourner en continu dans les deux sens (comme une roue), contrairement aux servos classiques qui ne tournent que sur un angle limité (en général 180° maximum).

⚙️ À quoi ça sert dans un robot comme le LittleBot ?

Dans le LittleBot, ces servos sont utilisés pour faire tourner les roues du robot. En envoyant des signaux différents, on peut :

2. Configuration et Programmation avec mBlock

Présentation des blocs spécifiques à la gestion des servomoteurs

Pour un servomoteur RC 360° on va utiliser le bloc ci-dessous que l'on peut trouver dans l'extensions "Servo360" ou ici "servo.mext" à télécharger et faire un glisser-déposer sur Mblock.

image.png

        Numéro de broche                         vitesse du servomoteur (dans un sens entre [-100 et 0[ et dans l'autre entre ]0 et 100]). A 0 on est donc à l'arrêt

Branchement d'un servomoteur à un Arduino Nano

Un servomoteur possède trois câbles :

Exercice sur Mblock

Consigne : Programmer un servomoteur RC 360° pour qu'il effectue en boucle un changement de sens de rotation à vitesse maximale et cela toute les 2 secondes.

3. Configuration et Programmation avec Arduino IDE

Exercice sur Arduino IDE

Consigne : Programmer un servomoteur 360 pour qu'il effectue en boucle un changement de sens de rotation à vitesse maximale et cela toute les 2 secondes.

Correction :

#include <Servo.h>

Servo monServo; // Création de l'objet Servo

void setup() {
  monServo.attach(9); // Connexion du servomoteur sur la broche D9
}

void loop() {
  monServo.writeMicroseconds(2000);   // Vitesse maximale dans un sens 
  delay(2000);         // Tourne pendant 2 secondes 
  monServo.writeMicroseconds(1000);   // Vitesse maximale dans l'autre sens 
  delay(2000);         // Tourne pendant 2 secondes
}

4. Discussion et Applications

Applications pratiques

Questions et suggestions d’amélioration

✅ Ajouter un potentiomètre pour contrôler l’angle du servomoteur.
✅ Utiliser un bouton poussoir pour déclencher le mouvement.
✅ Remplacer le servomoteur 180° par un servomoteur à rotation continue.

Club robotique - Explication et fonctionnement des composants électroniques

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 

!!Attention pour Mblock ne pas oublier d'installer l'extension en tapant "ultrasons" dans la barre de recherche.

image.png

 

Description des nouveaux blocs à utiliser :

- Ce bloc permet de d'indiquer à l'Arduino quelles broches l'on va utiliser pour le 'Trig' et pour l' 'Echo'

image.png

- Ce bloc permet de calculer à quel distance en cm l'on est d'un potentiel obstacle. 

image.png

- Ce bloc contient la valeur calculer dans le bloc précédent

image.png

Attention à bien indiquer à coté de 'Trig' et de 'Echo' les broches sur lesquels vous êtes branchés. Si votre code ne marche pas vérifier bien cela d'abord.

 

- Ce bloc permet d'écrire dans le port série

image.png

C’est quoi un port série ?

Le port série, c’est un peu comme une voie de communication entre ton ordinateur et le robot.

Imagine que l’ordinateur et le robot discutent.
Le port série, c’est le fil (ou le tunnel) par lequel les messages passent, un caractère à la fois, dans un seul sens à la fois.

En langage simple :

Où ce trouve le port série ?

Allez dans 'Arduinoc', et il se trouve dans l'encadrée rouge

image.png

Avant de téléverser votre code dans l'Arduino nano, accéder au port série et décocher ses cases en allant dans 'Arduinoc' puis cliquer sur envoyer :

image.png

Chaque exercice est à faire valider par un animateur

 
Exercice : Afficher les valeurs la distance de l'ultrason dans le port série

 

 

 

Ce code permet de mesurer une distance et de l'afficher sur le moniteur série du logiciel Arduino IDE.



// définition des numéros de broches 

const int trigPin = 12;

const int echoPin = 11; // définition des variables

long duration;

int distance;

void setup()

{

pinMode(trigPin, OUTPUT); // Définit le trigPin comme sortie 

pinMode(echoPin, INPUT); // Définit le echoPin comme entrée

Serial.begin(9600); // Commence la communication série

}

void loop()

{

// Efface le trigPin 

digitalWrite(trigPin, LOW);

delayMicroseconds(2); // Met le trigPin à l'état HIGH pendant 10 microsecondes 

digitalWrite(trigPin, HIGH);

delayMicroseconds(10);

digitalWrite(trigPin, LOW); // Lit le echoPin, renvoie le temps de trajet de l'onde sonore en microsecondes 

duration = pulseIn(echoPin, HIGH); // Calcul de la distance

distance = duration * 0.034 / 2; // La vitesse du son est d'environ 0.034 cm par microseconde 

Serial.print(“Distance: “); // Affiche la distance sur le moniteur série 

Serial.println(distance);
  
delay(2000);

}

Source :

https://www.moussasoft.com/hc-sr04-capteur-ultrason-avec-arduino

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

Club robotique - Explication et fonctionnement des composants électroniques

Batterie et Shield 18650 & Co

Carte de charge et décharge

Les shields de charge et décharge des batteries 18650, Lithion-Ion, 3.7V permettent :

On a une version simple accu "V3" et une double accu "V8" :

1. simple accu "V3" : 

image.png

2. double accu "V8" :

e91eb2b3-4fb5-42af-90af-9592c66fd8de.__CR0,0,970,600_PT0_SX970_V1___.jpg

Club robotique - Explication et fonctionnement des composants électroniques

Capteur de température et d'humidité (DHT22)

Objectif :

Comprendre le fonctionnement du capteur de température et d'humidité et apprendre à le programmer avec mBlock et Arduino IDE.

1. Introduction du capteur DHT22

Qu’est-ce qu’un capteur de température et humidité et comment il fonctionne?

Le capteur DHT22 est un dispositif utilisé pour mesurer la température et l'humidité de l'air. Il fonctionne grâce à deux composants principaux : un thermistor pour la mesure de la température et un capteur capacitif pour l'humidité.

  1. Température : Le thermistor, qui change de résistance en fonction de la température, permet de mesurer celle-ci avec une précision d'environ ±0.5°C dans une plage de -40°C à 80°C.

  2. Humidité : Le capteur capacitif d'humidité détecte les variations dans la capacité électrique causées par l'humidité dans l'air, offrant une précision d'environ ±2 à 5% pour une humidité relative comprise entre 0% et 100%.

Le DHT22 communique les données via une seule broche numérique (data). Après une courte initialisation, il envoie les informations sous forme de bits, codées dans un protocole spécifique. L'appareil peut être interrogé à des intervalles d'environ 2 secondes, car il a une période de rafraîchissement des données assez lente.

Ce capteur est populaire pour sa simplicité d'utilisation, notamment avec des microcontrôleurs comme Arduino ou Raspberry Pi, et est très utilisé dans des projets de domotique ou de surveillance de l'environnement.

2. Câblage du DHT22 avec l'Arduino nano

9fTimage.png

3. Configuration et Programmation avec mBlock

Commencer par installer l'extension pour le capteur en cliquant sur ce bouton  image.png  ,puis taper dans la barre de recherche "DHT22" et l'ajouter.

image.png

Faire un temps de brainstorming sur la logique que devra avoir le code final. Puis laisser le groupe faire le code en les aidants si besoin.

image.png

Avant de téléverser le code n'oubliez pas de décocher ces 2 cases ci-dessous qui se situe dans le moniteur série.

image.png

4. Configuration et Programmation avec Arduino IDE

------------- à remplir -------------

Club robotique - Explication et fonctionnement des composants électroniques

Qu'est ce qu'un ESP32

Club robotique - Explication et fonctionnement des composants électroniques

Qu'est ce qu'un microcontrôleur ?

Club robotique - Explication et fonctionnement des composants électroniques

Fonctionnement et programmation d'une LED RVB (ESP32)

🎯 Objectif

Faire changer la couleur d’une LED RGB (HW-479) contrôlée par une carte ESP32-WROOM-32E.
Les élèves apprendront :

🧰 Matériel

1. Définition simple

Une diode électroluminescente, appelée LED (Light Emitting Diode en anglais), est un petit composant électronique qui émet de la lumière quand on fait passer un courant électrique.

2. Comment fonctionne une LED ?

3. Avantages des LED

4. Utilisations courantes

4. Programmation

Club Robotique - Codey Rocky

Club Robotique - Codey Rocky

Phase 1 - Découverte des Codey Rocky et de Mblock


Objectif général :

L'objectif de cette activité est d'initier les élèves à la robotique et à la programmation à travers l’utilisation du robot Codey Rocky et du logiciel mBlock. Ils apprendront à concevoir des algorithmes pour programmer le robot et effectuer différentes missions. À travers trois parcours progressifs, ils développeront des compétences en logique, en résolution de problèmes et en collaboration.

Compétences techniques :

Savoir-être :

Compétences transversales :

Déroulement des parcours

Les élèves devront accomplir trois parcours progressifs avec le robot Codey Rocky. Pour chaque parcours, ils devront suivre des étapes précises de programmation à l’aide du logiciel mBlock et adapter leur code en fonction des résultats observés sur le terrain. Voici comment organiser les trois parcours :

Parcours 1 : 

image.png

  1. Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge.
  2. Objectif du parcours : Les élèves ont pour but d'aller du point vert jusqu'au point rouge en utilisant que les blocs se trouvant dans les onglets "Action" et "Evénements".
  3. Étapes de la programmation :
    • Créer une séquence de base pour faire avancer le robot.
    • Ajouter des commandes pour faire tourner le robot.
  4. Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
  5. Discussion de groupe : Échanger sur les difficultés rencontrées et les solutions trouvées.
  6. Correction : 

    image.png

Parcours 2 :

image.png

  1. Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge.
  2. Objectif du parcours : Les élèves ont pour but d'aller du point vert jusqu'au point rouge en utilisant que les blocs se trouvant dans les onglets "Action" et "Evénements".
  3. Étapes de la programmation :
    • Créer une séquence de base pour faire avancer le robot.
    • Ajouter des commandes pour faire tourner le robot.
  4. Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
  5. Bilan collectif : Échanger sur les difficultés rencontrées et les solutions trouvées.
  6. Correction :

    image.png

Parcours 3 :

image.png

  1. Présentation du défi : Expliquer aux élèves le but du premier parcours, aller du point vert jusqu'au point rouge..
  2. Objectif du parcours : Les élèves ont pour but d'aller du point vert jusqu'au point rouge en utilisant que les blocs se trouvant dans les onglets "Action" et "Evénements".
  3. Étapes de la programmation :
    • Créer une séquence de base pour faire avancer le robot.
    • Ajouter des commandes pour faire tourner le robot.
  4. Test et ajustements : Laisser les élèves tester leur programme et apporter des corrections si nécessaire.
  5. Présentation finale : Échanger sur les difficultés rencontrées et les solutions trouvées.
  6. Correction : 

    image.png

Conclusion et retour d'expérience

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

Club Robotique - Codey Rocky

Phase 2 - Approfondissement des fonctionnalités du Codey Rocky


Objectif général :

L'objectif de cette activité est d'initier les élèves à la robotique et à la programmation à travers l’utilisation du robot Codey Rocky et du logiciel mBlock. Ils apprendront à concevoir des algorithmes pour programmer le robot et effectuer différentes missions. À travers deux parcours progressifs, ils développeront des compétences en logique, en résolution de problèmes et en collaboration.

Compétences techniques :

Savoir-être :

Compétences transversales :

Déroulement des parcours

Les élèves réaliseront deux parcours en utilisant le robot Codey Rocky. Pour chaque parcours, ils devront suivre des étapes précises de programmation à l’aide du logiciel mBlock, puis ajuster leur code en fonction des résultats observés.

Parcours 1 : Utilisation d’une boucle de répétition

image.png

  1. Présentation du défi : Expliquer aux élèves le but du premier parcours, qui consiste à programmer Codey Rocky pour effectuer un trajet spécifique en boucle, ici une boucle répétitives de 3.

  2. Objectif du parcours : Utiliser une boucle de répétition pour faire en sorte que le robot répète une séquence de mouvements de manière continue. Le nombre de blocs maximum dans ce programme est de 5.

  3. Étapes de la programmation :

    • Créer une séquence de base pour faire avancer le robot et tourner à différents points.
    • Intégrer une boucle de répétition pour que le robot répète cette séquence plusieurs fois.

  4. Test et ajustements : Laisser les élèves tester leur programme et ajuster les paramètres si nécessaire pour garantir que le robot complète le parcours sans erreur.

  5. Discussion de groupe : Échanger sur les difficultés rencontrées et les solutions trouvées. Comparer les différentes manières dont les élèves ont utilisé les boucles pour optimiser leurs programmes.*

  6. Correction : 

    image.png

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

image.png

  1. Présentation du défi : Expliquer aux élèves que le second parcours consiste à programmer le robot pour se déplacer en détectant et en évitant des obstacles grâce à son capteur de distance.

  2. Objectif du parcours : Utiliser le capteur de détection d’obstacles pour permettre à Codey Rocky de réagir à son environnement en modifiant son comportement lorsqu’il rencontre un obstacle.

  3. Étapes de la programmation :

    • Créer une séquence de base pour faire avancer le robot.
    • Intégrer le capteur de distance pour détecter les obstacles et faire en sorte que le robot s’arrête lorsqu’il en rencontre un.
    • Utiliser des blocs de conditions (« si... alors... ») pour que le robot prenne des décisions en fonction de ce qu’il détecte.

  4. Test et ajustements : Permettre aux élèves de tester leur programme sur un parcours avec des obstacles. Ils devront observer comment le robot réagit et ajuster les conditions et distances de détection si nécessaire.

  5. Bilan collectif : Faire un retour en groupe sur les difficultés rencontrées, notamment sur l’utilisation des capteurs, et discuter des solutions trouvées pour que le robot puisse naviguer correctement dans un environnement rempli d’obstacles.

  6. Correction : 

    image.png

Conclusion et retour d’expérience

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

Club Robotique - Codey Rocky

Phase 3 - Suivi de ligne avec Codey


Objectif général :

Dans cette phase, les élèves vont approfondir leurs compétences en programmation et robotique en apprenant à créer un suiveur de ligne avec le robot Codey Rocky. Ils vont programmer deux types de suivi de ligne : un suivi basique basé sur des conditions simples, et un suivi fluide, qui optimise les mouvements du robot pour un déplacement plus souple.

Compétences techniques :

Compétences transversales :

Déroulement des parcours

Les élèves réaliseront deux parcours distincts avec des niveaux de difficulté croissants pour programmer Codey Rocky à suivre une ligne tracée au sol.

Parcours 1 : Suiveur de ligne basique

  1. Présentation du défi : Le robot doit suivre une ligne en alternant les actions des roues en fonction de la couleur détectée (noir ou blanc).

  2. Objectif du parcours :

    • Si le capteur de gauche détecte la couleur noire, seule la roue gauche s'active pour tourner vers la droite.
    • Si le capteur de droite détecte la couleur blanche, seule la roue droite s'active pour tourner vers la gauche.

  3. Étapes de la programmation :

    • Utiliser les blocs conditionnels pour définir les actions des roues selon la couleur détectée par les capteurs de Codey Rocky.
    • Assigner les actions des roues en fonction de la couleur noire pour tourner à droite et de la couleur blanche pour tourner à gauche.

  4. Test et ajustements :

    • Laisser les élèves tester leur programme sur une piste simple avec une ligne noire sur fond blanc.
    • Ils ajusteront les vitesses des roues et les conditions si le robot dévie ou ne suit pas correctement la ligne.

  5. Discussion de groupe : Échanger sur les stratégies utilisées pour améliorer le suivi de la ligne et résoudre les problèmes de déviation ou de perte de la ligne.

  6. Correction : 

    image.png

Parcours 2 : Suivi de ligne fluide

  1. Présentation du défi : Cette fois-ci, les élèves doivent programmer le robot pour qu'il suive la ligne de manière plus fluide, avec des virages progressifs et sans arrêts brusques.

  2. Objectif du parcours :

    • Utiliser les capteurs pour ajuster progressivement la vitesse des roues, afin de maintenir le robot centré sur la ligne et éviter des mouvements saccadés.

  3. Étapes de la programmation :

    • Utiliser les capteurs de lumière pour détecter la position du robot par rapport à la ligne.
    • Ajuster la vitesse des roues de façon continue (par exemple, faire ralentir une roue au lieu de l'arrêter complètement).
    • Éviter les changements de direction trop brusques en ajustant les conditions de manière plus douce et progressive.

  4. Test et ajustements :

    • Les élèves testeront le robot sur une piste avec des courbes plus complexes.
    • Ils ajusteront la vitesse des roues en fonction des courbes et de la réactivité des capteurs pour rendre les mouvements plus fluides.
    • Les élèves devront tester plusieurs configurations pour atteindre un suivi fluide.

  5. Bilan collectif :

    • Comparer les différences entre les deux méthodes de suivi (basique vs fluide).
    • Discuter des réglages qui ont permis d'améliorer la fluidité du robot et de l'impact des ajustements sur la vitesse et la précision des mouvements.
  6. Correction :

    image.png

Conclusion et retour d’expérience

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

Club Robotique - LittleBot

Club Robotique - LittleBot

Description du projet

Introduction

Pour ce cycle, nous allons créer un robot mobile très simple appelé LittleBot.

maxresdefault.jpg

Description des compétences visées : 

Compétences techniques et mécaniques
Compétences en électronique
Compétences en programmation
Compétences transversales

Description du déroulé des séances:

~9 séances :

Matériel

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

Club Robotique - LittleBot

Brainstorming : Imaginer notre robot de A à Z

Avant toute construction ou programmation, une séance est consacrée à un brainstorming collectif. L’objectif est de faire émerger les idées des enfants/jeunes sur les besoins, les fonctions, les matériaux et les étapes nécessaires à la réalisation du robot.

Déroulé de la séance :

Tableau regroupant les idées après débat :

image.png

Objectifs pédagogiques :

Club Robotique - LittleBot

Modification du châssis du LittleBot et Impression 3D

Le LittleBot dispose déjà de ses fichiers STL, comprenant la tête, la base, deux types de roues, ainsi qu’une demi-sphère permettant de le stabiliser. Toutefois, un problème a été identifié sur le fichier correspondant à la base, que nous allons corriger aujourd’hui.

Problème rencontré

La base du LittleBot a pour fonction de fixer les servomoteurs, de maintenir la batterie en place et de permettre l'installation de la carte Arduino Nano. Cependant, dans le fichier actuel, les trous de fixation du shield pour Arduino Nano ne sont pas positionnés correctement. C’est pourquoi nous allons modifier ce fichier.

Objectif

L’objectif de cette séance est de corriger le positionnement des trous de fixation dans le fichier STL de la base du LittleBot.

Ressources disponibles

Vous pouvez retrouver l’ensemble des fichiers STL du LittleBot ici ou dans les fichiers en pièce jointe.

Modification du Fichier :

Avant de commencer la modification, je vous invite à consulter :

Étape 1 : Préparation de l’environnement

Une fois la classe créée sur Tinkercad , avec le fichier de référence correctement chargé, et que tous les élèves sont connectés, nous pouvons passer à la phase de modification.

Comment créer une classe sur tinkercad : 

https://innovation.iha.unistra.fr/books/2-fablab-formation-machines-logiciels/page/creation-dune-classe-tinkercad

Sur l’interface principale de Tinkercad :

  1. Tout d'abord importer le fichier nommée "Base" en cliquant sur importer puis en le cherchant dans l'explorateur de fichier.

    image.png

    image.png

     

     


  2. Dès que votre fichier est importer regardez dans la barre de recherche située à droite de l’écran en cliquant sur la loupe.image.png

  3. Tapez le mot "shield" dans le champ de recherche.

  4. Sélectionnez le troisième élément proposé dans la liste (il s’agit du modèle de shield compatible avec l’Arduino Nano).

  image.png

Glisser le sur votre forme comme sur l'image ci-dessous.

image.png

Etape 2 : Ajustement du Modèle 3D

Positionnez le de manière à ce que le trou en haut à gauche du shield soit parfaitement centré sur celui de la base.

image.png

Faire un cylindre de 3mm x 1.5mm x 1.5mm.

image.png

Le mettre en mode perçage image.png

Puis le placer dans le trou en haut à droite du shield et l'enfoncer de 3mm comme ci-dessous.

image.png

Sélectionner le cylindre et la base puis les regrouper avec ce bouton image.png .

Pour la dernière étape d'ajustement, il faut percer le bas du châssis afin que le shield puisse bien se positionner.

Créer un cube de 7mm x 3mm x 6 mm.

image.png

Le placer le à 14 mm de hauteur par rapport au sol.

image.png

Coller votre cube à votre base comme sur l'image ci-dessous.

image.png

Et le rentrer de manière à ce que vous ne voyez plus la face de la base.

k9oimage.png

Mettre le cube en mode Perçage image.pnget le Regrouper image.pngavec la base.

image.png

Quand vous avez fini la modélisation vous pouvez supprimer le shield.

image.png

Etape 3 : Préparation à l'exportation

Exporter la pièce en STL.

image.png

image.png

Impression 3D :

Comme nous avons maintenant exporté notre pièce en STL qu'il faut l'imprimer, je vous invite donc à consulter cette page qui explique comment utiliser Cura (Slicer) ou cette page qui explique comment utiliser BambuStudio (Slicer).

Club Robotique - LittleBot

Fonctionnement et programmation des composants

1. Introduction à l'Arduino Nano 

Qu'est-ce que l'Arduino ?

https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-que-larduino

2. Fonctionnement et programmation d'un servomoteur RC 360°

Comment fonctionne le servomoteur RC 360° ? Consulter cette page.

Ensuite, consultez cette page pour apprendre à programmer le servomoteur RC 360°.

3. Capteur à ultrasons HC-SR04 

Comment fonctionne le capteur à ultrasons ? Consulter cette page


4. Programmation d'un capteur à ultrasons HC-SR04 avec un servomoteur RC 360°

Vous avez vu comment programmer un servomoteur RC 360° et un capteur ultrasons individuellement. Maintenant, vous apprendrez à les utiliser en même temps. (voir partie "Programmation sur Mblock"

Programmation sur Mblock

Exercice 1 : Changer le sens d'un servomoteur 360 grâce au capteur ultrasons

Consigne : 

Programmez votre carte Arduino pour que le servomoteur réagisse en fonction de la distance mesurée par le capteur à ultrasons :

Correction :

image.png

Programmation sur Arduino IDE

Exercice 2 : Changer le sens d'un servomoteur 360 grâce au capteur ultrasons

Consigne : 

Programmez votre carte Arduino pour que le servomoteur réagisse en fonction de la distance mesurée par le capteur à ultrasons :

Correction :

#include <Servo.h>

// Définir les broches du capteur HC-SR04
const int trigPin = 9;
const int echoPin = 10;

// Définir la broche du servomoteur
const int servoPin = 6;

Servo monServo;

void setup() {
  Serial.begin(9600);            // Initialisation du moniteur série
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  monServo.attach(servoPin);     // Attache le servomoteur à la broche 6
}

void loop() {
  // Mesure de la distance
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  long duree = pulseIn(echoPin, HIGH);
  float distance = duree * 0.034 / 2;  // Conversion en centimètres

  Serial.print("Distance : ");
  Serial.print(distance);
  Serial.println(" cm");

  // Contrôle du servomoteur
  if (distance > 10) {
    monServo.writeMicroseconds(2000);
  } else {
    monServo.writeMicroseconds(1000);
  }

  delay(200); // Petite pause pour éviter les mesures trop rapides
}

Club Robotique - LittleBot

Montage et Câblage du LittleBot

Etape 1 : Montage des Servomoteurs

Placez les servomoteurs dans la base du LittleBot en vous référant aux images ci-dessous.

⚠️ Attention : veillez à ce que l’axe des servomoteurs soit bien centré dans le trou prévu pour la roue.

image.png                   image.png

Visser les servomoteurs.

image.png

Nous allons maintenant passer au câblage du robot, car continuer le montage sans cette étape pourrait compliquer le branchement de certains composants.

Etape 2 : Câblage des Composants

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

Le branchement ce présente comme ceci :

Branchement littlebot.png

⚠️ Attention à bien vous référer aux inscription des pins pour brancher l'Arduino nano dans le bon sens (port usb vers l'extérieur du shield).

  1. Branchement du capteur à ultrasons (se référer au schéma du dessus) :

     2. Branchement des Servomoteurs RC 360° (se référer au schéma du dessus) :

Ainsi le servo qui est sur la broche 10 sera notre roue droite et le Servo sur la pin 11 sera notre roue gauche.  

image.png

Etape 3 : Montage du shield

Fixer le shield à la base du LittleBot avec 2 vis.

image.png

Etape 4 : Fixation des roues

Mettre les palonniers dans les roues.

image.png

Puis fixer les roues sur les servomoteurs.

image.png   rKQimage.png

Etape 5 : Finalisation du LittleBot

Mettre la batterie comme sur l'image ci-dessous et ne pas oublier de passer le câble dans le trou de la tête.

image.png

Placer le capteur ultrasons dans le tête du LittleBot

image.png

Placer la tête du LittleBot sur la base.

image.png

Passons maintenant à la programmation sur la prochaine page.

Club Robotique - LittleBot

Programmation Littlebot

Le Programme en Mblock :

Objectifs :

Le robot doit tout le temps avancer sauf si il rencontre un obstacle à moins de 10 cm il doit reculer puis tourner vers la gauche.

Tout d'abord, ajouter les extensions que nous auront besoin, dans la barre des extensions taper "ultrasons" et ajouter l'extension (il y en aura que une) et pour la 2ème extension la voici servo.mext (cliquez dessus pour télécharger le fichier et faire un glisser-déposer du fichier sur Mblock pour importer l'extension).

Dès que les 2 extensions sont installées on peut commencer à programmer.

Mettre le bloc d'évènement pour pouvoir jouer le code.

image.png

Ensuite mettre le bloc "pour toujours" pour faire une boucle infinie.

image.png

Mettre le bloc de conditions "si ... alors ...".

image.png

Maintenant on va réaliser la condition.

image.png

Ne pas oublier d'initialiser notre capteur de distance et de calculer la distance en continue.

image.png

Maintenant si la condition est correct alors il doit d'abord reculer puis tourner à gauche.

Les valeurs 100 et -100 sont les vitesse maximale dans un sens différent.

image.png

Rajouter les 2 dernier blocs pour que si la condition n'est pas réalisée le robot avance.

image.png

Programmation sur Arduino IDE :

Ici nous décomposerons notre programme pour bien l'écrire. 

Tout d'abord, nous déclarons la librairie et les servomoteurs que nous utiliserons :

#include <Servo.h> // Inclusion de la bibliothèque Servo pour contrôler les servomoteurs
#define trigPin 6 // Attribution des pins du capteur à ultrasons
#define echoPin 7 // Attribution des pins du capteur à ultrasons
Servo servo1;  // Déclaration du premier servomoteur
Servo servo2;  // Déclaration du second servomoteur

Puis nous déclarons sur quelles pins sont branchés notre capteur et nos servomoteurs :

void setup() {
pinMode(trigPin, OUTPUT); // Configure la broche trigPin (6) en sortie 
pinMode(echoPin, INPUT); // Configure la broche echoPin (7) en entrée 
servo1.attach(11); // Attribution de la broche 11 au premier servomoteur 
servo2.attach(10); // Attribution de la broche 10 au deuxieme servomoteur 
}

Rentrons dans le vif 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; // Nous déclarons notre variable que nous retrouverons plus tard
// Envoie une impulsion courte pour déclencher le capteur ultrasonique
digitalWrite(trigPin, LOW); 
delayMicroseconds(2);         
digitalWrite(trigPin, HIGH);  // Début de l’impulsion
delayMicroseconds(10);        // Durée de l’impulsion (10µs)
digitalWrite(trigPin, LOW);   // Fin de l’impulsion
// Mesure du temps entre l’émission et la réception de l’onde sonore
duration = pulseIn(echoPin, HIGH);
// Conversion de la durée en distance (en cm)
distance = (duration*0.034) / 2;
// Si un obstacle est détecté à moins de 20 cm
if (distance < 20) {
  // Mouvement 1 : envoie d'un signal d'une durée 1000 µs à servo1, envoie d'un signal d'une durée 2000 µs à servo2
  servo2.writeMicroseconds(1000);
  servo2.writeMicroseconds(2000);
  delay (2000); // Attend 2 secondes
  // Mouvement 2 : servo1 reste dans sa position, envoie d'un signal d'une durée de 1500 us à servo2
  servo1.writeMicroseconds(1000);
  servo2.writeMicroseconds(1500);
  delay (2000);// Attend 2 secondes
}

else {
 // Si aucun obstacle détecté on avance normalement
 servo1.writeMicroseconds(2000);
 servo2.writeMicroseconds(1000);
 delay (2000);
}
}
}

      

Club Robotique - LittleBot

Animation LittleBot (2h30)

🤖 Introduction au projet – Le LittleBot

🎯 Qu’est-ce que le LittleBot ?

Le LittleBot est un petit robot éducatif que tu peux programmer toi-même !
Il est équipé de :

🧠 À quoi sert ce projet ?

Ce projet te permet de découvrir la robotique et la programmation en t’amusant.
Tu vas apprendre à :

  1. Programmer le robot avec des blocs dans mBlock (comme des LEGO numériques),

  2. Contrôler les roues du robot,

  3. Utiliser un capteur pour éviter les obstacles,

  4. Faire un robot autonome, comme un vrai petit véhicule intelligent !

🟨 Étape 1 – Découverte de mBlock

🧩 1. Présentation de mBlock

mBlock est un logiciel de programmation qui utilise des blocs colorés qu’on assemble comme des briques de LEGO.
Il est basé sur Scratch, mais adapté pour programmer des robots comme le LittleBot.

image.png

1) Appareil que nous programmons, ici nous sommes avec un Arduino nano

2) Catégorie de bloc de programmation

3) Bloc de programmation (à glisser dans l'interface de dépôt de bloc pour la programmation)

4) Interface de dépôt de bloc pour la programmation 


🟩 Étape 2 – Qu’est-ce qu’un Arduino Nano ?

🧠 C’est quoi un Arduino Nano ?

Un Arduino Nano est une petite carte électronique :

image.png

C’est le « cerveau » du robot.

Il reçoit des instructions depuis l’ordinateur (grâce à mBlock), et il contrôle les moteurs et les capteurs du robot…
Dans le LittleBot, l’Arduino Nano permet de :

🧠 On peut dire que tu écris un programme avec mBlock et que l’Arduino le suit à la lettre.

🟦 Étape 3 – Qu’est-ce qu’un servomoteur RC 360° ?

🔄 Qu’est-ce qu’un servomoteur RC 360° ?

Un servomoteur RC 360° (ou « continu ») est un petit moteur qui peut tourner en continu dans les deux sens (comme une roue), contrairement aux servos classiques qui ne tournent que sur un angle limité (en général 180° maximum).

⚙️ À quoi ça sert dans un robot comme le LittleBot ?

Dans le LittleBot, ces servos sont utilisés pour faire tourner les roues du robot. En envoyant des signaux différents, on peut :

🎛️ Comment on contrôle la vitesse et le sens ?

Pour commencer un programme, on commence toujours par le bloc 'lorsque Arduino démarre'

image.png

Ensuite, on va indiquer à l'Arduino nano que l'on veut que notre programme fonctionne tout le temps grâce au bloc 'pour toujours' dans la catégorie 'Contrôle'.

image.png

Et maintenant, nous allons faire fonctionner notre servomoteur. Allez dans la catégorie 'Servo360' et prendre le bloc 'servo 9 tourne à 0'.

image.png

Comment fonctionne ce bloc ? 

image.png

        Numéro de broche                        vitesse du servomoteur, dans un sens entre [-100 et 0[ et dans l'autre entre ]0 et 100]). A 0 on est donc à l'arrêt

Attention ce bloc ne contrôle qu'un seul moteur, nos servomoteurs sont branchés sur les broches numéros 10 et 9.

Comment téléverser le code dans l'arduino nano?

image.png

Sélectionner un appareil disponibles, si le programme ne se téléverse pas vous n'aurez cas vous déconnecter de l'appareil que vous avez choisis et essayer avec un autre. Cliquer sur 'Connecter' puis 'Télécharger le code'.

image.pngimage.png

Chaque exercice est à faire valider par un animateur

Exercice n°1 :

Faire bouger les deux servomoteurs

Exercice n°2 :

Faire bouger les deux servomoteurs dans le même sens afin que le robot aille vers l'avant

Exercice n°3 :

Faire avancer le robot pendant quelques secondes, et le faire faire revenir.

🛑 Étape 4 : Détecter un obstacle avec le capteur à ultrasons

📡 Qu’est-ce qu’un capteur à ultrasons ?

Le capteur à ultrasons permet au robot de "voir" ce qu’il y a devant lui… sans yeux 👀 !

🟠 Il envoie un son très aigu (inaudible pour nous) et mesure le temps que met l’écho à revenir.

👉 Plus l’écho revient vite, plus l’objet est proche.
👉 Plus il met du temps, plus l’objet est loin.

Dans un premier temps nous allons apprendre à utiliser le capteur à ultrasons.

Allez faire un tour sur cette page ! : (ne pas réaliser la partie câblage ni le code en C avec arduino IDE)

https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-quun-capteur-a-ultrasons

Maintenant que vous savez utilisez le capteur à ultrasons, passons à la suite.

 

Nouveaux blocs utilisables : 

- Les conditions : 

🧠 Les blocs de condition permettent au robot de prendre des décisions.

Comme dans la vie de tous les jours :

👉 "S’il pleut, je prends mon parapluie."

En programmation, c’est pareil :

👉 "Si un obstacle est devant moi, je m’arrête."

image.png

 

- Les opérations :

🧠 Les blocs d’opérations servent à faire des calculs ou des comparaisons.

image.pngimage.png

A vous de choisir les blocs les plus pertinents et les essayer ! N'oubliez pas tout les blocs que vous avez vue depuis le début de l'animation !

 

Exercice n°4 :

Programmer le Littlebot pour faire en sorte qu'il s'arrête lorsqu'il croise un obstacle à moins de 10 cm de lui

🚗 Étape 5 : Esquiver un obstacle

Exercice n°5 :

Maintenant que le Littlebot arrive à s'arrêter lorsqu'il croise un obstacle, faites en sorte qu'il l'esquive comme le ferait un robot aspirateur!

Club Robotique - Poubelle à couvercle automatique

Club Robotique - Poubelle à couvercle automatique

Description du projet

Introduction

Pour ce cycle, nous allons réalisée une poubelle avec une ouverture de couvercle automatique.

1745939032116 (1).jpg

Description des compétences visées :

Compétences techniques et mécaniques :

Compétences en électronique :

Compétences en programmation :

Compétences transversales :

Description du programme des séances :

~6 séances :

Matériel :

Club Robotique - Poubelle à couvercle automatique

Modélisation en 3D du couvercle

Avant de commencer à modéliser en 3D notre pièce, veuillez consulter les pages suivantes :

Commençons à modéliser en 3D le couvercle de la poubelle à couvercle automatique.

1746535678208 (1).jpg

Préparation de l’environnement

Créer une classe sur Tinkercad et faire rejoindre tous les élèves.

Comment créer une classe sur tinkercad : 

https://innovation.iha.unistra.fr/books/2-fablab-formation-machines-logiciels/page/creation-dune-classe-tinkercad

Réaliser un pavé droit de dimension : 

1.PNG

Réaliser deux pavés droits de dimensions :

Les placer avec un espacement de 43 mm entre eux, les sélectionner et les regrouper (CTRL+G).

2.PNG

Center les deux pavés droits la base du couvercle comme l'image ci-dessous à gauche et aligner manuellement les pavés droit à la base comme l'image ci-dessous à droite et regrouper le tout (CTRL+G)

Astuce : afin d'aligner le tout plus facilement, vous pouvez rendre "Inactif" la "Grille D'accrochage" en bas à droite de l'interface de Tinkercad.

4.PNG5.PNG

Réaliser un pavé droit de dimension : 

L'aligner manuellement avec une des charnières de la réalisation précédente. 

6.PNG7.PNG

Faire de même pour l'autre coté.

9.PNG

Réaliser un cylindre de dimension :

Et le centrer avec l'outil aligner par rapport à la pièce réalisée précédemment. 

8.PNG

Le centrer maintenant par rapport à cette partie de la pièce (voir photo ci-dessous à gauche) et le surélever (avec la flèche noir entourée en rouge sur la photo ci-dessous à doite) de 3 mm. A présent, sélectionner le tout et les assembler.

11.PNG12.PNG

Club Robotique - Poubelle à couvercle automatique

Fonctionnement et programmation des composants

Objectif :

Comprendre le fonctionnement des composants du projet et apprendre à les programmer

 

1. Introduction à l'Arduino Nano 

Qu'est-ce qu'un Arduino ?

https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-que-larduino

2. Capteur à ultrasons HC-SR04 

Qu'est ce qu'un capteur à ultrason et comment il fonctionne ?

https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-quun-capteur-a-ultrasons

3. Servomoteur SG90 180° 

Qu'est ce qu'un servomoteur et comment il fonctionne ?

https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-quun-servo-moteur

Explication du câblage complet 

Maintenant que nous avons vu chaque composant individuellement, voici un résumé du câblage complet :

  1. Capteur à ultrasons (HC-SR04) :

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

  2. Servomoteur :

    • VCC (fil rouge) → 5V de l’Arduino
    • GND (fil noir) → GND de l’Arduino
    • Signal (fil jaune) → D12 de l’Arduino

Conclusion et exercices pratiques 

Synthèse :

Exercice pratique :

Pour terminer la séance, les participants peuvent reproduire le câblage décrit ci-dessus sur leur propre montage.

Correction de L'exercice :

image.png

Code à utiliser : Le code sera introduit dans la prochaine séance, mais vous pouvez donner un aperçu du fonctionnement et les amener à réfléchir sur la façon dont les composants vont interagir ensemble.

Club Robotique - Poubelle à couvercle automatique

Assemblage et programmation de la poubelle à couvercle automatique

1. Utilisation du capteur à ultrasons HC-SR04 

Objectif :

Gestion et programmation des capteurs/actionneurs de la poubelle à couvercle automatique dans son ensemble.  

Assemblage :

Le modèle 3D de la poubelle à imprimer en 3D ce trouve en pièce jointe du wiki

Positionner les capteurs de la même façon que sur les photos ci-dessous.

1746451665438.jpg 1746451665443.jpg1746451665429.jpg

Câblage :

Vous référez à la page précédente . Voici un résumé :

Programmation final :

Programmation par bloc avec Mblock :

Demander aux élèves de réaliser le code final tout en les aidants si besoin. Voici le code final :

Code_final_Mblock.PNG

Programmation avec arduino IDE :

En fonction du niveau, demander aux élèves d'écrire ou de copier le code suivant tout en expliquant ce dernier.

#include <Servo.h> // Inclure la bibliothèque Servo

// Déclaration des pins
const int trigPin = 9;
const int echoPin = 10;
Servo myServo;

void setup() {
  Serial.begin(9600); // Initialiser la communication série
  pinMode(trigPin, OUTPUT); // Définir le trigPin comme sortie
  pinMode(echoPin, INPUT);  // Définir l'echoPin comme entrée
  myServo.attach(6); // Attacher le servomoteur à la pin D6
  myServo.write(0); // Position initiale à 0 degrés
}

void loop() {
  // Envoyer un signal
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Lire la durée du signal de retour
  long duration = pulseIn(echoPin, HIGH);
  int distance = duration * 0.034 / 2; // Calculer la distance

  // Afficher la distance dans le moniteur série
  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  // Si la distance est inférieure à 5 cm, déplacer le servomoteur
  if (distance < 5) {
    myServo.write(140); // Positionner le servomoteur à 180 degrés
    delay(1000); // Attendre 1 seconde
    myServo.write(0); // Retourner à 0 degrés
  }

  delay(500); // Attendre un peu avant la prochaine mesure
}

Conclusion et discussion 

Synthèse des compétences acquises :

Compétences techniques et mécaniques :

Compétences en électronique :

Compétences en programmation :

Compétences transversales :

Perspectives :

Projet similaire

https://www.hackster.io/FANUEL_CONRAD/automatic-soap-dispenser-75abd6

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

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

Description du projet

Introduction

Pour ce cycle, nous allons réalisée une station de mesure de température de l'air.


Description des compétences visées :

Compétences techniques et mécaniques :

Compétences en électronique :

Compétences en programmation :

Compétences transversales :

Description du déroulé des séances :

~6 séances :

Matériel :

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

Modélisation et impression en 3D de la boîte de la station

Création d'un boite pour la station

La station d'analyse de l'air ne possède pas de boite pour contenir ni fixer les composants électroniques, c'est pour ca que je vais vous décrire comment la réalisée. 

Objectif (en deux séances)

L’objectif est de réussir à modéliser la boite de la station qui va contenir tout nos composants électronique et à apprendre à utiliser une imprimante 3D pour imprimer cette dernière.

Ressources disponibles

Vous pouvez retrouver le fichiers STL de la boite dans les fichiers en pièce jointe.

Avant de commencer la modification, je vous invite à consulter si vous n'êtes pas à l'aise avec tinkercad :

1. Modélisation 3D 

Une fois la classe créée sur Tinkercad , avec le fichier de référence correctement chargé, et que tous les élèves sont connectés, nous pouvons passer à la phase de modification.

Comment créer une classe sur tinkercad : 

https://innovation.iha.unistra.fr/books/2-fablab-formation-machines-logiciels/page/creation-dune-classe-tinkercad

Sur l’interface principale de Tinkercad :

      1. Création du Boîtier Principal:

    Création des trou pour les vis :

    Création du trou pour le Capteur :

    Création du trou pour l'afficheur :

    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 (ne pas oublier de cliquer sur le cylindre), puis les modifier pour avoir les mêmes que sur l'image :

    image.png

    Conception du Capot :

    Ajustements Finaux :

    Validation et Export :

    3. Impression 3D

    Afin de comprendre de qu'est l'impression 3D vous pouvez visiter les pages présente dans la catégorie suivante :

    https://innovation.iha.unistra.fr/books/2-fablab-formation-machines-logiciels/chapter/impression-3d-fdm

    Et pour savoir comment lancer une impression sur l'une de nos machines, veuillez vous référer à la page suivante : 

    https://innovation.iha.unistra.fr/books/2-fablab-formation-machines-logiciels/page/lancer-une-impression-avec-bambu-studio

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

      Phase 2 - Impression 3D

      Phase 2 - Impression 3D

      Objectifs :

      Compétences techniques :

      Savoir-être et compétences transversales :

      Déroulement de la séance :

      1.Exportation de la boite :

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

      Conclusion / Rangement :

      Dans cette phase, les participants vont apprendre à préparer leur modèle 3D pour l'impression en utilisant le logiciel Cura. Ils vont importer leur fichier STL, ajuster les paramètres d'impression, générer le code pour l'imprimante 3D et exporter le fichier prêt pour l'impression. Si des questions se posent ou si vous avez besoin de plus d'informations, n'hésitez pas à demander !

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

      Fonctionnement et programmation des composants

      -------------------------- Début de la nouvelle page

      Objectif :

      Comprendre le fonctionnement des composants du projet et apprendre à les programmer

      1. Introduction à l'Arduino Nano 

      Qu'est-ce qu'un Arduino ?

      https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-que-larduino

      2. Capteur de température et d'humidité (DHT22)

      Qu'est ce qu'un capteur de température et d'humidité (DHT22) et comment il fonctionne ?

      https://innovation.iha.unistra.fr/books/robotique-educative/page/fonctionnement-et-programmation-du-capteur-de-temperature-et-dhumidite-dht22/edit

       

      3. Ecran OLED 

      Qu'est ce qu'un écran OLED et comment il fonctionne ?

      -------------------------- page de base en dessous

      Objectifs

      Compétences techniques:

      Déroulement de la séance

      1. Introduction:

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

      2. Programmation:

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

          image.png

        •  

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

        • image.png

        • Avant de téléverser le code n'oubliez pas de décocher ces 2 cases ci-dessous qui se situe dans le moniteur série.

        •  

          image.png

        • Pour la suite nous allons passer sur le logiciel "Arduino IDE" car il nous offre plus de possibilités.
        • Dans un premier temps télécharger la librairie Arduino DHT de Adafruit https://www.arduino.cc/reference/en/libraries/dht-sensor-library/ 
          • bien installer la dépendance Adafruit Unified Sensor

      image.png

      #include <SoftwareSerial.h>
#include <DHT.h>
#include <EEPROM.h>

#define DHTPIN 9
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

const int EEPROM_SIZE = 512;          // Taille de l'EEPROM en octets
const int ENTRY_SIZE = sizeof(float) * 2; // Taille d'une entrée (température + humidité)
const int NUM_ENTRIES = EEPROM_SIZE / ENTRY_SIZE; // Nombre total d'entrées possibles

int currentAddress = 0; // Adresse actuelle pour stocker
bool storageFull = false; // Indique si l'EEPROM est pleine

unsigned long previousMillis = 0; // Dernier temps de stockage
const unsigned long interval = 3600000; // Intervalle d'une heure (en millisecondes)

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

void loop() {
  unsigned long currentMillis = millis();

  // Vérifie si une heure s'est écoulée
  if (!storageFull && currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    // Lecture des données du capteur
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

    if (!isnan(temperature) && !isnan(humidity)) {
      // Vérifie si suffisamment d'espace reste dans l'EEPROM
      if (currentAddress + ENTRY_SIZE <= EEPROM_SIZE) {
        // Stocker la température
        EEPROM.put(currentAddress, temperature);
        currentAddress += sizeof(float);

        // Stocker l'humidité
        EEPROM.put(currentAddress, humidity);
        currentAddress += sizeof(float);

        // Affichage des données
        Serial.print("Données stockées à l'adresse ");
        Serial.print(currentAddress - ENTRY_SIZE);
        Serial.print(": Température = ");
        Serial.print(temperature);
        Serial.print(" °C, Humidité = ");
        Serial.println(humidity);
      } else {
        storageFull = true; // Indiquer que l'EEPROM est pleine
        Serial.println("EEPROM pleine. Arrêt du stockage.");
      }
    } else {
      Serial.println("Erreur de lecture du capteur DHT22.");
    }
  }
}

                   3. Validation:

                   4. Conclusion:

      Résolution de problèmes

      image.png

      image.png

      image.png

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

      Phase 4 - Mesure et Analyse des Données de Température avec le Capteur DHT22

      Phase 4 - Mesure et Analyse des Données de Température avec le Capteur DHT22

      Objectifs de la séance :

      Compétences techniques :

      Savoir-être :

      Compétences transversales :

      Déroulement de la séance :

      1. Introduction

        • Présentation des objectifs de la séance.
        • Rappel du fonctionnement du capteur DHT22 et de l'Arduino Nano.
        • Explication des points de mesure : définir les différents endroits où seront placées les stations (intérieur, extérieur, pièces fermées, etc.).

      2. Installation des stations de mesure

        • Mise en place des stations avec le capteur DHT22 à différents endroits prédéfinis.
        • Vérification de la connectivité et du bon fonctionnement de chaque station.
        • Lancement de la collecte des données (durée de mesure à définir : quelques heures ou une journée complète).

      3. Collecte des données

        • Chaque participant vérifie régulièrement les stations et enregistre les données (extraction via l’Arduino).
        • Récupération des température via l'Arduino IDE, puis exportation sur Excel ou Open Office.

           

          image.png

          image.png


           

        • Pour récupérer les température facilement il y a cette formule =DROITE(GAUCHE(A1; NBCAR(A1)-23); 5).
        • Pour récupérer la valeur de l'humidité vous pouvez utiliser cette formule =DROITE(GAUCHE(A1; NBCAR(A1)-2); 5) si vous avez collez votre texte dans la case A1, ensuite si vous êtes sur Exel n'oubliez pas de les convertir en valeurs.
        • image.png
        • Attention si vous êtes sur Libre Office, il faut copier vos valeur puis les coller en "collage spécial" et ensuite sur "Texte non formaté".

          image.png


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

      4. Analyse des données sur Excel

        • Importation des données dans Excel ou Libre Office.
        • Structuration des informations sous forme de tableau.
        • Création des graphiques : courbes de tendance pour visualiser les écarts de température selon les points de mesure.

        • Pour créer un graphique sur Excel sélectionnez votre tableau et allez dans "Insertion" puis "Graphiques Recommandés".

        • Sur Libre Office sélectionnez vos valeurs puis allez dans "Insertion", "Diagrammes", "Ligne", et prenez le 2ème.

          image.png


        • Après avoir obtenue l'image ci-dessus, faites un clic droit sur le graphique et ensuite dans "plage de données" allez dans "séries de données".

        • image.png

        • Et vous avez juste à supprimer les données des heures.
        • Sur Excel n'oubliez pas de changer l'échelle des température en mettant la température la plus basse à 0.
        • Analyse des résultats : interpréter les différences entre les différents points de mesure.
        • Faire la même chose pour l'humidité.

      5. Conclusion et échanges

        • Chaque participant présente ses résultats sous forme de graphiques.
        • Discussion autour des facteurs qui peuvent influencer les écarts de température (environnement, exposition au soleil, ventilation, etc.).
        • Synthèse des principaux apprentissages de la séance.

      Club Robotique - Voiture RC

      Club Robotique - Voiture RC

      Description du projet

      Introduction

      Pour ce cycle, nous allons créer une voiture contrôlable avec notre smartphone

      Compétences techniques et mécaniques
      Compétences en électronique
      Compétences en programmation
      Compétences transversales

      Description du déroulé des séances:

      ~9 séances :

      Matériel

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

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

      Code voiture RC

      image.png

      //source Sample Code 2 https://wiki.dfrobot.com/Micro_DC_Motor_with_Encoder-SJ01_SKU__FIT0450#target_3
//The sample code for driving one way motor encoder
#include <PID_v1.h>
const byte encoder0pinA = 0;//A pin -> the interrupt pin 0
const byte encoder0pinB = 1;//B pin -> the digital pin 3
const byte encoder0pinA_2 = 8;//A pin -> the interrupt pin 0
const byte encoder0pinB_2 = 9;//B pin -> the digital pin 3
// int E_left =5; //The enabling of L298PDC motor driver board connection to the digital interface port 5
// int M_left =4; //The enabling of L298PDC motor driver board connection to the digital interface port 4
int MOTEUR_A_1 =12; //Connexion du pilote de moteur CC l9110s au port digital 5
int MOTEUR_A_2 =13; //Connexion du pilote de moteur CC l9110s au port digital 6
int MOTEUR_B_1 =10; //Connexion du pilote de moteur CC l9110s au port digital 5
int MOTEUR_B_2 =11; //Connexion du pilote de moteur CC l9110s au port digital 6
byte encoder0PinALast;
double duration,abs_duration;//the number of the pulses
boolean Direction;//the rotation direction
boolean result;

double val_output;//Power supplied to the motor PWM value.
double Setpoint;
double Kp=0.6, Ki=5, Kd=0;
PID myPID(&abs_duration, &val_output, &Setpoint, Kp, Ki, Kd, DIRECT);

#include <Servo.h>
#define trigPin 6
#define echoPin 7
// #define EncoderInit
Servo servo1;
Servo servo2;
Servo monServo;

//Le port série matériel de l'Arduino Nano (Pins 0/RX et 1/TX) est déjà utilisé pour la liaison Arduino-USB avec l'ordinateur
//On utilise donc une liaison série logicielle pour la liaison Arduino-HC05 avec le module Bluetooth
#include <SoftwareSerial.h>  //Software Serial Port  
#define RxDpin 2    //Pin Digital 2 pour arduino Rx (pin0=serial) 
#define TxDpin 3    //Pin Digital 3 pour arduino Tx (pin1)
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut configurer le HC-05
//on maintient le bouton à côté de la PIN EN/KEY enfoncé au démarrage de l'Arduino
// #define baudrate 38400 //Vitesse pour la liaion Arduino-HC05 en mode configuration
//Pour la liaison SoftwareSerial Arduino-HC05, quand on veut communiquer à travers le bluetooth depuis un smartphone,
//on appaire le HC-05 depuis l'appli avec le mot-de-passe par défaut : 1234
#define baudrate 9600
#include <Servo.h>
Servo myservo;  // create servo object to control a servo 


SoftwareSerial BTSerie(RxDpin,TxDpin); 

char caractereTexte;
String phraseTexte;

void setup()
{
  Serial.begin(9600);//Initialize the serial port
   pinMode(MOTEUR_A_1, OUTPUT);   //L298P Control port settings DC motor driver board for the output mode
   pinMode(MOTEUR_A_2, OUTPUT);
   pinMode(MOTEUR_B_1, OUTPUT);   //L298P Control port settings DC motor driver board for the output mode
   pinMode(MOTEUR_B_2, OUTPUT);   
   Setpoint =80;  //Set the output value of the PID
   myPID.SetMode(AUTOMATIC);//PID is set to automatic mode
   myPID.SetSampleTime(100);//Set PID sampling frequency is 100ms
  EncoderInit();//Initialize the module

pinMode(RxDpin, INPUT);   //Configuration du Pin RxD (Receive) en mode entrée
pinMode(TxDpin, OUTPUT);  //Configuration du Pin TxD (Transmit) en mode sortie
BTSerie.begin(baudrate); 
// Commandes AT pour le HC-05
// BTSerie.print("AT+NAME?");  //Demande le nom du module. Noter le ?
// BTSerie.print("AT+NAME=RCcar-HC-05-1");  //Définir le nom du module.
BTSerie.print("AT+VERSION?");  //Demande le N° de version. Noter le ?
// BTSerie.print("AT+UART?");  //Demande la vitesse série (baudrate). Noter le ?
// BTSerie.print("AT+UART=57600,0,0");  //Définir la vitesse série (baudrate).
// BTSerie.print("AT+ROLE?");  //Demande le mode du module, maitre ou esclave. Noter le ?
// BTSerie.print("AT+PSWD?");  //Demande le mot-de-passe du module. Noter le ?
// La console série de l'ordinateur d'où l'on envoie les commandes AT doit être réglée de telle sorte que 
// les fins de ligne soient « les deux, NL et CR », ce qui revient à envoyer \r\n à la fin de chaque commande.
BTSerie.print("\r\n");     // sur HC-05, toutes les commandes doivent se terminer par \r\n
// afficher ce que le module bluetooth répond
  Serial.print( BTSerie.read() );     // afficher sur la console ce qui est lu sur BT
// pour AT+VERSION?, c'est le n° de version puis OK qui s'affiche

if (baudrate==38400) {
  Serial.println("En mode communication USB - Pret pour les commandes AT");
  Serial.println("Le HC-05 doit clignoter lentement (2 secondes)");
}
else if (baudrate==9600){
  Serial.println("En mode smartphone - Pret pour être appairé");
  Serial.println("Le HC-05 doit clignoter rapidement avant d'être appairé");
}
else{
  Serial.println("La vitesse de communication (baudrate) a été personnalisée");
}
monServo.attach(5);
delay(500);

pinMode(13,OUTPUT);   //left motors forward
pinMode(12,OUTPUT);   //left motors reverse
pinMode(11,OUTPUT);   //right motors forward
pinMode(10,OUTPUT);   //right motors reverse
pinMode(9,OUTPUT);   //Led
pinMode(5,OUTPUT);   //SG90 steering motor
  // A COMPLETER pour le servo //
//myservo.attach(5);  // attaches the servo on pin 5 to the servo object
}
 

void loop()
{

  //On lit caractere par caractere sur la liaion Arduino-HC05 et on affiche sur la liaison Arduino-USB
  if (BTSerie.available()) {  
    caractereTexte = BTSerie.read();  
    Serial.print(caractereTexte);  
  }  

//On lit caractere par caractere sur la liaion Arduino-USB et on affiche sur la liaison Arduino-HC05
  if (Serial.available()) {  
    caractereTexte = Serial.read();  
    BTSerie.write(caractereTexte); 
    // Serial.println("Caractere envoye vers bluetooth : ");  
    // Serial.println(caractereRecu);  
  // }  

if(caractereTexte == 'F'){            //move forward(all motors rotate in forward direction)
  advance();//Motor Forward
  monServo.write(90);                  // sets the servo position according to the scaled value
}
 
else if(caractereTexte == 'B'){      //move reverse (all motors rotate in reverse direction)
  back();//Motor reverse
  monServo.write(90);                  // sets the servo position according to the scaled value 
}
 
else if(caractereTexte == 'L'){      //turn right (left side motors rotate in forward direction, right side motors doesn'caractereRecu rotate)
  left();
  monServo.write(60);                  // sets the servo position according to the scaled value
}
 
else if(caractereTexte == 'R'){      //turn left (right side motors rotate in forward direction, left side motors doesn'caractereRecu rotate)
  right();
  monServo.write(120);                  // sets the servo position according to the scaled value
}

 
else if(caractereTexte == 'S'){      //STOP (all motors stop)
  Stop();
  monServo.write(90); 
}
abs_duration=abs(duration);
      result=myPID.Compute();//PID conversion is complete and returns 1
      if(result)
      {
        Serial.print("Pluse: ");
        Serial.println(duration);
        duration = 0; //Count clear, wait for the next count
      }              // sets the servo position according to the scaled value
}
}
void EncoderInit()
{
  Direction = true;//default -> Forward
  pinMode(encoder0pinB,INPUT);
  attachInterrupt(0, wheelSpeed, CHANGE);
}

void wheelSpeed()
{
  int Lstate = digitalRead(encoder0pinA);
  if((encoder0PinALast == LOW) && Lstate==HIGH)
  {
    int val = digitalRead(encoder0pinB);
    if(val == LOW && Direction)
    {
      Direction = false; //Reverse
    }
    else if(val == HIGH && !Direction)
    {
      Direction = true;  //Forward
    }
  }
  encoder0PinALast = Lstate;

  if(!Direction)  duration++;
  else  duration--;

}
void advance()//Motor Forward
{
     digitalWrite(MOTEUR_A_1,LOW);
     digitalWrite(MOTEUR_A_2,val_output);
     digitalWrite(MOTEUR_B_1,val_output);
     digitalWrite(MOTEUR_B_2,LOW);     
}
void back()//Motor reverse
{
     digitalWrite(MOTEUR_A_1,val_output);
     digitalWrite(MOTEUR_A_2,LOW);
     digitalWrite(MOTEUR_B_1,LOW);
     digitalWrite(MOTEUR_B_2,val_output);

}
void left()
{
     digitalWrite(MOTEUR_A_1,LOW);
     digitalWrite(MOTEUR_A_2,val_output);
     digitalWrite(MOTEUR_B_1,LOW);
     digitalWrite(MOTEUR_B_2,LOW);  
}
void right()
{
     digitalWrite(MOTEUR_A_1,LOW);
     digitalWrite(MOTEUR_A_2,LOW);
     digitalWrite(MOTEUR_B_1,val_output);
     digitalWrite(MOTEUR_B_2,LOW);
}

void Stop()//Motor stops
{
     digitalWrite(MOTEUR_A_1, LOW);
     digitalWrite(MOTEUR_A_2, LOW);
     digitalWrite(MOTEUR_B_1, LOW);
     digitalWrite(MOTEUR_B_2, LOW);
}

      Club Robotique - Bras Robotique

      Club Robotique - Bras Robotique

      Phase 1 - Robot 4 DDL à parallélogramme ARM.UNO

      Capture d’écran 2025-01-16 105824.png

      Club Robotique - Bras Robotique

      Phase 2 - Assemblage des pièces

      Phase 1 - Assemblage des pièces

      Objectifs pédagogiques

      Compétences techniques visées

      Savoir être (compétences comportementales)

      Compétences transversales

      Montage du bras robotique :

      FICHE DE RÉFÉRENCE RAPIDE DES PARTIES STRUCTURELLES :

      image.png

      image.png

                                             

      Montage de la Base :

      Capture d’écran 2025-01-14 115314.png

      Matériel nécessaire :

      Capture d’écran 2025-01-14 115635.png

      Etape 1 :

      Capture d’écran 2025-01-14 115928.png

      Fixez d'abord un palonnier double face à l'aide des petites vis fournies avec les servomoteurs.
      Faites attention à l'orientation des pièces. Notez la petite flèche gravée sur la pièce, qui pointe vers l'avant du bras. Positionnez le palonnier comme indiqué, puis retournez les deux pièces et fixez les deux petites vis.
      Positionnez toujours les vis à mi-distance ou plus loin du moyeu central du palonnier. Cela permet d'éviter une éventuelle interférence entre les têtes des vis et certains boîtiers de servomoteurs.

      Etape 2 :
      Capture d’écran 2025-01-14 140932.png

      SI LES ENCOCHES NE S'ALIGNENT PAS
      VÉRIFIEZ BIEN QUE LA PIÈCE EST ORIENTÉE COMME INDIQUÉ.
      NE FIXEZ PAS ENCORE LES ÉCROUS ET LES BOULONS.

      Etape 3 :

      image.png

      INSTALLEZ LA BARRE CENTRALE COMME INDIQUÉ.

      AVEC LE DERNIER CÔTÉ INSTALLÉ, IL NE RESTE PLUS QU'À FIXER LES BOULONS ET LES ÉCROUS.

      Capture d’écran 2025-01-14 141631.png

      Pour le coté Gauche :

      Capture d’écran 2025-01-14 141843.png

      image.png

      Placez le cercle du palonnier dans le trou correspondant du servomoteur.
      Retournez les deux pièces et fixez à nouveau la vis du palonnier vers l'extrémité la plus éloignée afin d'éviter d'éventuels problèmes de dégagement avec le boîtier du servomoteur.


      Capture d’écran 2025-01-14 142637.png

      Pour la suite quelques petite précisions, il faut bien faire la différence entre l'avant du servomoteur et l'arrière.

      Capture d’écran 2025-01-30 093130.png

      Pour fixer le palonnier sur le servomoteur il faut d'abord donner ce code via l'Arduino nano  pour connaître sa position 0.

      image.png

      Arrivé à la position 0 mettez le palonnier à l'horizontal vers l'avant du servomoteur.

      image.png

      Capture d’écran 2025-01-14 143030.png              QxVimage.png

      Coté droit :

      Matériel :

      Capture d’écran 2025-01-14 144431.png

      Pour le servomoteur du coté droit, dans un premier temps le mettre à la position 0, puis placer le palonnier à l'horizontal vers l'arrière.

      Capture d’écran 2025-01-30 093130.png

      Capture d’écran 2025-01-14 144655.png

      image.png

      ASSEMBLAGE DU SERVOMOTEUR DU CÔTÉ DROIT AVEC LA BASE :

      Capture d’écran 2025-01-14 145050.png image.png

      Matériel de l'assemblage de la poutre du lien supérieur :

      image.png

      Fixez la renfort de la poutre du lien supérieur comme indiqué ci dessous :

      image.png

      Capture d’écran 2025-01-14 145652.png

      Capture d’écran 2025-01-30 112310.png

                               Capture d’écran 2025-01-14 150331.png

      L'assemblage principal du bras est maintenant terminé et prêt à recevoir l'assemblage de la pince.

      Assemblage du servomoteur de la pince :

      Matériel nécessaire :

      Capture d’écran 2025-01-14 150549.png

      image.png

      Assemblage du reste de la pince :

      Matériel nécessaire :

      Capture d’écran 2025-01-14 152158.png

      Capture d’écran 2025-01-14 152430.png

      Mettre le servomoteur de la pince à la position 0 et mettre le palonnier à l'horizontal vers l'arrière.

      Capture d’écran 2025-01-30 093130.png

      Capture d’écran 2025-01-16 102542.png

      Montage de la pince sur le bras :

      Capture d’écran 2025-01-16 102859.png

      Fixer la pince au lien supérieur gauche du bras avec une vis de 3 mm x 10 mm. ne pas trop serrer, car les vis pourraient comprimer le boîtier du moteur servo, ce qui entraînerait le blocage du train d'engrenages.

      Capture d’écran 2025-01-16 104248.png

      Fixer le lien parallèle à la pince avec un écrou et une vis de 3 mm x 10 mm. Ajuster le serrage pour permettre un mouvement libre.

      assemblage de la base et du roulement :

      image.png


      Quand vous fixer le servomoteur mettez le à la position 90 puis vous avez juste à mettre votre bras robotique vers l'arrière à l'inverse de la dernière image.

      image.png

      Capture d’écran 2025-01-16 105824.png

      Vous pouvez rajouter les extensions de la pince avec les pièces 31 et 32 comme ci-dessus.

      Et voilà le montage de votre bras robotique est fini!!!

      Source : Armuno A1Hd -V0.5-Assembly-7-22-2015-copy

      Club Robotique - Bras Robotique

      Phase 3 - Programmation du bras robotique

      Cinématique d'un bras robot

      La cinématique est un domaine de la mécanique qui se concentre sur l’étude des mouvements. Ça tombe bien, le but d'un robot étant de bouger ! L'étude cinématique consiste donc à déterminer les positions, vitesses et accélérations des différentes parties d’un robot, sans prendre en compte les forces qui causent ces mouvements (puissance des moteurs par exemple). Un robot, souvent décrit comme une machine automatisée, peut effectuer des tâches complexes apportant une réelle valeur ajoutée dans divers secteurs.

      Notre robot a 4 moteurs, l'objectif est de les actionner pour :

      Les 4 moteurs contrôlent 4 mouvements possibles : 

      https://www.youtube.com/watch?v=xQkPjDEbFoU

      Attention chaque Servomoteur possède des positions maximums et minimums à bien respecter pour pas que ce dernier ne fonctionne plus.

      Voici un tableau qui regroupe ces valeurs si vous l'avez monter comme dans la phase 1 : 

      image.png

      Pour ouvrir et fermer la pince c'est donc facile, on actionne le moteur 4.

      Espace Cartésien : les mouvements de la pince et des objets

      Espace articulaire : les mouvements des moteurs

      La question principale qu'on se pose c'est comment actionner mes moteurs pour faire bouger ma pince comme je veux ? C'est le modèle cinématique inverse.

      On peut aussi se demander : si je bouge mes moteurs à telle position, quelle sera la position de ma pince ? C'est le modèle cinématique direct.

      Voici un code mblock qui permet de prendre un objet à une où le coude est à la position 140 et l'épaule à la position 150.

      Epaule : Pin 6

      Coude : Pin 9

      Base : Pin 3 

      Pince : Pin 13

      Partie 1 :

      image.png

      Partie 2 :

      image.png

      Code traduit en Arduino

      #include <Servo.h>

Servo monServo1;
Servo monServo2;  // Création de l'objet Servo
Servo monServo3;
Servo monServo4;


void setup() {
    monServo1.attach(3);
    monServo2.attach(6);
    monServo3.attach(9);
    monServo4.attach(13); // Attache le servomoteur à la broche définie

    monServo1.write(0);
    monServo2.write(90);
    monServo3.write(180);
    monServo4.write(90);
}

void loop() {

  delay(1000);
    // Balayage de 0° à 180°
    for (int angle =0; angle <= 90; angle++) {
        monServo1.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =180; angle >= 140; angle--) {
        monServo3.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =90; angle <= 150; angle++) {
        monServo2.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =90; angle <= 150; angle++) {
        monServo4.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =150; angle >= 90; angle--) {
        monServo2.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =140; angle <= 180; angle++) {
        monServo3.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =90; angle >= 0; angle--) {
        monServo1.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =180; angle >= 140; angle--) {
        monServo3.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =90; angle <= 150; angle++) {
        monServo2.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =150; angle >= 90; angle--) {
        monServo4.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =90; angle <= 150; angle++) {
        monServo4.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =150; angle >= 90; angle--) {
        monServo2.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);

    for (int angle =140; angle <= 180; angle++) {
        monServo3.write(angle); // Déplace le servo à l'angle spécifié
        delay(10); // Pause pour que le servo ait le temps de bouger
    }

    delay(1000);
}


      Sources

      Cinématique des robots série :

      https://howtomechatronics.com/tutorials/arduino/diy-arduino-robot-arm-with-smartphone-control/ 

      https://poppy.discourse.group/t/presentation-dun-travail-de-cinematique-2d-avec-le-robot-poppy-ergo-jr-1ere-s/2611 

      https://poppy.discourse.group/t/algorithme-de-cinematique-inverse-applique-a-poppy-inverse-kinematic-algorithm-applied-to-poppy/1582 

      https://learn.ros4.pro/fr/theory/ 

      https://files.ros4.pro/theorie.pdf 

      https://www.youtube.com/watch?v=vKD20BTkXhk 

      Robot série à parallélogramme : 

      https://www.youtube.com/watch?v=GnrRk9mWv7A 

      https://www.youtube.com/watch?v=xQkPjDEbFoU

      https://www.youtube.com/watch?v=Z7HWoh_MR1s

      https://drive.google.com/drive/folders/1zaOw2QcZatylyqQoVnYhIK7iysyCOY2d

      https://www.youtube.com/watch?v=Q9JOKQaIR1w

      Un peu complexe :

      https://eduscol.education.fr/sti/ressources_pedagogiques/analyse-et-performance-cinematique-dun-robot-bi-articule#fichiers-liens 

      https://eduscol.education.fr/sti/sites/eduscol.education.fr.sti/files/ressources/pedagogiques/14480/14480-1-robot-bi-articule-doc-ressource.pdf 

      Club Robotique - Plieur de Linge

      Club Robotique - Plieur de Linge

      Phase 1 - Conception du fichier 2D avec Inkscape

      Phase 1 - Conception 2D avec Inkscape

      Compétences techniques :

      Savoir-être, compétences transversales :

      Déroulement de la séance :

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

      Phases et méthodes d’animation :

      Prise en main du logiciel Inkscape :

      Présentation de l’Outil de Modélisation :

      Démonstration :

      Création du premier fichier de découpe :

      Création des volets du plieur de linge :

      1. Ouvrir Inkscape et créer un nouveau document.

      2. Définir la taille de la page en fonction du matériau utilisé ( ici une plaque de 600 mm x 300 mm).

      3. Utiliser l’outil rectangle pour créer le volet du plieur (370 mm x 150 mm).

        image.png

        image.png


      4. Aller dans "Fond et Contour" et enlever le fond, mettre le contour en rouge d'une épaisseur de 0,260 mm.

        image.png   image.png

         

      5. Ajouter un deuxième rectangle plus petit pour créer un contour extérieur (140 mm x 60 mm), puis utiliser la fonction "Union".

        image.png

        image.png

      Ajout des encoches et trous pour les Servomoteurs :

      1. Pour les encoches créer un rectangle de dimensions ( 3 mm x 10 mm ).

      2. Ensuite la dupliquer ( CTRL D ) et la déplacer avec les flèches du clavier.

      3. Résultat : 

        image.png


      Création des cales des volets :

      1. Créer un rectangle de 12 mm x 100 mm.
      2. Le placer comme ceci : 

        image.png

      3. Dupliquer les encoches et ensuite sélectionner le rectangle avec.
      4. Plus qu'à utiliser l'outil "Union".
      5. Pour surélever la cale on vient créer un autre rectangle de 16 mm x 35 mm et le placer comme l'image.

        image.png*

      6. Et pour le final utiliser l'outil "Union sur les 2 formes.

      Puis y placer un cercle de 2,9 mm x 2,9 mm.

      image.png

      Création des boites pour surélever les servomoteurs : 

      1. Aller sur boxes.py pour créer une "Basedbox" de 35 mm x 35 mm x 15 mm.

        image.png

      2. Ajouter cette boite au fichier et rajouter des trous de 2,9 mm sur la face du dessus.

        image.png

      3. Dupliquer la boite 3 fois pour en avoir 4 au total.

      Création du deuxième fichier de découpe :

      1. Faire un copier-coller du 1er volet sur le 1er fichier de découpe.

      Création de la partie du milieu :

      1. Créer un rectangle de 225 mm x 300 mm sans oublier d'enlever le fond et de mettre les contours en rouge.
      2. Créer un rectangle de 40 mm x 50 mm.
      3. Placer le rand rectangle en x = 0 et Y = 0 et le petit rectangle en x = 0 et y = 150.
      4. Sélectionner les 2 rectangle et réaliser une différence.

        image.png

      5. Pour les encoches du milieu, pointés ci-dessous faire comme pour les cales des volets ci-dessus.

        image.png


      6. Pour les encoches de cotés faire un carré de 30 mm x 250 mm et le placer à coté des encoches.
      7. Dupliquer les encoches et faire une union.
      8. Résultat :

        image.png

      Création du troisième fichier de découpe :

      1. Créer 2 rectangles de dimensions 370 mm x 150 mm, qui vont permettre à rallonger  les volets du plieur. 

      Ajustements Finaux :

      Validation et Export :

      Conclusion / Rangement / Démontage :

      Club Robotique - Robot Araignée

      Club Robotique - Robot Araignée

      Ressources

       

      Sélection de ressources sur la robotique éducative

      Arduino

      Club robotique - Maison connectée

      Club robotique - Maison connectée

      Description du projet

      Introduction

      Pour ce cycle, nous allons créer une maquette de maison connectée équipée de capteurs et d’objets contrôlables (lumières, température, buzzer, servomoteur, etc…), en utilisant une carte microcontrôleur ESP32 et divers composants électroniques.

      (Photo du projet)

      Description des compétences visées : 

      Compétences techniques et mécaniques
      Compétences en électronique
      Compétences en programmation
      Compétences transversales

      Description du déroulé des séances:

      ~9 séances :

       

      Matériel

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

      Club robotique - Maison connectée

      Fonctionnement et programmation des composants ( version Arduino )

      Qu'est ce qu'un ESP32 :

      https://innovation.iha.unistra.fr/books/robotique-educative/page/quest-ce-quun-esp32

      Découverte de Arduino IDE :

      L'objectif  est de comprendre l’environnement de développement Arduino IDE. Pour cela, rendez vous sûr la page suivante.

      https://innovation.iha.unistra.fr/books/robotique-educative/page/decouvre-arduino-ide-et-la-logique-dun-programme

      Le microcontrôleur que nous allons utiliser ici est un ESP32. En suivant le tutoriel précédent vous pouvez donc sélectionner la carte ESP32.

      Si vous ne la trouvez pas, vérifier bien si elle est installer. Si ce n'est pas le cas, installer la de cette façon.

      Ouvrez Arduino IDE, allez dans "Outils > Carte > Gestionnaire de carte" et dans la barre de recherche écrire "ESP32". 

      Installer ceci :

      image.png

      Fonctionnement et programmation d'une LED :

      Fonctionnement et programmation du buzzer :

      Fonctionnement et programmation du servomoteur :

      Fonctionnement et programmation du capteur PIR :

      Défi intermédiaire :

      Réaliser un programme qui lorsque le capteur PIR détecte une présence, le servomoteur ferme la porte, la led s'allume en rouge et le buzzer sonne.

      Fonctionnement et programmation du DHT22 :

       

      Fonctionnement et programmation du pavé numérique :

      Défi intermédiaire :

      Réaliser un programme qui lorsque si l'alarme est activée et le capteur PIR détecte une présence, le servomoteur ferme la porte, la led s'allume en rouge et le buzzer sonne. Et, que si l'alarme est désactivée à l'aide du pavé numérique en ayant entré le bon code alors cela ne fait rien. Si le code est entré est faux 3 fois de suite, l'alarme sonne. Pour activé l'alarme, le code doit être entrée puis le bouton validée du pavé numérique presser

      Fonctionnement et programmation de l'écran OLED :

      Club robotique - Maison connectée

      Modélisation de la maison en 2D

      Club robotique - Maison connectée

      Programme final de la maison connectée

      Club robotique - Drone

      Club robotique - Drone

      Description du projet

      Club robotique - Drone

      Fonctionnement et programmation des composants

      Club robotique - Distributeur de boisson

      Club robotique - Distributeur de boisson

      Description du projet

      Liste des composants :

      Club robotique - Distributeur de boisson

      Fonctionnement et programmation des composants

      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

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

      Nouvelle correction : programmeEauComplet.ino

      Ancien code : 2024_stage_collegiens_v5_Station_Eau.ino

      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

      Séance Thématique

      Séance Thématique

      Séance Pâques

      Séance Thématique

      Club robotique - Séance "Scratch & Snacks"

      Bienvenue à notre grande fête de fin d’année : Scratch and Snacks ! :
      Un moment pour croquer des biscuits, partager des souvenirs, jouer comme des robots et déconnecter joyeusement après une belle année de découvertes !

      22110287-2d4f-42c8-bb99-fc533cdf6451 (1).png

      Dérouler de la séance :
      🧃 0–10 min : Accueil, goûter et création des équipes
      Ambiance musicale, snacks partagés et création des équipes (binôme)!
      🎮 10–25 min : Jeu “Code Humain” façon Scratch
      Donner des blocs d’instructions à exécuter (avancer, tourner, sauter, etc.) afin d'éviter les obstacles et finir la course ! Le travail d'équipe va être important ! (en binome)
      🔍 25–35 min : “Quiz Scratch & Snacks”
      Questions sur les clubs de robotique (vrai/faux, choix multiples).
      🎲 35–50 min : “Dessine ton robot”
      Un thème donnée puis dessine un robot à l'aveugle… et laisser place à l’imagination (et aux fous rires) ! Attention, ici vous n'êtes plus en équipe alors accroché vous... 
      🎓 50–60 min : Diplômes, photo, au revoir !
      C'est l'heure de se dire aurevoir... jusqu'à l'année prochaine !

      En fonction du temps disponible, vous êtes libres d'ajuster les animations et les temps dédié à ces dernières.

      1) "Code Humain" façon Scratch
      Introduction :
      Description de l'atelier aux jeunes. 
      Exemple : Aujourd’hui, vous allez devenir des robots Scratch ! Vos amis vont vous donner des blocs d'instructions à suivre… mais attention : il faudra les exécuter dans l’ordre, comme un vrai programme afin d'éviter des obstacles et récupérer un objet à la fin du parcours."
      Activité en binôme:
      Une fois la course d'obstacle prête, faire les équipes en binôme.
      Les binômes choisissent un programmeur (qui donne les ordres en bloc) et un robot (qui exécute les ordres). Le robot doit avoir les yeux fermer. 
      Le groupe qui prend le moins de temps gagne ! (Vous pouvez faire deux courses en parallèle si vous faites deux fois le parcours avec assez de matériels)
      Attention, si vous toucher un obstacle alors c'est retour à la case départ. Si vous avez du mal essayer de changer les rôles!
      - Présentation des blocs à utiliser : 
      1 - Avancer de "X" pas*
      2 - Obstacle détectée
      3 - Reculer de "X" pas*
      4- Tourner de "X" degré*
      5 - S'arrêter 
      6 - Faire une danse 
      7 - Dire "je suis fatigué"
      *Remplacer "X" par le nombre de pas souhaité ou par l'angle en degré dont vous voulez tourner* 

      Démonstration : 
      Faire une démonstration avec un volontaire si besoin.

      Répartition des points :
      Le comptage ce fait en individuel car il n'y aura qu'un vainqueur à la fin. 
      Le premier groupe gagne chacun le nombre de point équivalent au nombre d'équipe qui participe. Le second groupe gagne chacun un point en moins et ainsi de suite.
      Exemple : 3 équipes au total :
      - Equipe 1 : Chacun des membres de l'équipe gagne 3 points
      - Equipe 2 : Chacun des membres de l'équipe gagne 2 points 
      - Equipe 3 : Chacun des membres de l'équipe gagne 1 points

      Maintenant, il vous suffit de jouer. A vos marques! Prêt ? Partez !
      2) Quizz "Scratch and Snacks"
      Introduction :
      Pour les quizz, nous utilisons le site quizz : https://wayground.com/join
      Libre à vous de faire comme vous le souhaitez, tableau, ardoise, feuille et stylo ou encore à l'oral.
      En fonction de la méthode utilisé, vous pouvez également faire en binôme. 

      Objectif :
      Trouvez les bonnes réponses aux questions. 
      Démonstration : 
      Faire une démonstration si besoin.

      Répartition des points :
      A vous de choisir le système de point. Ici nous prendrons le nombre de participants, le vainqueur gagnera le nombre de point équivalent correspondant aux nombres de participants. Le deuxième en gagne un de moins et ainsi de suite.
      Exemple : 5 participants au total :
      - Le 1er gagne 5 points
      - Le 2ème gagne 4 points
      - Le 3ème gagne 3 points 
      - ainsi de suite…


      Si vous choisissez de le faire en binôme, vous pouvez prendre la même répartition des points que pour le premier atelier.

      3) Quizz "Dessine ton robot"
      Objectif :
      "Aujourd’hui, on va faire un défi un peu fou… Un défi où on va mélanger de l’imagination, du dessin, et… un peu de chaos rigolo !
      Est-ce que vous êtes prêts à dessiner un robot ? 
      Oui ? Très bien…
      Mais attention… vous allez devoir le faire les yeux fermés ! 
      L’idée, ce n’est pas de faire un dessin parfait, mais de laisser parler votre cerveau de roboticien, votre mémoire et vos doigts, même sans regarder.
      Vous aurez 1 minute pour créer un robot selon la consigne donnée, à l’aveugle. Et ensuite, on regardera tous ensemble le résultat pour voter le podium :
      - Le robot le plus drôle
      - Le plus étrange
      - Le plus mignon
      - Et peut-être… le plus effrayant !
       
      A vous de choisir les thématique.
       
      Prêts ? Fermez les yeux, attrapez vos crayons… et que le dessin robotique commence !"

       

      Démonstration : 
      Faire une démonstration avec un volontaire si besoin.

       

      Répartition des points :
      A la fin du temps impartie nous passons au vote. Tout le monde à le droit de voter pour son préférer. Attention vous n'avez pas le droit de voter pour le votre. Vous devez donc voter votre dessin préférer selon la thématique donnée.
      A vous de choisir le système de point. Ici nous prendrons le nombre de participants, le vainqueur gagnera le nombre de point équivalent correspondant aux nombres de participants. Le deuxième en gagne un de moins et ainsi de suite.
      Exemple : 5 participants au total :
      - Le 1er gagne 5 points
      - Le 2ème gagne 4 points
      - Le 3ème gagne 3 points 
      - ainsi de suite…

      Nouvelle page

      Pour les animateurs et la création pédagogique des clubs

      Pour les animateurs et la création pédagogique des clubs

      Matériel et Plateforme standards pour la robotique éducative

      Où acheter des composants et cartes électroniques :

      Composant standards choisis excel et plateformes robotiques possibles :

          Direct Chine (AliExpress, Alibaba) CreaBot Robotique
      Type Désignation Réf Marque Fournisseur  Prix TTC+port  LittleBot (creabot mobile) RCcar (creabot car)
      Carte Microcontrôleur Arduino Nano ATmega328P         1 1
      Development Shield Sensor Shield R3         1 1
      Distance ultrason Ultrason HC-SR04 HC-SR04 Ultraljudsmodul AZDelivery Amazon    1,85 € 1 1
      Suivi ligne infrarouge TRCT5000 coulée infrarouge  MH-Sensor-Series DIY-Victor AliExpress    0,72 € 1 1
      Accéléromètre Gyroscope 6DDL MPU-6050 H-1-0122 Hailege Amazon    4,13 €    
      Température et humidité DHT11 JST PH            
      Température et humidité DHT22 Dupont DHT22 TZT AliExpress    1,65 €    
      Température et humidité DHT22 JST PH            
      Moteur CC Moteur CC encodeur           2
      Moteur CC Moteur CC jaune            
      pilote moteur CC double pont H L298N N30 xocom,ATOYT AliExpress    3,40 €    
      pilote moteur CC double pont H L9110S L9110S PUMUDDSY AliExpress    0,95 € 1 1
      Servomoteur vitesse servomoteurs DM-S0090D-R 9g/0.08s/1.6kg.cm 22.9X12X22.5mm DM-S0090D-R DORCRCMAN AliExpress    2,22 € 2  
      Servomoteur position Servomoteur 180° SG90 9g SG90 TowerPro AliExpress    2,19 €   1
      Moteur pas-à-pas Nema 14 35x35x34mm arbre 24mm 14HS13-0804S STEPPERONLINE AliExpress  15,21 €    
      pilote moteur pas-à-pas CNC shield V4 HW-702 v0.0.0 V4 DRV8825 RoarKit AliExpress    7,14 €    
      pilote moteur pas-à-pas pilote moteur CC DRV8825 V4 DRV8825 RoarKit AliExpress    
      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

       

      Pour les animateurs et la création pédagogique des clubs

      Installation des PC

      Dual-boot Windows Ubuntu

      Pour le pilotage du bras robot SO-ARM100 et des drones, on privilégie Ubuntu et la programmation en Python.

      Après avoir configuré correctement le PC Windows https://doc.ubuntu-fr.org/cohabitation_ubuntu_windows  :

      Si Secure Boot n'est pas désactivé, le dual boot est possible mais il faudra booter sur Windows exclusivement depuis le Bios en appuyant sur F12. Si on démarre Windows via le Grub, secure boot demande une clé de sécu.

      Installer Ubuntu LTS depuis une clé USB Live.

      Après l'installation il y a deux possibilités pour basculer entre Windows et Ubuntu :

      OIP-2633633953.jpeg

       Il est possible de changer l'ordre de boot par défaut du menu Grub : https://askubuntu.com/a/110738 

      Mblock 5 pour l'animation STEM

      Mblock 5 pour l'animation STEM

      Création de blocs d'extensions aevc mBlock 5 Extension Builder

      Voir https://forum.makeblock.com/t/how-to-add-an-extension-for-mblock/2280 

      Mblock est normalement installé dans C:\ProgramData 

      Sur mon PC il est installé dans C:\Users\USER\mblock (voir aussi dans C:\Users\Public\Programs

      Les extensions sont installées dans : C:\Users\USER\mblock\exts

      Les sources sont en JavaScript... Il faut trouver comment remonter aux sources C (fichiers .c et .h) qui appellent les librairies dont dépendent les blocs de programmation et définissent le code C équivalent à chaque bloc. A défaut, trouver si les fournisseurs de l'extensions ont mis le code source sur une forge logicielle publique.

      Création de nouveau bloc avec mBlock 5 Extension Builder


      Avec des librairies de dépendance

      https://support.makeblock.com/hc/en-us/articles/15264543414935-Example-Arduino-Add-a-Third-party-Library-for-an-Arduino-Extension 

      https://www.yuque.com/makeblock-help-center-en/extension-builder/arduino-add-third-party-library 

      Pour inspiration, on importe une librairie existante : 

      image.png

      Pour créer une nouvelle librairie :

      image.png

      image.png

      Scroller jusqu'en bas et importer un dossier src contenant les fichiers .h et .cpp de votre lib

      image.png

      Publier un block

      https://www.yuque.com/makeblock-help-center-en/extension-builder/how-to-publish 

      https://www.yuque.com/makeblock-help-center-en/extension-builder/publishing-criteria 

      Sources

      Mblock 5 pour l'animation STEM

      Animation avec un bloc non publié

       

      Ouvrir l'IDE de test de l'extension et récupérer l'URL du type

      https://ide.mblock.cc/preview.html#/?extId=39817 

      Connexion au PC

      Ouvrir Chrome
      sélectionner DuckduckGo

      ide.mblock.cc
      skip
      etudiant1@fablab-alsacenord.fr
      etudiantfablab1
      https://ide.mblock.cc/preview.html#/?extId=39817 

      Club Robotique - Lego Mindstorms

      Club Robotique - Lego Mindstorms

      Lien de téléchargement du logiciel de programmation

      https://education.lego.com/fr-fr/downloads/mindstorms-ev3/software/

      Club Robotique - Lego Mindstorms

      Mis à jour du Firmware

      Lien du site pour la mis à jour de la brick lego :

      https://ev3manager.education.lego.com/

      Une fois sur le site vous devrez télécharger  "EV3DeviceManager.msi" que le site vous proposera d'installer.

      Redémarrer votre ordinateur puis retourner sur le site précédent.

      Sélectionner le firmware que vous voulez télécharger dans la brick et lancer la mis à jour.

      Attendez jusqu'à ce que ce soit fini