Position et détection d'obstacle

Présentation

Exemple de Robot

Notre projet à pour but de concevoir un robot pour participer à La coupe de France des IUT GEII à CachanDans cette partie nous allons nous concentrer sur la position du robot sa navigation et sa faculté a éviter les obstacles décrit dans le règlement.

Navigation

Codeur rotatif

Afin de connaitre la position des roues, de savoir de combien elles ont tournés nous utiliserons un codeur rotatif.Les codeurs rotatifs sont un type de capteurs permettant de délivrer une information d'angle, en mesurant la rotation effectuée autour d'un axe.L'information de vitesse peut alors être déduite de la variation de la position par rapport au temps. Plus le codeur rotatif tourne lentement, plus la déduction de vitesse perd en précision.

Il en existe 2 principaux types :

• Le codeur rotatif incrémental qui ajoute ou soustrait (selon le sens de rotation) une unité à un compteur à chaque rotation supérieure à la résolution du capteur. Le compteur est généralement remis à zéro lorsque l'appareil est allumé. C'est le cas de la souris d'ordinateur à boule.

• Le codeur rotatif absolu qui intègre son propre compteur. Ce genre de capteur est généralement calibré et initialisé une seule fois, et il conserve normalement sa valeur lors de l'arrêt de l'appareil. C'est le cas des compteurs kilométriques des automobiles à la différence du "compteur journalier" qui peut être remis a zéro par l'utilisateur.

Nous utiliseront des codeurs incrémentaux fixé sur les axes des deux moteur ce qui nous permettra d'asservir la rotation des robot c'est à dire que nous pourrons avoir un retour sur les commande du moteur de plus on connaîtra l'angle pris par le robot par rapport a sa position de départ. En effet ce genre des capteur est plus précis par rapport à l'autre.

équation de positionnement

Le positionnement du robot en intégration les information reçu des codeur incrémentaux qui constituera des petits déplacements avec les quelle on pourra nous positionner.

Il y a deux manières d'approximer la trajectoire parcourue par le robot sur un laps de temps :

• En utilisant des segments de droites. On considère alors que le robot va en ligne droite sur toute la période. Ceci revient à supposer que les deux roues ont une vitesse constante et identique sur cet élément de trajectoire. A la fin de cet élément de trajectoire, on corrige l'orientation du robot en fonction de la différence de distance parcourue par les deux roues.

• En utilisant des arcs de cercles . On considère alors que le robot se déplace et change d'orientation en suivant un arc de cercle pendant le temps . Ceci revient à considérer que chacune des roues a une vitesse constante sur la période mais que les vitesses des 2 roues ne sont pas identiques.

On peux alors cacluler les positionement en calculant la distance parcouru et le temps de trajet des 2 roues :

On peut alors accéder à la position du robot (coordonnées x,y)

Réalisation de la roue codeuse

Nous avons pris les mesures du moteur et du châssis imposé pour la compétition afin de fabriquer notre roue codeuse puis nous l'avons représenter sur le logiciel de création de Charly robot. Nous avons choisit des fentes ouvertes sur l’extérieur, c'est a dire pas de contour la taille de la fente est limité par les outils que nous avons une fraise de 2 mm donc la taille de nos fente est de 2 mm une taille minimal permet une précision maximal lors de la rotation. La première roue que l'on a usiner était trop fine et donc pas assez rigide :

première roue usiné

Nous avons donc choisit de tester une roue à deux épaisseurs : l'une plus fine (1 mm) pour la partie extérieur et l'autre plus épaisse pour la partie intérieure de la roue (2 mm). :

deuxième roue usiné

Cette solution étant aussi fragile que la précédente nous avons finalement opter pour une roue à une seul épaisseur de 2mm pour avoir une bonne rigidité et peu de vibration.

Réalisation du montage électronique

le montage Electronique a pour but de récupérer et traiter les signaux obtenus par les optocoupleurs TCUT 1300 pour nous permettre de compter le nombres d’encoche parcouru et connaitre le sens de rotation grâce aux 2 photo-transistor. Nous avons tout d'abord utilisé le montage d'un groupe qui a travaillé sur le projet avant nous, toutefois leur montage n'a pas fonctionner. On a fini par modifié leurs montage afin de corriger les erreurs ce qui a donné le montage suivant :

• Si il y de la lumière émise par la photodiode et reçu par le photo-transistor on a un état logique "1" => ce qui correspond a une encoche.

• Si il y a un obstacle entre la photodiode et le photo-transistor on a un état logique "0" => pas d'encoche.On obtiendra donc un signal de cette allure :

Phase de test

Le problème rencontré est que lorsque la roue codeuse tournait rapidement on ne détecté plus l'encoche : état 0 Pour résoudre ce problème on a utilisé à la place d'une résistance fixe une résistance variable qu'on a tester avec différentes valeur à fin d'avoir un rapport cyclique le proche possible de 50% en vitesse maximal. En effet ce problème est du à la présence d'une capacité au montage donc si la roue codeuse tourne rapidement le circuit ne peux plus détecter le "0" ce qui s'explique par la constante de temps R*C trop petite, donc il faut augmenté R à fin que le temps de réponse soit plus rapide. En effet si la résistance est trop faible la tension n'aura pas le temps de descendre puis remonter donc elle reste à l’état haut .

REMARQUE :

• On place un condensateur en parallèle de chaque photo-transistors pour filtrer les pics qui pourraient venir perturber le fonctionnement des capteurs.

• On a aussi insérer un condensateur de découplage à fin de filtrer les pic provenant de l'alimentation.

Réalisation de la carte

Suite à la phase de test nous avons commencé la conception de la carte

Le schéma:

Schéma de la carte roue codeuse

Le board :

Board de la carte roue codeuse

Changement du Semestre 4

Durant le quatrième semestre nous avons procédé a la correction du schéma et du board, en effet pendant la phase de test de la carte ci-dessus nous nous sommes aperçu que certain composant été mal positionné nous avons donc procédé a des modification.

ci-dessous le schéma et le board définitif:

Le schéma :

Schéma corrigé de la carte roue codeuse

Le board :

Board corrigé de la carte roue codeuse

Tout sera relié à un microcontrôleur en l'occurrence c'est unATtiny44 (mais on a réaliser les testes en utilisant une carte arduino Uno) car ce microcontrôleur présente l'avantage d’être peu onéreux et le nombre de pin qui nous suffit largement (voir annexe pour la documentation )

Comptage du nombres d’encoche et détermination du sens de rotation

Il faut faire un programme qui, à partir des signaux obtenu dans la partie montage électronique compte le nombre d’encoches tout en tenant compte du sens de rotation !
Il faut tout d'abord initialisé un sens comme le sens direct qui à chaque encoche parcouru incrémentera le compteur et diminuera à chaque encoche parcouru dans le sens inverse .
Pour détecter dans quelle sens la roue tourne, on compare le retard juste après la changement (on peut comparé juste après la phase montante ou après la phase descendante mais pour une meilleur précision on compare pour les 2 phases) d'état du signal A par rapport aux signal B de l’optocoupleur, en effet il y a 4 cas de figures possibles :

Exploitations des 2 signaux d'un optocoupleur

1. Le signal A = 1 et B = 1 ==> sens direct ==> on incrémente
   
2. Le signal A = 1 et B = 0 ==> sens indirect ==> on diminue
   
3. Le signal A = 0 et B = 1 ==> sens indirect ==> on diminue
   
4. Le signal A = 0 et B = 0 ==> sens direct ==> on incrémente
   

Maintenant il faut écrire le programme :

• Dans un premier temps on a réaliser un programme en utilisant les fonctions que la bibliothèque d'Arduino nous offre pour tester et bien comprendre.
  

Voici donc le premier programme:

Programmation des registres pour compter les encoches

volatile  int s = 0;

voidsetup() {

  Serial.begin(9600);

  attachInterrupt(0, counnt, CHANGE);

}

voidloop() {

  Serial.println(s);

}

voidcount() {

  if (digitalRead(2) == HIGH)

  { if (digitalRead(3) == HIGH)      s++ ;

    else      s-- ;

  }

  else  {

    if (digitalRead(3) == HIGH) s-- ;

    else s++ ;

  }

}

• Puis pour essayer d’améliorer ce programme on a programmer en utilisant les registres directement à fin d’améliorer la vitesse d'exécution du microcontrôleur, en effet il y a une augmentation d'un facteur 30 de la vitesse d’exécution en programmant les registres .
  

Voici donc le programme:

Programmation des registres pour compter les encoches

#include<avr/io.h>
volatile  int s = 0;
ISR(INT0_vect)    // programme d'interruption : le programmeprincipal est interrompu,
{ //l'interruption exécutée et ensuite le programme principal continu normalementson exécution
  if (PORTD & (1 << PIND2) == HIGH)
  { if (PORTD & (1 << PIND3) ==HIGH)       s++ ;
    else       s-- ;
  }  else    {
    if (PORTD & (1 << PIND3) ==HIGH)s-- ;
    else s++ ;
  }
}  
voidsetup() {
  Serial.begin(9600);
  cli();          // arrêt des interruptions  
  EICRA=0x01;     // mode de déclenchement de l'interruption: change   EIMSK=0x01;  
  // choix des interruptions actives :interruption 0 
  sei();          // autorisation des interruptions
  } 
void loop() {   Serial.println(s);  }

programme finale : Obtention des coordonnées x , y , l'angle

Programme comptant les encoches

 

#include<avr/io.h>

#include<math.h>

volatile  int d = 0;

volatile  int g = 0;

doubledelta_moy = 0;

doubledelta_dif = 0;

doubledelta_angle = 0;

doubledelta_x = 0;

doubledelta_y = 0;

doubleangle = 0;

doublex = 0;

doubley = 0;

doublephi = 0;

doubledelta_phi = 0;

doubledifference_encouche_droite = 0;

doubledifference_encouche_gauche = 0

                                    ; doubleCOEF_a_trouver = 0;

constdouble pi = 3.14;

voidsetup() {

  Serial.begin(9600);  cli();          // arrêt des interruptions

  EICRA = 0x05;   // mode de déclenchement de l'interruption :change

  // ISC00 =1      // ISC01 =0      // ISC10 =1       // ISC11 = 0

  EIMSK = 0x03;   // choix des interruptions actives :interruption 0 & 1

  sei();          // autorisation des interruptions

}

ISR(INT0_vect)    // programm ed'interruption : le programmeprincipal est interrompu,

{ //l'interruption exécutée et ensuite le programme principal continu normalementson exécution

  if (PORTD & (1 << PIND2) ==HIGH)  {

    if (PORTD & (1 << PIND3) ==HIGH)      g++ ;

    else      g-- ;

  } else   {

    if (PORTD & (1 << PIND3) ==HIGH)g-- ;

    else g++ ;

  }

}

ISR(INT_vect1)    // programme d'interruption : le programmeprincipal est interrompu,

{ //l'interruption exécutée et ensuite le programme principal continu normalementson exécution

  if (PORTD & (1 << PIND3) ==HIGH)   {

    if (PORTD & (1 << PIND2) ==HIGH)      d++ ;

    else      d-- ;

  } else   {

    if (PORTD & (1 << PIND2) ==HIGH)d-- ;

    else d++ ;

  }

}

voidloop() {

  difference_encouche_droite = d -difference_encouche_droite;

  difference_encouche_gauche = g -difference_encouche_gauche;

  delta_moy = ((g + d) / 2) * COEF_a_trouver;

  delta_dif = d - g;

  delta_phi = int(delta_dif / 23.3) % int(2 *pi);

  delta_x = delta_moy * cos(delta_phi);

  delta_y = delta_moy * sin(delta_phi);

  x = delta_x + x;  y = delta_y + y;

  phi = int(delta_phi + phi) % int(2 * pi) ;

  Serial.print("g="   );

  Serial.print(g);

  Serial.print("et d =");

  Serial.println(d);

  Serial.print("et phi =");

  Serial.println(phi);//   il faut mieux mesurer L (distance entre les2 rue )// demande au prof la conversion en int pour le modulo

}

Transmissions des coordonnées vers la carte principal

Contrainte et choix de support de transmission

Les contraintes :

• Nous avons besoin d'un support de transmission rapide et précis quelque soit la vitesse de la roue codeuse.

• notre carte communique avec la carte mère à fin d'envoyer les coordonné.

• le type de réseau qu'on recherche est une liaison maître-esclave : c'est notre carte qui envoi les information.

Sachant que notre microcontrôleur ne supporte que les protocoles i²c et SPI, on se limite donc au I²C et SPI :

En comparant les deux peu voir que:

• le protocole i2c est lent ce qui nous expose a des erreur de positionnement.

• le SPI est est plus rapide ce qui nous nous amène a le choisir plutôt que le i2c .

Fonctionnement du protocole SPI

SPI ( Serial Peripheral Interface) est une liaison série synchronisé à l'aide d'une horloge, de type maître-esclave.

Le bus SPI est composé de 4 signaux logiques :

1. SCLK — Serial Clock, Horloge (généré par le maître) permet de synchronisé la transmission de donnés .
2. MOSI — Master Output, Slave Input (généré par le maître et envoyé à l'esclave )
3. MISO — Master Input, Slave Output (généré par l'esclave et envoyé au maître )
4. SS — Slave Select, Actif à l'état bas (généré par le maître)

Donc en gros on met SS = 0 puis à l'aide de MISO on envoi x,y,phi puis on remet SS = 1 .

Méthodes pour programmer un ATtiny44a

Il y a plusieurs façon de programmer un microprocesseur voici les deux plus courantes :

• Généralement il est plus facile pour un débutant travaillant sous Windows d'utiliser un IDE telle que atmel studio qui bien fait mais très long lors de compilation.

• Sous Linux il est plus rapide et plus efficace de programmer un microprocesseur à l'aide d'un terminale en suivant plusieurs étape :

• • • • • étape de compilation

• se déplacer dans le répertoire de votre programme : cd /home/ge1/deElec/

• CONFIGURER QUELLE µc avr-gcc -Wall -g -Os -mmcu=attiny44 -o prog.o prog.c && avr-objcopy -j .text -j .data -O ihex prog.o prog.hex

• transférer le programme avrdude -c avrisp2 -P usb -p t44 -U flash:w:"prog.hex"

Programme test de fonctionnement

Programme pour faire clignoter une led:

Programme test

#define F_CPU 1000000UL#include <avr/io.h>#include <util/delay.h>int main(void){DDRB|=1<<PB1;  while (1)  {	PORTB^= 1<<PB1; 	_delay_ms(300);  }
== Programme de transmission de donné entre une carte arduino et un attiny44 ==


Il y a un master & un slave :


=== Le master : ===


{{boîte déroulante/début|titre=Programme du master }} <source lang="java">

#include <SPI.h> //master void setup (void) 
{ 
Serial.begin(115200);
    digitalWrite(SS, HIGH);
    // ensure SS stays high for now
    // Put SCK, MOSI, SS pins intooutput mode
    // also put SCK, MOSI into LOWstate, and SS into HIGH state.
    // Then put SPI hardware into Mastermode and turn SPI on
    SPI.begin ();
    // Slow down the master a bit
   SPI.setClockDivider(SPI_CLOCK_DIV128);
    }
    // end of setup void loop (void) 
{
  uint8_t c,a;
    // enable Slave Select
    digitalWrite(SS, LOW);
      // SS is pin 10
    // send test string
    a=SPI.transfer (10);
    digitalWrite(SS, HIGH);
    Serial.println(a,DEC);
    // disable Slave Select
    delay (100);
    // 1 seconds delay
   }

le slave :

Programme du slave

#define F_CPU 1000000UL


#include <avr/io.h>  
#include <avr/interrupt.h>  
#include <util/delay.h>
    MCUCR|=1<<ISC00; 
    MCUCR|=1<<ISC01; ISR (INT0_vect)
  {
     static uint8_t x=0;
       x++;
  }
      ISR (USI_OVF_vect)
  {
     static uint8_t i=0;     // valeur a transmettre pour le coup suivant
     USIDR=i;     //acquittement de l'ovf 
     USISR|=1<<USIOIF;     // test de transmission
     i+=3;
  }
      int main (void) }      //MISO comme sortie      
      DDRA|=1<<PA7;      // mode 3wire
      USICR|=1<<USIWM0;      // clock
      USICR|=1<<USICS1;      //interruption
      USICR|=1<<USIOIE;
      sei();      // acquittement d'un ovf éventuel
      USISR|=1<<USIOIF;
      while (1)      {        // attente du SS
        while((PINA&(1<<PA7))!=0);       // fin du SS
        while((PINA&(1<<PA7))==0);       // remise a zero du compteur de front
        // permet de resynchroniser en cas de pb 
       // a faire plutôt par interruption sur front de SS
        USISR &=0b11110000;     
     } 
 }

Assemblage de données

Après avoir réussi à faire un transmission de donné en SPI entre arduino et ATtiny44 on va tenter de rassembler les éléments permettant d'avoir les coordonné :

Simulation des roues codeuse en reliant un GBF au pin : PB2

Programme comptant les encoches

#define F_CPU 1000000UL 
#include <avr/io.h> 
#include <avr/interrupt.h> 
#include <util/delay.h>
   volatile uint8_t x=0;
   ISR (USI_OVF_vect) {      // valeur a transmettre pour le coup suivant
   USIDR=x; }
 ISR (INT0_vect) {    // valeur a transmettre pour le coup suivant
      x++; }   
int main (void) {
 	MCUCR|=1<<ISC00;
 	MCUCR|=1<<ISC01;    // RISING EDGEINT0
 	GIMSK|=1<<INT0;     //MISO comme sortie
         DDRA|=1<<PA5;      // mode 3wire
        USICR|=1<<USIWM0;   // clock
        USICR|=1<<USICS1;     //interruption
        USICR|=1<<USIOIE;
       sei();     // acquittement d'un ovf eventuel
     USISR|=1<<USIOIF;
     while (1)     {       // attente du SS
       while((PINA&(1<<PA7))!=0);       // fin du SS
       while((PINA&(1<<PA7))==0);       // remise a zero du compteur defront
                                       // permet de resynchroniser encas de pb
                                       // a faire plutot parinterruption sur front de SS
       USISR &=0b11110000;
     }
 }

Utilisation de l'algorithme pour obtenir les position définit précédemment

c'est la partie finale du projet que l'on a malheureusement pas pu terminer :

insérer l'algorithme et les différentes parties plus hauts pour avoir les coordonnés polaire et l'angle du robot.

à compléter

#include <avr/io.h> 
#include <math.h>  
volatile  int d=0;
volatile  int g=0;


/*double delta_moy =0;
 double delta_dif =0;
double delta_angle =0;
double delta_x =0;
double delta_y =0;
double angle =0;
double x =0;
double y =0;
double phi =0;
double delta_phi = 0;
double difference_encouche_droite =0;
double difference_encouche_gauche =0;
double COEF_a_trouver=0;
const double pi = 3.14;
*/void setup()
  {  Serial.begin(9600);
        cli();                // arrêt des interruptions  EICRA|=0x05;
                              // mode de déclenchement de l'interruption : change
       // ISC00 =1
       // ISC01 =0
       // ISC10 =1
       // ISC11 = 0
  EIMSK|=0x03;
                    // choix des interruptions actives : interruption 0 & 1
  sei();           // autorisation des interruptions}
  ISR(INT0_vect)    // programme d'interruption : le programme principal est interrompu,


{  
               // l'interruption exécutée et ensuite le programme principal continu normalement son exécution
if ((PORTD&(1<<PIND2))!=0)  


{
    Serial.println("h");
    if ((PORTD&(1<<PIND3))!=0)
      g++ ;
    else
       g-- ;
  }
  else
   {
       Serial.println("l");
    if ((PORTD&(1<<PIND3))!=0)g++ ;
    else g-- ;
     } 
   } ISR(INT_vect1)    // programme d'interruption : le programme principal est interrompu,{                 // l'interruption exécutée et ensuite le programme principal continu normalement son exécution  if (PORTD&(1<<PIND3)!=0)  {      if (PORTD&(1<<PIND2)!=0)      d++ ;    else       d-- ;  }  else   {        if (PORTD&(1<<PIND2)!=0)d-- ;    else d++ ;  }   } void loop(){/*  difference_encouche_droite=d-difference_encouche_droite;  difference_encouche_gauche=g-difference_encouche_gauche;  delta_moy =((g+d)/2)*COEF_a_trouver;  delta_dif =d-g;  delta_phi=int(delta_dif/23.3) %int(2*pi);  delta_x=delta_moy*cos(delta_phi);  delta_y=delta_moy*sin(delta_phi);  x=delta_x+x;  y=delta_y+y;  phi=int(delta_phi+phi) % int(2*pi) ;*/int tmp=g;  Serial.print("g="   );  Serial.println(tmp);//  Serial.print("et d =");//  Serial.println(d);  delay(200); // Serial.print("et phi ="); // Serial.println(phi);  /* il faut mieux mesurer L (distance entre les 2 rue )    demande au prof la conversion en int pour le modulo     trouver la coefficient de réduction j'ai mis à un     


*/}

Annexes

Pages en relation avec le positionnement

• http://www.telecom-robotics.org/wiki/Tutoriels/AsservissementParPidEtPositionnementParRouesCodeuses/CalibrationDuPositionnement
• http://manubatbat.free.fr/doc/positionning/node5.html
• http://www.pobot.org/Asservissement-d-un-moteur-a.html
• http://www.vishay.com/docs/84756/tcut1300.pdf
• http://www.atmel.com/Images/Atmel-8127-AVR-8-bit-Microcontroller-ATtiny4-ATtiny5-ATtiny9-ATtiny10_Datasheet.pdf