RobotiqueCoupeGEII

Présentation du projet

Cahier des charges / règlement de la compétition

Aire de jeu

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

schéma aire de jeu

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

Prototype

Prototype robot avec actionneur fonctionnel

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.

Solution adoptée

Alimentation / Régulation

Batterie fournie

abaisseur de tension

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

Schéma eagle connecteur ISP

Microcontroleur ATmega 2560 16MHz

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.

Schéma ATmega2560

Programmateur connecté à la broche ISP

Carte Capteur / microcontrôleur

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.

• Schéma de la carte
• Board de la carte

Schéma eagle de la carte électronique

Board de la carte électronique

Face Top de la Carte électronique avec les branchements

Face Bot de la carte électonique

Actionneurs

Crève-Ballon

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

Capteurs

Détection des balles

De près : Caméra Pixy

Caméra Pixy2 montée sur le robot

Balle de tennis dans le logiciel PixyMon

Pour détecter les balles de tennis qui seront proches de notre robot nous avons décidé d'utiliser une caméra Pixy 2.
Grace à la caméra nous pouvons obtenir la position en X et en Y de la balle ce qui nous permet via un programme arduino de diriger le robot vers la balles détecté.
Cette dernière est alimentée en 5V et est également connectée à notre microcontrôleur.
Pour pouvoir utiliser la caméra sur arduino, nous avons eux besoin de télécharger et d'importer la librairie suivante sur arduino: Librairie

[Développer]

Exemple programme détection de balles avec caméra Pixy2 (fonctionnel)

#include <Pixy2.h>

// This is the main Pixy object
Pixy2 pixy;

void setup()
{
  Serial.begin(115200);
  Serial.print("Starting...\n");
 
  pixy.init();
}

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<158){ // 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>158) {
  	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<104){ // si la balle est plus en haut par rapport au milieu de l'axe, on tourne à gauche
    	Serial.println("avancer doucement");
  	}
    
  	if (pixy.ccc.blocks[i].m_y>104) {
  	Serial.println("avancer rapidement"); // si la balle est plus en bas par rapport au milieu de l'axe, on tourne à droite
  	}

  }

//si on ne détecte pas la balle
else {
  Serial.println("chercher la balle");
 



}

}

Détection d'obstacle : VL53L1X

Capteur Lidar VL53L1X / Nom broche

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 des Lidar, 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 lidars 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.
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).

[Développer]

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.

Position capteur VL53L1X pour la présence de balle

Détection de la ligne médiane

Capteur CNY70

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.

Emplacement capteurs

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 :

Schéma électrique circuit capteur CNY70

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 :

Board circuit détection de la ligne médiane

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