COUPE ROBOTIQUE DES IUT

RobotGEII 16-17

                                               Sommaire:          

1. Présentation
   • Présentation du projet
   • Cahier des charges fonctionnel
   • Solution techniques
2. Étude et Réalisation des Différentes Parties
   • Alimentation et Régulation
     • Batterie
     • Moteurs de roues
     • Régulation de la tension d'alimentation
   • Contrôle des moteurs CC par un dual H-Bridge (L298P)
     • Principe de fonctionnement d'un H-Bridge (PONT-H)
     • Le composant L298N
     • Tests effectués avec un SHIELD Arduino (L298P)
     • Mode PWM
   • Positionnement du robot :Explication du principe
     • Approximation par des segments de droites
   • Estimation de la position du robot
     • Étude et Réalisation Carte Encodeurs
     • Roue codeuse
     • Valeur reçu par les capteurs
     • Interruption et timer
     • suivons une ligne droite
     • suivons une consigne
   • Détection de balles de tennis
   • Caméra
     • Choix Caméra
     • Caméra CMU cam 5
     • Programme de gestion du cap
   • Mise à l’arrêt du robot et le perçage du ballon
     • Capteur de "Mise à l’arrêt" du robot
     • Système "perçage du ballon"
   • Réalisation Carte des "Entrées et Sorties" et du pont H
     • Objectifs et Composants utilisés
     • Schéma électrique de la carte (Eagle)
     • Routage et Correspondance des pins (Eagle)
     • La commande des Moteurs de Roues(L298N H-Bridge)
     • Les signaux d'entrée et de sortie
     • La carte final et les connecteurs
     • Problèmes rencontrés :
3. Code complet
4. Vidéo de Démonstration
5. Bibliographie/références

Présentation

Présentation du projet

Chaque année la France organise un concours robotique des GEII. Et ce concours exige un cahier des charges à respecter.L'objectif est de fabriquer un robot à partir des kits imposer: comprenant le châssis, les moteurs, les roues et la batterie.Ce robot doit être capable d'envoyer un maximum de balles de tennis dans le camp adverse,sans entrer dans le camp adverse et sans jamais contrôler plus d’une balle à la fois

Cahier des charges fonctionnel

Schéma fonctionnel de degré II

Schéma fonctionnelle 1er degres

Solutions techniques

Pour fabriquer ce robot nous avions plusieurs choix pour procéder à la détection des balles de tennis ainsi que le contrôle et direction du robot vers la ligne noir ... , ainsi qu'au guidage vers la position (zone) du ballon . Nous avons choisi pour guider le robot un système hybride composé de roues codeuses et d'une caméra CMUCam Pixy, spécialisée dans la reconnaissance d'objets. La roue codeuse permettra d'effectuer le début du parcours, et sera remplacée par la caméra, plus précise, une fois la distance de détection atteinte. L'évitement des obstacles sera assuré par trois capteurs infrarouges SHARP GP2Y0A21YK0F, permettant la détection d'objets jusqu'à 80 centimètres de distance, qui, placés à l'avant du robot, permettront l'esquive si un obstacle est rencontré.

Etude et Réalisation des Differentes Parties

Alimentation et Régulation

Batterie

La batterie est imposée :

Tension	12 V
Capacité	7 Ah

Batterie

Moteurs de roues

Les moteurs sont imposés.

• Caracteristique du moteur:

Marque	Dunkermotoren G 42*25
Tension	15V
In	1.45 A
Ifm	10.9A
Rpm	3300 tr/mn

Régulation de la tension d'alimentation

• Les besoins :

Pour Arduino MEGA:
Caractéristiques techniques :

Operating Voltage	5V
Input Voltage (recommended)	7-12V
Input Voltage (limit)	6-20V
Total output current MAX	800mA

On constate qu'il est possible d'alimenter la carte Arduino MEGA directement avec la tension de la batterie ( 12.8V chargée).
Ce n'est toutefois pas recommandé, car le régulateur intégré dans l'Arduino chaufferait, ce qui pourrait endommager le microcontrôleur.

Solutions Alimentation Arduino MEGA:

1. Tension d'alimentation inférieure à 12 V
   
2. Tension régulé de 5V qu'on fait venir directement sur les pattes VCC d'Arduino:
   

Le courant maximum requis: 800mA

Pour les Moteurs de Roues :

1. Tension maximum requise: 15V
   
2. Courant maximum requis: 3.2A
   

Contrôle des moteurs CC par un dual H-Bridge (L298P)

Principe de fonctionnement d'un H-Bridge (PONT-H)

Le pont-H est une structure utilisée en électronique de puissance pour:

1. controle moteurs
2. convertisseurs et hacheurs
3. onduleurs

• Principe: On active les commutateurs avec differents cominaisons pour obtenir le branchement voulu. Le courant va circuler dans un sens ou dans l'autre dans le moteur, ce qui va permettre d'inverser les sens de rotation du moteur. Avec le pont-H on peut également varier la vitesse en modulant la tension aux bornes du moteur.
  

Principe Pont-H

Freinage Magnétique

Combinaisons de commutateurs possibles pour commander un moteur DC:

Sens +	Fermer A et D
Sens -	Fermer B et C
Freinage magnétique	A et C / B et D
Arret libre	A,B,C,D ouverts
Autres combinaison	INTERDITES

Le composant L298N

Nous allons utiliser pour notre robot le composant L298N (traversant) qui a le meme principe de fonctionement que celui en CMS (L298P).Dans la figure suivante on peux voir le cablage du composant, les signaux de commande et les sorties d'alimentation MOTEUR. Dans le tableau nous avons les 4 modes possibles en actionnant les entrées logique C et D ainsi que Venable (PWM) pour varier la tension d'alimentation des moteurs (0-12V).

Operating L298N

Tests éffectués avec un SHIELD Arduino (L298P) (

Pour commander les moteurs nous allons utiliser le pont H L298P [ datasheet].

L298P

Le composant est ci-dessous:

L298P

Pour faire des tests nous avons utlisé le Motor Shield For Arduino. En connectant ce shield à l'arduino nous pouvons commander les deux moteurs (commande du sens et de la vitesse).

L298P

• PWM

Nous allons utiliser le shield en mode PWM, on placera donc les jumpers en conséquence.

L298P

• Borne du moteur

Nous avons deux bornes (bleues) pour connecter les moteurs CC. Les connecteurs mâles derrière sont identiques à celui des bornes bleues.

L298P

• PWRIN

Les moteurs peuvent être alimentés par une alimentation externe lorsque le courant du moteur dépasse les limites fournies par l'Arduino (Il est conseillé de séparer les alimentations d’Arduino et des moteurs). Le changement entre la puissance externe et l'Arduino est mis en œuvre par deux jumpers .

PWRIN: Alimentation externe.
VIN: Alimentation du Arduino.

On placera donc les jumpers d’alimentation sur PWRIN.

On doit avoir quelque chose comme cela:

L298P

• Signal de contrôle Tableau de vérité

E1	M1		E2	M2	Texte de l’en-tête
L	X	Moteur 1 désactivé	L	X	Moteur 2 désactivé
H	H	Moteur 1 en arrière	H	H	Moteur 2 en arrière
H	L	Moteur 1 en avant	H	L	Moteur 2 en avant
PWM	X	Contrôle vitesse PWM	PWM	X	Contrôle vitesse PWM

NOTE:

H: Niveau haut
L: Niveau bas
X: N'importe quel niveau.

Mode PWM

Commande	Moteur	Pin Arduino	Pin Atmega328p	Signification
M1	Gauche	4	PD4	Contrôle du sens de rotation
E1 (PWM)	Gauche	5	PD5	Contrôle de la vitesse de rotation
M2	Droit	7	PD7	Contrôle du sens de rotation
E2 (PWM)	Droit	6	PD6	Contrôle de la vitesse de rotation

• Exemple de code

Nous allons gérer les moteurs par des signaux PWM (-255 a 255), le signe moins (-) indique que le moteur fonctionne en marche arrière, et le signe plus (+) qu'il fonctionne en marche avant. Ce code nous permet de gérer les deux moteurs par la fonction setVitesse(vG,vD). Dans la suite nous allons l'utiliser pour gérer le déplacement du robot.

Code exemple

#include <avr/io.h>//Librairie AVR
#define topPWM 255 //Valeur Max du PWM (8bits)

void initMoteur()//PWM sur PD5 et PD6
{
  //fpwm = fq / (topPWM * p)
  //fpwmi:fréquence du PWM
  //fq:fréquence du quark
  //topPWM: valeur maximum du PWM
  //p:prédiviseur

  //Déclaration de sorties
  DDRD |= (1 << PD4);//Sens du moteur Gauche
  DDRD |= (1 << PD5);//PWM du moteur Gauche
  DDRD |= (1 << PD7);//Sens du moteur Droit
  DDRD |= (1 << PD6);//PWM du moteur Droit

  TCCR0B |= (1 << CS00) | (1 << CS01);//Prédiviseur P=64

  TCCR0A |= (1 << WGM00) | (1 << WGM01);//Mode FAST PWM

  TCCR0A |= 1 << COM0A1;//PWM sur OC0A

  TCCR0A |= 1 << COM0B1;//PWM sur OC0B

  OCR0A = 0;//Valeur de comparaison pour A --> PD6

  OCR0B = 0;//Valeur de comparaison pour B --> PD5
}
void setMoteurG(int16_t vit)//fonction pour gérer le moteur gauche
{
  if (vit < 0)
  {
    vit = -vit;
    PORTD |= (1 << PD4);//Moteur Gauche en arrière
  }
  else PORTD &= ~ (1 << PD4);//Moteur Gauche en avant

  if (vit > topPWM) vit = topPWM;//Si jamais on met une valeur supérieure à 255, la vitesse maximum sera 255

  OCR0B = vit;//Action sur le PWM --> PD5
}

void setMoteurD(int16_t vit)//fonction pour gérer le moteur droit
{
  if (vit < 0)
  {
    vit = -vit;
    PORTD |= (1 << PD7);//Moteur Droit en arrière
  }
  else PORTD &= ~ (1 << PD7);//Moteur Droit en avant

  if (vit > topPWM) vit = topPWM;//Si jamais on met une valeur supérieure a 255, la vitesse maximum sera 255

  OCR0A = vit;//Action sur le PWM --> PD6
}

void setVitesse(int16_t vG, int16_t vD)//cette fonction nous permet gérer les deux moteurs avec "une seule" ligne
{
  setMoteurD(vD);
  setMoteurG(vG);
}

int main()
{
  initMoteur();

 while(1)
 {
  setVitesse(100,100);//Exemple d’utilisation
 }
}

Positionnement du robot: Explication du principe

Approximation par des segments de droites

Le positionnement du robot est obtenu ...

Estimation de la position du robot

Etude et Réalisation Carte Encodeurs

• CAPTEUR TCUT 1300. Nous allons utiliser ce capteur il nous permettra d'avoir le sens et la vitesse de chaque roue.

The TCUT1300X01 is a compact transmissive sensor that includes an infrared emitter and two phototransistor detectors, located face-to-face in a surface mount package.

Code example

• TIMER 1

Suivons une ligne droite

Code de Suivons une ligne droite

Suivons une consigne

ws2812_config.h

Caméra

Choix camera

Nous avons testé 3 cameras différentes, la PiCam, la CMUCam3 et la CMUCam5 Pixy

vignette

Nous avons choisi d'utiliser la CMUCam 5 http:.. site CMU cam 5 car elle est beaucoup plus simple d'utilisation que les deux autres. En effet, celle ci dispose d'une interface dre réglage, PixyMon, lui permettant d'enregistrer les signatures des objets à détecter, et de régler l'acquisition pour restreindre la détection à ces signatures précises. De plus, celle ci dispose d'un support mû par des servomoteurs permettant d'élargir son champ de vision.

Camera CMU cam 5

Tout d’abord nous avons réalisé une simple reconnaissance d'objet grâce au logiciel, il suffit pour cela de sélectionner l'objet en question via une interface, Pixymon. Nous avons ensuite choisi d'utiliser une balise lumineuse pour que la camera la repère le plus loin possible. balise test.

Grâce à cette balise nous avons pu déterminer la distance maximale de détection avec une balise de taille réglementaire. Nous avons ainsi déterminé que la balise était capable d'effectuer une détection à approximativement 6m.

Programme de gestion du cap

Nous avons réalisé un programme permettant de récupérer la position en X d'un objet par rapport à la caméra

Code exemple

//////////////////////////////////////////
// Fonction cap
//////////////////////////////////////////
/**************************************************************

Description : indique le cap à suivre grace à la camera Pixy.
Entrées : Aucune
Sorties : Un int allant de -160 à 160. Une valeur nulle indique
          que la cible se trouve au centre du champ de vision 
          de Pixy. Une valeur positive indique que la cible se
          trouve à droite de Pixy, une valeur négative indique 
          la gauche.
***************************************************************/

int cap()
{
  int compteur1;
  uint16_t blocks;
  /*Récupération des "blocs". Un bloc est une zone rectangulaire 
  définie par Pixy, possedant plusieurs caractéristiques (hauteur,
  position en x/y, couleur...)*/
  blocks = pixy.getBlocks();
  /*Dans le cas ou un bloc est détecté, la caméra renverra la
  position en x de celui ci. La valeur est centrée en zero.*/
  if (blocks)
  {
    return(pixy.blocks[0].x );
  }    
}

Cette fonction a été testée avec le main suivant

Code exemple

#include <SPI.h>  
#include <Pixy.h>

Pixy pixy;

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


int cap()
{
  int compteur1;
  uint16_t blocks;
  blocks = pixy.getBlocks();
  if ((blocks) && (pixy.blocks[0].x != 0))
  {
    return(pixy.blocks[0].x );
  }    
}

void loop()
{ 
  delay(100);
  Serial.println(cap());
  delay(500);
}

Il est nécessaire d'appeler les bibliothèques SPI.h et Pixy.h, et de déclarer et d'initialiser Pixy dans le setup. Ceprogramme ne permet cepandant pas l'usage des servomoteurs, limitant le champ de vision.

Mise à l’arrêt du robot et le perçage du ballon

La mise à l’arrêt du robot et le perçage du ballon doivent avoir lieu simultanément. Cela doit se produire quand le robot est arrivé dans le coin opposé.

Capteur de "Mise à l’arrêt" du robot

Pour se diriger vers le bon coin, le robot est guidé par les roues codeuses et par la caméra qui suit la couleur jaune des balles de tennis présente dans son camp. Maintenant qu'il est guidé dans la bonne direction, nous devons procéder à une mise à l’arrêt rapide des qu il franchi le camp adverse en détectant la ligne noir qui sépare ces deux dernières à l'aide du CNY70 qui nous permettra d’arrêter le robot afin qu'il effectue un retour en arrière pour chercher les autres balles présentent dans son camp .

• Le capteur CNY70 :

Nous pourrons utiliser ce capteur infrarouge pour détecter la couleur du sol.

• Schéma et dimensionement des composants

Emetteur: If = 20mA (Vf = 1.15V), Re = (5V-Vf)/If = 195 ohm.

Collecteur: Ic = 0.5mA (pour If = 20mA, Vce = 5V, d = 2mm), Rc = Vce /Ic = 10 kohm.

Nous devons obtenir les signaux correspondents:

Sol noir/surface non reflechissante	env 0 V
Sol bleu	env 3 V
Sol blanc/surface bien reflechissante	env 5 V

• Schéma électrique, routage en Eagle et fabrication de la carte

Systeme "Perçage du Ballon"

• La partie mécanique

a remplir ...

Système de Contrôle et Lancement du Ballon (Tennis)

Réalisation Carte des "Entrées et Sorties" et du Pont H

Objectifs et Composants utilisés )

• Objectif: concevoir une carte compacte qui va héberger le composant L298N pour le contrôle des moteurs ainsi que toutes les entrées et les sorties.La carte devra s’emboîter sur la carte Arduino MEGA.
  

Les Entrées	Les Sorties
Alimentation (5V)	Moteur Gauche
Alimentation moteurs (12V)	Moteur Droit
Encodeurs (TCUT1300)	Commande perçage Ballon
Camera (CMUCam 5)
3 capteurs obstacles (IR)
Couleur Sol (CNY70)
PWM Moteurs
Sens rotation Moteurs

• Références des composants utilisés:
  

Qté	Nom	Référence Eagle
1	Dual H-Bridge	L298n
1	Radiateur	pour L298n
4	Résistance	1 ohm package 207/10
8	Diode	1N4004
2	Condensateur	E 1.8-4 package 100nF
1	Connecteur ISP	AVR-ISP-6
1	Connecteur	Farnell 6 pins CMS
6	Connecteur	Molex 2 pins 22-27-2021-02 traversant
3	Connecteur	Molex 3 pins 22-27-2031-03 traversant

Schéma électrique de la carte (Eagle)

Schéma Complet

Routage et correspondance des pins (Eagle)

Schéma Complet

La carte finale et les connecteurs

Figure 1 La carte finale

Figure 2 Carte Récto

Figure 3 La carte Vérso avec un défaut

Figure 4 Montage sur le Robot

Problèmes rencontrés:

a remplir

1. après la fabrication de la carte
   
2. après avoir soudé tous les composants
   

De même se servir toujours de l'oscilloscope pour visualiser les différents signaux en temps réel.

Code complet

Pour gérer les différents fonctionalités du robot nous avons utilisé le code suivant:

Code exemple

a remplir .. </source>