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

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 :

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

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
}

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.

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

      

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!