COUPE ROBOTIQUE DES IUT : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
Ligne 65 : Ligne 65 :
  
 
=={{Vert|Solutions techniques}}==
 
=={{Vert|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 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é.
+
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é.
 
={{Rouge|Etude et Réalisation des Differentes Parties}}=
 
={{Rouge|Etude et Réalisation des Differentes Parties}}=
 
=={{Vert|Alimentation et Régulation}}==
 
=={{Vert|Alimentation et Régulation}}==

Version du 24 janvier 2018 à 11:11

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

Ce projet consiste à réaliser un robot pour participer à la coupe de robotique des GEII.Pour fabriquer ce robot nous devons respecter un cahier des charges défini par le : http:(...) Le principe de ce concours est 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



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
  • Tests en conditions réeles sur les moteurs montés sur le robot ( U=12V ) :
Résistance électrique 4 ohm
Courant à vide 0.28 A
Courant en charge nominale robot 0.7A
Courant en charge au démarage robot 1.6A
  • Consommation maximum en courant pour les 2 moteurs du robot :

Imax = 2*1.6A = 3.2A


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
  • Utilisation d'un Convertisseur DC/DC

Nous avons utilisé une carte faite par des étudiants des années précédents.


Cette carte contient deux régulateurs à découpage:

  1. LM2596S fournit 5V ( 3A max )
  2. XL6009E1 qui fournit 12V ( 4A max )

Les régulateurs fournissent largement le nécessaire en tension et courant.
Pour le semestre suivant nous prévoyons à réaliser une autre carte d'alimentation, qui sera plus compacte.

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.

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 actionant les entrées logique C et D ainsi que Venable (PWM) pour varier la tension d'alimentation des moteurs (0-12V).

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.

Arduino Shield6.png


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 par odométrie, c'est à dire que la position est obtenue par intégration de petits déplacements. L'intérêt de l'odométrie est qu'elle est assez simple à mettre en oeuvre et qu'elle est fiable. Par contre, quand on intègre les déplacements, on intègre aussi l'erreur ce qui fait que l'erreur de position croît avec le temps.

Entre deux lectures, on peut savoir de combien s'est déplacée chaque roue codeuse et il faut à partir de cela en déduire la position du robot.


GrapheASD.png

Appelons ∆d et ∆g les distances (en mm) parcourues respectivement par les roues droites et gauches entre deux lectures des LM soit un intervalle de temps Te. Connaissant la position du robot à l'instant n-1, on cherche la pose à l'instant n.


4545.png

On a donc : ∆moy_n = (∆d_n + ∆g_n)/2

∆dif_n = ∆d_n - ∆g_n

∆x_n = ∆moy_n cos(theta_n-1)

∆y_n = ∆moy_n sin(theta_n-1)

∆theta_n = ∆dif_n/L


x_n = x_n-1 + ∆x_n

y_n = y_n-1 + ∆y_n

theta_n = theta_n-1 + ∆theta_n