RobotiqueCoupeGEII
Sommaire
Présentation du projet
Notre équipe
Nous sommes 5 étudiants venant de l’IUT de Troyes en formation d’un DUT Génie électrique et informatique industrielle (GEII), lors de cette formation nous avons eu l’opportunité de réaliser un projet de robotique durant l’année 2020-2021, avec l’objectif de participer à la Coupe Robot GEII.
Notre groupe est composé de Dan Boilleau, Luca Giocondo, Mathieu Beauvois, Louis Foucher et Loris Baroni.
Durant le projet nous nous sommes répartis les tâches à effectuer au fur et à mesures :
- Dan Boilleau : utilisation des moteurs de déplacements avec les ponts en H / réalisation de la partie permettant de lancer et d'attraper la balle.
- Luca Giocondo : réalisation de la partie de détection de la ligne médiane.
- Louis Foucher : réalisation de la partie Crève-ballon / élaboration de support pour différents capteurs.
- Mathieu Beauvois : réalisation de la partie détection de la balle avec la caméra Pixy2 / réalisation de la partie boussole (magnétomètre).
- Loris Baroni : Réalisation de la partie des télémètres / Assemblages du robot / réalisation de la carte électronique de contrôle.
Objectifs
Nous avons pour but de réaliser un robot pouvant jouer au tennis de manière autonome en vue de participer à la coupe robotique GEII. Durant la compétition, deux robots s’affrontent. Notre robot doit se déplacer sur le terrain sans toucher les murs ou encore franchir la ligne médiane de séparation des camps. Il doit également attraper et renvoyer un maximum de balles de tennis standard dans le camp adverse en contrôlant une balle à la fois. De plus, Il doit avant la fin du temps imparti (90 secondes : durée du match) crever un ballon accroché à lui-même. Une fois le ballon crevé, le robot doit être immobile sur la ligne médiane (Pour rapporter des points bonus). Nous devons également respecter des contraintes de taille, de composants tels que la batterie ou encore les moteurs.
Cahier des charges / règlement de la compétition
L'aire de jeu
L'aire de jeu a pour dimension 8 x 4 m avec une ligne médiane de 67 cm de large soit un espace de 16 m² pour le déplacement de notre robot.
Les balles
Les balles utilisées sont des balles de tennis standard.
Elles sont placées aléatoirement sur le terrain à l'exception de 3 balles placées systématiquement aux 3 intersections des lignes de notre terrain (points jaunes sur le schéma).
Le Robot
Le but du robot est d'envoyer le plus de balle possible dans le camps adverse à l'aide d'un système propulseur, sans jamais franchir la ligne médiane qui sépare les deux camps et en ne contrôlant qu'une balle à la fois. Lors du lancement d'un match, le robot doit être démarré à l'aide d'un bouton qu'un utilisateur viendra actionner, ensuite il sera autonome. Le robot gagnant est celui qui aura le moins de balle dans son camp à la fin du match.
Les Balises
Il est possible de poser jusqu'à 3 balises de dimensions maximales de 20 x 20 x 20 cm sur des emplacements spécifiques (détaillé sur le schéma). Nous avons décidé de ne pas utilisée de balise.
Homologation
Le robot doit répondre aux exigences fixées.
Ces exigences sont les suivantes :
- Le robot rentre dans une boite de 40 x 30 x 30 cm.
- Un ballon de baudruche est fixé à 30 cm du sol et doit être percé sur la ligne médiane avant la fin du temps imparti des matchs (90 secondes).
- Le robot ne présente aucun danger, ni au repos, ni en fonctionnement (pas de pièces coupantes...).
- Un dispositif permettant de couper le courant doit être mit en place (bouton d'arrêt d'urgence).
- Un dispositif mécanique de mise en marche doit être présent.
Règlement complet de la compétition
Pour plus d'information sur les règles, je vous invite à aller regarder la réglementation complète: Règlement
Recherche et développement
Schéma fonctionnel
Algorithme
Prototype
Dans un premier temps, nous avons utilisés un robot existant afin de pouvoir tester, configurer ou encore programmer différente partie du robot à l'aide d'un Arduino UNO. Dans un premier il a fallut piloter les moteurs permettant un déplacement du robot sur notre terrain à l'aide de pont en H permettant de piloter les moteurs dans les deux sens de rotation, On a programmer la base de notre code. Par la suite nous avons pu coupler au robot la caméra Pixy2 afin que notre robot puisse suivre une balle de tennis en déplacement, après plusieurs test les essais fut concluant, ces étapes de test sont indispensables pour le bon fonctionnement de notre futur robot. On a également pu tester la détection d'un obstacle afin de l'éviter ... (etc)
Solution adoptée
Alimentation / Régulation
La batterie
Notre robot comprend un pack de piles rechargeables 4x 18650 LiFePO 4 Emmerich 4A12318650RK 12.8 V 1100 mAh pour permettre d'alimenter les différents éléments.
Une tension minimum de 9V est nécessaires pour le bon fonctionnement de notre robot.
Abaisseur de tension
La batterie fournie délivre 12.8V, hors nous avons besoin d'une alimentation 5V pour le bon fonctionnement de certain capteur ou actionneur.
C'est pourquoi nous avons utilisée un abaisseur de tension réglable.
Gérer
ATmega 2560
Ce microcontrôleur qui est présent sur les Arduino Méga possède un grand nombre de port ce qui nous est utile pour l'élaboration d'une carte complète avec un grand nombre de capteur et d'actionneur.
Il est programmable à l'aide du logiciel Arduino ainsi qu'un programmateur brancher sur un connecteur ISP, le connecteur ISP sert également à brancher la caméra Pixy 2 au microcontrôleur.
Carte électronique de contrôle
Pour la réalisation de notre robot, afin de ne pas avoir de fil volant qui pourrait se débrancher nous avons réaliser une carte électronique sur le logiciel Eagle. Cette carte qui comporte le microcontrôleur permet de connecter et contrôler les capteurs et actionneur qui sont tous reliés à la carte. Grâce à cette carte cela nous permet d'alimenter facilement tous les composant à la tension voulue.
Lorsque la carte a été imprimé, et après la soudure des composant traversant et CMS sur la carte, nous sommes passer en phase de test pour vérifier que l'ensemble des partie de la carte fonctionnait, l'absence de court circuit ainsi que la continuité des pistes et des vias, puis la bonne transmission de données à l'aide du programmateur et du module Xbee pour bien récupérer les informations en utilisation sans fil sur l'ordinateur.
Actionneurs
Déplacement
Système propulsion
Crève-Ballon
Pour la crevaison du ballon, nous avons utilisé un disque souple en plastique qui est piloté par un moteur à courant continu, ainsi qu’un servo-moteur. Aussi, nous avons réalisé un mât comme support pour l’ensemble décrit ci-dessus. Celui-ci nous sert aussi à positionner le support de la caméra PIXY. Le ballon est maintenu par un câble qui serre le ballon au niveau du nœud et un élastique qui est attaché au câble qui maintient le ballon pour que celui-ci reste en place tout le long du match.
Lien vers la vidéo de la crevaison du ballon :
https://drive.google.com/file/d/15fuKFu1aPadkrwBS-FIqvhHlt_E1LWdR/view?usp=sharing
Exemple programme crevaison du ballon (fonctionnel)
#include <Servo.h>
Servo monservo;
//int bp;
void setup(){
//pinMode(3, OUTPUT);
DDRK|=(1<<PK7);
//pinMode(2, INPUT);
DDRH&=~(1<<PH5);
DDRH&=~(1<<PH4);
monservo.attach(9); // utilise la broche 9 pour le contrôle du servomoteur
monservo.write(0); // positionne le servomoteur à 0°
delay(5000);
//Serial.begin(9600);
}
void loop(){
//bp=digitalRead(2);
//Serial.println(bp);
//if (bp==1){
monservo.write(120);
//delay(5000);
PORTK|=(1<<PK7);
delay(500);
PORTK&=~(1<<PK7);
//delay(1000);
monservo.write(0);
delay(10000);
//bp=0;
//}
//else {}
}
Je sais plus
Détection de la balle
De près : Caméra Pixy 2
De loin : Lidar
Détection D'angle : Magnétomètre
Détection d'obstacle : VL53L1X
Le robot ne peut pas sortir de l'aire de jeu, il y a des murs. Pour éviter toutes casse matérielle lors du déplacement de notre robot il faut que nous puissions les détecter.
Pour cela nous avons utiliser un capteur de distance ToF (Time of flight), les VL53L1X.
Ils ont l'avantage d'être petits et arrivent à détecter à de courtes distances des distances et allant jusqu'à 2 m avec une bonne précision.
Ces capteurs se branchent sur un bus I2C (SDA-SCL) et sont alimentés en 5 V sur la broche VIN.
À l'initialisation, ces capteurs nécessite un changement d'adresse, on utilise la broche Xshut (tout ou rien) du capteur connecter à une broche logique du microcontrôleur.
Les VL53L1X ont 3 modes de fonctionnement un mode short, medium et long (mode par défaut). Pour notre utilisation on utilisera le mode short (distance max = 1.3 mètres).
Avec notre carte de contrôle nous avons la possibilités d'en utiliser 4, ils sont connecter à la carte via un connecteur Molex.
On a décidé de positionner un capteur à l'avant droite et l'autre à l'avant gauche du robot.
On place ces capteurs sur des petit support amovible pour permettre de les déplacer si besoin, ces support protègent également les capteurs en cas de collision lors des tests par exemple.
Pour utiliser ce capteur sur le logiciel Arduino il est nécessaire d'inclure la bibliothèque du capteur (VL53L1X by Polulu).
Lien vidéo correspondant au programme ci-dessous (vidéo réaliser sur le prototype) : détection obstacle
Information supplémentaires sur le capteur : datasheet.
Exemple programme détection des obstacles avec un capteur (fonctionnel)
#include <Wire.h>
#include <VL53L1X.h>
VL53L1X sensor_1;
int pinMoteurG = 8;
int pinMoteurD = 7;
int pinMoteurPWMG = 9;
int pinMoteurPWMD = 6;
int VmG;
int VmD;
void setVitesse (int VmG , int VmD) {
if ( VmG < 0 ) {
digitalWrite(pinMoteurG,HIGH);
VmG = -VmG;
} else {
digitalWrite(pinMoteurG,LOW);
};
if ( VmD < 0 ) {
digitalWrite(pinMoteurD,HIGH);
VmD = -VmD;
} else {
digitalWrite(pinMoteurD,LOW);
};
analogWrite(pinMoteurPWMG, 2 * VmG + 10);
analogWrite(pinMoteurPWMD, 2 * VmD + 10);
}
void arret () {
VmG = 0;
VmD = 0;
analogWrite(pinMoteurPWMG, VmG);
analogWrite(pinMoteurPWMD, VmD);
}
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
Wire.begin();
Wire.setClock(400000); // use 400 kHz I2C
//XSHUT sensor_1
pinMode(4,OUTPUT);
digitalWrite(4,LOW);
delay(100);
digitalWrite(4,HIGH);
sensor_1.setTimeout(500);
if (!sensor_1.init())
{
Serial.println("Failed to detect and initialize sensor_1!");
while (1);
}
sensor_1.setDistanceMode(VL53L1X::Short);
sensor_1.setMeasurementTimingBudget(50000);
sensor_1.startContinuous(50);
sensor_1.setAddress(41);
pinMode(pinMoteurG, OUTPUT);
pinMode(pinMoteurD, OUTPUT);
pinMode(pinMoteurPWMG, OUTPUT);
pinMode(pinMoteurPWMD, OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
sensor_1.read();
Serial.print("range: ");
Serial.print(sensor_1.ranging_data.range_mm);
Serial.print("\tstatus: ");
Serial.print(VL53L1X::rangeStatusToString(sensor_1.ranging_data.range_status));
Serial.print("\tpeak signal: ");
Serial.print(sensor_1.ranging_data.peak_signal_count_rate_MCPS);
Serial.print("\tambient: ");
Serial.print(sensor_1.ranging_data.ambient_count_rate_MCPS);
Serial.println();
Serial.print("n° Adress :");
Serial.print(sensor_1.getAddress());
if (sensor_1.timeoutOccurred()) { Serial.print(" TIMEOUT"); }
Serial.println();
if (sensor_1.ranging_data.range_mm > 300) {
setVitesse (50 , 50);
}else if (sensor_1.ranging_data.range_mm < 300) {
setVitesse ( 25 , 25);
}else if (sensor_1.ranging_data.range_mm < 200) {
arret ();
delay(100);
setVitesse ( 25, -25 );
}
}
Balle attrapé / non attrapé
Pour savoir si une balle a été attrapé, nous avons utiliser un capteur VL53L1X qui nous permettra de savoir si une balle est présente ou non.
Détection de la ligne médiane
Pour la détection de la ligne médiane, nous avons choisi d'utiliser des capteurs CNY70. Ces capteurs sont composés d'une LED infrarouge et d'un transistor, le principe est que la LED va émettre une lumière et en fonction de la couleur sur laquelle va réfléchir la lumière, il y aura plus ou moins de courant qui passera dans le transistor. Le noir étant la couleur qui réfléchit le moins et le blanc celle qui réfléchit le plus.
Pour ce qui est de l'emplacement des capteurs, nous avons choisi d'en utiliser 8 et de les placer comme le montre l'image à gauche, les capteurs sont espacés de 2.5cm, il sont reliés à des comparateurs afin d'avoir des données numériques et non analogiques. Les sorties des comparateurs sont ensuite reliées à des portes logiques ET à quatre entrées, les sorties des quatre comparateurs reliés aux quatre capteurs de gauche sont reliés au quatre entrées de la Porte ET, même chose pour les quatre capteurs de droites qui sont aussi reliés à une port ET à quatre entrées. On a décidé de procéder de cette manière car lorsque les quatre capteurs de gauche ou de droite sont tous activés alors on est sur de détecter la ligne médiane et non une ligne du terrain.
Voici le schéma électronique :
La borne 1 sert à relier l'alimentation (+5V), la borne 2 pour le GND, les bornes 3,5,6 et 7 sont reliés au 4 capteurs de gauche et les bornes 8,9,10 et 11 sont reliés au 4 capteurs de droite et la borne 12 est la sortie qui renverra une tension logique au microcontrôleur indiquant l'état des capteurs
Voici le board du circuit précédent créer sur Eagle :
Communiquer : Module Xbee
Assemblage pièces du robot
Pièce imprimante 3D
- Support VL53L1X de gauche
- Support VL53L1X de droite
- Support caméra Pixy 2
- Mât de fixation pour le ballon
- Butée du système de propulsion droite
- Butée du système de propulsion gauche
Travaux restants
Voici ce que notre robot peut effectuer avec la programme réaliser à la fin de nos séances de travail : Vidéo de lancer de la balle
Pour avoir un robot fonctionnel à la compétition, il reste du travail à effectuer :
- Les parties mécaniques sont entièrement réaliser, il reste à fixer le tout.
- Il faut terminer les tests des différents capteurs avec la carte électronique du microcontrôleur.
- Il faut réaliser les programmes de chaque parties encore non-existant ou non-fonctionnel et tous les assembler.
- Après ceci, il faudra faire des tests afin d'avoir les meilleurs réglage possible.
