Robotique2 2
Sommaire
Présentation du projet
Le but du robot est d’envoyer un maximum de balle dans le camp adverse sans jamais y entrer et sans contrôler plus d’une balle à la fois.
Les parties se dérouleront sur un terrain de 8 mètres par 4, divisé en deux parties par une ligne blanche centrale de 67cm de large donc notre robot aura une surface de 4 mètres par 4, soit 16m² pour se déplacer.
Les parties auront une durée de 90 secondes à l’issu desquelles notre robot devra se déplacer jusqu'à la ligne blanche centrale, sans pour autant la dépasser, puis arrêter ses moteurs et crever le ballon qui sera accroché à son socle, à 30cm du sol minimum.
Notre robot devra être totalement autonome et en aucun cas ne pourra être téléopéré.
Nous devons toutefois faire face à quelques obligations :
Aucune tension ne doit dépasser 24V.
Le robot ne peut avoir que 2 roues motrices.
La distance entre ces 2 roues doit être inférieure à 30 cm.
La batterie ne doit être ni au lithium-polymère, ni au lithium-cobalts.
Le propulseur de balle ne doit sortir du robot uniquement pour un tir, et doit revenir se ranger lorsque son tir est terminé.
Pour se faire, nous avons séparer les différentes parties sous la forme suivante :
Lachiri Iyad : Caméra Pixy2, Boussole & création physique.
Sciré Morgane : Crève-ballon & pièces 3D.
Mathieu Anthony : Fonction frapper la balle & la retenir
Garnier Clément : Détecter les lignes & créer un compte à rebours
Lescasse Enzo : Fonction se déplacer & mise en commun des différents programmes
Fonctionnement du robot
Le fonctionnement du robot devra se dérouler comme ci-contre exactement (voir image du diagramme de fonctionnement), lors de ce compte-rendu, nous détaillerons donc les actions dans l'ordre où elles interviendront sur le fonctionnement du robot.
Caméra Pixy2, Boussole & création physique
La caméra Pixy2 se branche seulement sur le port ICSP d'une carte Arduino Uno en l'occurence.
Peu de montage physique entraîne beaucoup de programmation, nous avons donc conçu ce programme afin de faire fonctionner la caméra :
Code_Pixy2
#include <Pixy2.h>
Pixy2 pixy;
void setup()
{
Serial.begin(115200);
Serial.print("Starting...\n");
pixy.init();
}
void loop()
{
int i;
int x;
int y;
pixy.ccc.getBlocks();
if (pixy.ccc.numBlocks) // si on détecte la balle
{
Serial.print("position x de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_x); // on indique la position de la balle sur l'axe x (entre 316 et 0)
if (pixy.ccc.blocks[i].m_x < 103) { // si la balle est plus à gauche par rapport au milieu de l'axe, on tourne à gauche
Serial.println("tourner à gauche");
}
if (pixy.ccc.blocks[i].m_x > 206) {
Serial.println("tourner à droite"); // si la balle est plus à droite par rapport au milieu de l'axe, on tourne à droite
}
Serial.print("position y de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_y);
if (pixy.ccc.blocks[i].m_y > 105 && pixy.ccc.blocks[i].m_x < 206 && pixy.ccc.blocks[i].m_x > 103) { // si la balle est en face du robot, et proche
Serial.println("avancer doucement");
}
if (pixy.ccc.blocks[i].m_y < 105 && pixy.ccc.blocks[i].m_x < 206 && pixy.ccc.blocks[i].m_x > 103) {// si la balle au centre de l’axe X, et loin du robot
Serial.println("avancer rapidement");
}
}
//si on ne détecte pas la balle
else {
Serial.println("chercher la balle");
}
delay(1000);
}
Afin de pouvoir régler la caméra Pixy lors de sa programmation, nous avons eu recours au logiciel "PixyMon" qui nous permet d'afficher sur l'écran d'ordinateur ce que la caméra voit en temps réel :
Caméra Pixy2
PixyMon
Crève-ballon & pièces 3D
Tout d'abord, il fallait trouver comment fixer à 30 cm minimum du sol et comment maintenir le ballon sur le robot. On a donc crée un socle en 3D pour maintenir le ballon afin qu'il soit maintenu et qu'il ne bouge pas trop lors du déplacement du robot sur le terrain.
Ensuite, pour exploser le ballon, on utilisera un pique car c'est une solution simple et efficace à mettre en œuvre. Sachant que pour percer un ballon à l'aide d'un pique nous n’avons pas besoin de beaucoup de force, on a décidé d'utiliser un servomoteur.
Le pique sera fixé sur un bras conçu en 3D, une partie du bras sera fixé sur le servomoteur et sur l'autre extrémité il y aura le pique. Le servomoteur s'utilise en degrés, c'est-à-dire qu'il peut tourner de 0 à 180°. On le mettra en position initiale, c'est-à-dire à 0° et on le programme de façon à ce qu'il puisse exploser le ballon, donc ici il devra tourner d'environ 140° pour exploser le ballon et ensuite se remettre dans sa position initiale.
Après avoir trouver et tester cette solution, il fallait trouver comment fixer le servomoteur le plus proche possible du ballon. On a donc décidé de le fixer sur le socle du ballon.
On a donc crée une pièce 3D qui se fixe autour du socle à l'aide d'une "bague" sur laquelle on y a mis une encoche pour y insérer le servomoteur.
Code_Crève Ballon
#include <Servo.h>
Servo monServomoteur; //Création de l’objet servomoteur
void setup() {
monServomoteur.attach(7); // Déclaration pour utilisation de la broche 7
monServomoteur.write(0); // Initialisation de la position 0
Serial.begin(9600);
}
void loop() {
monServomoteur.write(130);
delay(0000);
monServomoteur.write(0);
delay(0000);
}
Fonction frapper la balle & la retenir
La fonction qui permet d'attraper la balle de tennis et de la frapper est la partie du robot qui nous permettra de marquer des points sur le terrain ou non.
Pour cette partie, énormément d'idées ont vu le jour :
- Utilisation de moteur à courant continu
- Utilisation de moteurs pas-à-pas
- Utilisation de ressorts ou de lames de ressorts
La solution retenue pour la version finale est l'utilisation des différentes parties du robot, de deux servomoteurs ( un pour attraper la balle et un autre pour la projeter ), et d'un HC SR 04 qui permet un calcul de distance à l'aider d'ultrason qui contrôlera la présence ou non de la balle dans la zone des 2 servomoteurs.
Le fonctionnement et le déroulement se feront en six étapes :
- A l'aide de la caméra Pixy2, le robot se dirige vers la balle - Une fois que le capteur de distance HCSR04 détectera la présence de la balle, le servomoteur qui permet de contenir la balle va se refermer sur celle-ci pour l'attraper La balle sera alors contenue entre les deux servomoteurs, celui qui sert à attraper, et celui qui est prêt à la frapper à tout moment - A l'aide du gyroscope, le robot va se diriger vers le terrain adverse - Une fois sur la ligne blanche, celle-ci sera détectée grâce au capteur de ligne et le robot va mettre ses moteurs à 0 afin d'arrêter totalement le mouvement - Enfin, le robot ouvrira le bras du servomoteur qui servait à contenir la balle, et va actionner le second servomoteur afin de pousser la balle dans le camp adverse.
Cette partie est donc l'une des plus importantes car elle regroupe toutes les autres parties et nous permet de marquer des points.
Code_Frapper la balle
#include <Servo.h>
int capteur0;
int capteur1;
int capteur2;
Servo monServomoteurTaper;
const int detecte = 8;
void setup() {
pinMode(detecte, INPUT); //detecte balle
monServomoteurTaper.attach(8);
monServomoteurTaper.write(0);
Serial.begin(9600);
}
void loop() {
int sensorValue0 = analogRead(A0);
int sensorValue1 = analogRead(A1);
int sensorValue2 = analogRead(A2);
Serial.println("capteur0");
Serial.println(sensorValue0);
//delay(1000);
Serial.println("capteur1");
Serial.println(sensorValue1);
//delay(1000);
Serial.println("capteur2");
Serial.println(sensorValue2);
//delay(1000);
if ((sensorValue0 > 500) && (sensorValue1 > 400) && (sensorValue2 > 200))
{
Serial.println("ARRET MOTEUR");
monServomoteurTaper.write(90);
}
else if ((sensorValue0 < 450) && (sensorValue1 < 400) && (sensorValue2 < 200))
{
monServomoteurTaper.write(0);
}
}
Code_Attraper la balle
#include <Servo.h>
Servo monServomoteurAttraper;
int trig = 2;
int echo = 3;
long lecture_echo;
long cm;
void setup() {
monServomoteurAttraper.attach(7);
monServomoteurAttraper.write(0);
pinMode(trig, OUTPUT);
digitalWrite(trig, LOW);
pinMode(echo, INPUT);
Serial.begin(9600);
}
void loop() {
digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
lecture_echo = pulseIn(echo, HIGH);
cm = lecture_echo / 58;
Serial.print("Distance en cm :");
Serial.println(cm);
delay(500);
if (cm < 5)
{
Serial.print("Balle attrapée");
monServomoteurAttraper.write(90);
delay(100);
}
if (cm > 5){
Serial.print("Balle va être attrapée");
monServomoteurAttraper.write(0);
delay(100);
}
}
Détecter les lignes & créer un compte à rebours
Pour la partie détection de ligne nous avons décidé d'utiliser 6 capteurs Cny70 répartis sur l’avant du robot.
Nous avons utilisé ce schéma de branchement pour les 6 capteurs et nous les avons reliés ensemble.
Le CNY70 est un émetteur et un récepteur infrarouge.
Le capteur envoie un faisceau infrarouge et selon la luminosité reçue, la tension dans le capteur variera, grâce à cette tension nous pourrons savoir si le capteur est sur la ligne blanche ou sur le terrain bleu.
Pour détecter la ligne blanche au milieu du terrain. Nous les avons regroupés par 3 afin qu’ils couvrent une plus grande surface de détection. Et si les 6 capteurs possèdent la même tension correspondant à la ligne blanche alors le robot s’arrêtera.
Tout ce programme sera regroupé au sein du code du TIMER qui permettra au robot de s'arrêter avant la fin du temps imparti.
Code_Détecteur de ligne
void setup()
{
pinMode(A0, INPUT);
pinMode(A1, INPUT);
pinMode(A2, INPUT);
Serial.begin(9600);
}
void loop()
{
//on declare les variables des capteurs
int capteur0;
int capteur1;
int capteur2;
//On declare les variables sensorValue
//pour donné un nom a la valeur que donnera la pin
int sensorValue0 = analogRead(A0);
int sensorValue1 = analogRead(A1);
int sensorValue2 = analogRead(A2);
//Serial.println("capteur0");
//Serial.println(sensorValue0);
//delay(1000);
//Serial.println("capteur1");
//Serial.println(sensorValue1);
//delay(1000);
//Serial.println("capteur2");
//Serial.println(sensorValue2);
//delay(1000);
if ((sensorValue0 < 240))
{
capteur0 = 1;
Serial.print(capteur0);
Serial.println("___capteur dans le bleu");
delay(1000);
}
else if ((sensorValue0 > 240))
{
capteur0 = 2;
Serial.print( capteur0);
Serial.println("___capteur dans le blanc");
delay(1000);
}
if ((sensorValue1 < 240))
{
capteur1 = 11;
Serial.print(capteur1);
Serial.println("___capteur dans le bleu");
delay(1000);
}
else if ((sensorValue1 > 240))
{
capteur1 = 12;
Serial.print( capteur1);
Serial.println("___capteur dans le blanc");
delay(1000);
}
if ((sensorValue2 < 250))
{
capteur2 = 21;
Serial.print(capteur2);
Serial.println("___capteur dans le bleu");
delay(1000);
}
else if ((sensorValue2 > 250))
{
capteur2 = 22;
Serial.print( capteur2);
Serial.println("___capteur dans le blanc");
delay(1000);
}
if ((sensorValue0 > "") && (sensorValue1 > "") && (sensorValue2 > ""))
{
Serial.println("ARRET MOTEUR");
}
}
Fonction se déplacer
Pour créer cette fonction, nous avons pris deux moteurs en courant continu, un shield moteur L298P ainsi qu'une batterie de 12V.
Pour le programme, j’ai commencé par déclarer les variables et faire le void setup, ensuite pour le void loop, j’ai préparé les 5 actions nécessaires soit : avancer lentement et rapidement, tourner à gauche et à droite et chercher la balle. Lorsqu’il faut tourner à gauche, on active les deux moteurs mais le moteur de droite va être plus rapide que celui de gauche ce qui permettra une rotation du robot, inversement pour tourner à droite.
Pour avancer plus ou moins rapidement, on active tout simplement les deux moteurs plus ou moins vite, et pour chercher la balle, on exerce le même programme que pour tourner à gauche ce qui va permettre au robot de subir une rotation jusqu’à ce qu’une balle entre dans son champs de vision.
Code_SeDéplacer
int E1 = 5;
int M1 = 4;
int E2 = 6;
int M2 = 7;
void setup()
{
pinMode(M1, OUTPUT);
pinMode(M2, OUTPUT);
}
void loop()
{
if (){ // si la balle est plus à gauche que la barre verticale des ⅓ de pixel
Serial.println("tourner à gauche");
analogWrite(E1, 30);
analogWrite(E2, 50);
}
if () {// si la balle est plus à droite que la barre des ⅔ de pixel
Serial.println("tourner à droite");
analogWrite(E1, 50);
analogWrite(E2, 30);
}
if (){ // si la balle est, sur l’axe y, supérieur à la moitié
Serial.println("avancer doucement");
analogWr+ Boussole +ite(E1, 50);
analogWrite(E2, 50);
}
if (){ // si la balle est inférieur à la moitié sur l’axe y
Serial.println("avancer rapidement"); // si la balle est plus à droite par rapport au milieu de l'axe, on tourne à droite
analogWrite(E1, 100);
analogWrite(E2, 100);
}
}
//si on ne détecte pas la balle
else {
Serial.println("chercher la balle");
analogWrite(E1, 50);
analogWrite(E2, 30);
}
}
Pour le programme final, nous avons changé la variable pour tourner, c’est-à-dire qu'au lie de tourner à une vitesse constante et e risquer de passer devant la balle sans avoir le temps de la voir, nous avons créé une équation qui nous permettra de faire fluctuer la vitesse en fonction de l'angle entre la balle et le centre de vision du robot.
Nous avons donc obtenu cette équation :
analogWrite(E1, (N + K * (pixy.ccc.blocks[i].m_x - 158))); // N est une vitesse constante, K un coefficient réducteur, puis on soustrait la position X de la balle par le nombre de pixels central de la vision afin d'obtenir un angle.
Cette équation n'est valable que pour tourner à droite, pour tourner à gauche nous remplacerons les parenthèses par 158 - position X de la balle.
Le robot ralentira sa rotation au fur et à mesure que la balle se rapprochera du centre de sa vision jusqu'à aller finalement tout droit et réussir à l'intercepter.
Mise en commun des différents programmes
Lors de cette partie, nous allons vous expliquer, étape par étape, comment nous avons mit nos codes en commun chacun notre tour jusqu'à obtenir le code final. Au niveau de la construction physique du robot, nous nous sommes débrouillé pour que chaque partie utilise des différentes broches afin de pouvoir utiliser seulement une carte Arduino.
Fonction Pixy2 + Boussole + Se déplacer
Pour se faire, comme vous l'avez vu précédemment, le programme de la Pixy renvoyait des données telles que "Tourner à gauche", il a donc suffit de mettre les commandes correspondantes aux moments donnés afin de faire un programme homogène. Ici, la boussole est liée dans le programme mais n'est pas utilisée, nous l'avons préparée afin de l'utiliser par la suite.
Code_Mise en commun se déplacer + Pixy2
#include "MPU9250.h"
int boussole;
int N = 50;
int K = 0.3;
MPU9250 IMU(Wire, 0x68);
int status;
double moyenne;
double moyenneFinal;
int i;
double angle() {
double Module_magnetic;
double angle;
double Xmagnetic;
double Ymagnetic;
double Zmagnetic;
IMU.readSensor();
Xmagnetic = IMU.getMagX_uT();
Ymagnetic = IMU.getMagY_uT();
Zmagnetic = IMU.getMagZ_uT();
Module_magnetic = Xmagnetic * Xmagnetic + Ymagnetic * Ymagnetic + Zmagnetic * Zmagnetic;
Module_magnetic = sqrt(Module_magnetic);
angle = atan2(Ymagnetic, Xmagnetic) * (180 / 3.14159265); // angle en degres
if (angle < 0) {
angle = angle + 360;
}
return angle;
}
#include <Pixy2.h>
// This is the main Pixy object
Pixy2 pixy;
int E1 = 5;
int M1 = 4;
int E2 = 6;
int M2 = 7;
void setup()
{
Serial.begin(115200);
Serial.print("Starting...\n");
pixy.init();
pinMode(M1, OUTPUT);
pinMode(M2, OUTPUT);
Serial.begin(115200);
while (!Serial) {}
// start communication with IMU
status = IMU.begin();
if (status < 0) {
Serial.println("IMU initialization unsuccessful");
Serial.println("Check IMU wiring or try cycling power");
Serial.print("Status: ");
Serial.println(status);
while (1) {}
}
IMU.setAccelRange(MPU9250::ACCEL_RANGE_8G);
IMU.setGyroRange(MPU9250::GYRO_RANGE_500DPS);
IMU.setDlpfBandwidth(MPU9250:: DLPF_BANDWIDTH_20HZ);
IMU.setSrd(19);
}
void loop()
{
int i;
int x;
int y;
// grab blocks!
pixy.ccc.getBlocks();
// si on détecte la balle
if (pixy.ccc.numBlocks)
{
Serial.print("position x de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_x); // on indique la position de la balle sur l'axe x (entre 316 et 0)
if (pixy.ccc.blocks[i].m_x < 103) { // si la balle est plus à gauche par rapport au milieu de l'axe, on tourne à gauche
Serial.println("tourner à gauche");
analogWrite(E1, 50);
analogWrite(E2, (N + K * (158 - pixy.ccc.blocks[i].m_x)));
}
if (pixy.ccc.blocks[i].m_x > 206) {
Serial.println("tourner à droite"); // si la balle est plus à droite par rapport au milieu de l'axe, on tourne à droite
analogWrite(E1, (N + K * (pixy.ccc.blocks[i].m_x - 158)));
analogWrite(E2, 50);
}
Serial.print("position y de la balle ");
Serial.print(i);
Serial.print(": ");
Serial.println(pixy.ccc.blocks[i].m_y);
if (pixy.ccc.blocks[i].m_y > 105 && pixy.ccc.blocks[i].m_x < 206 && pixy.ccc.blocks[i].m_x > 103) { // si la balle est proche
Serial.println("avancer doucement");
analogWrite(E1, 50);
analogWrite(E2, 50);
}
if (pixy.ccc.blocks[i].m_y < 105 && pixy.ccc.blocks[i].m_x < 206 && pixy.ccc.blocks[i].m_x > 103) {
Serial.println("avancer rapidement"); // si la balle est loin
analogWrite(E1, 100);
analogWrite(E2, 100);
}
}
//si on ne détecte pas la balle
else {
Serial.println("chercher la balle");
analogWrite(E1, 50);
analogWrite(E2, 30);
}
delay(1000);
Serial.print(" ");
Serial.print("Angle "); //en degres
Serial.println(angle());
boussole = angle;
moyenne = 0;
for (i=0; i<100; i++)
{
moyenne = moyenne + angle();
delay(10);
}
moyenneFinal = moyenne/100;
Serial.print("Moyenne : ");
Serial.println(moyenneFinal);
delay(1000);
}
