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

Modification du châssis du LittleBot et Impression 3D

Modification du châssis du LittleBot

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 :

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 .

Etape 3 :

Pour la dernière étape, 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

Etape 4 :

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

image.png

Etape 5 :

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

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

Montage et Câblage du LittleBot :

Etape 1 :

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

Etape 2 :

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

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

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

image.png

Etape 5 :

Mettre les palonniers dans les roues.

image.png

Puis fixer les roues sur les servomoteurs.

image.png   rKQimage.png

Etape 5 :

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 du 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 pendants 2 secondes puis tourner à gauche pendant 2 sec.

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