Archives pour la catégorie Eurobot

Modèle géométrique pour robots mobiles à roues différentielles

Dans cet article, le modèle géomètrique est une transformation mathèmatique dont les entrées sont les vitesses angulaires des roues (généralement mesurées avec des codeurs) et la sortie est la pose (position et orientation) du robot mobile dans son espace de travail.

Définition du problème

nous nous intéresserons ici aux robots à roues différentielles. Ce type de robot est constitué de deux roues alignées sur le même axe. Ci-dessous, se trouve une illustration de Rat-Courci, un petit robot à roues différentielles conçu pour le concours Micromouse:

Rat-Courci

Le diamètre des roues est donné par D=2.rr est le rayon. La distance entre le centre du robot et les roues est donné par l, la distance entre les roues est alors donnée par 2.l conformément à l’illustration suivante:

Dimensions

Nous supposerons les paramètres suivants connus:


  • r est le rayon des roues

  • l la distance entre le centre du robot et les roues

  • \omega_l et \omega_r sont respectivement les vitesses angulaires instantanées des roues gauche et droite

Geometric_Model

Notre but est de calculer la pose du robot définie selon la figure ci-dessus:


  • x et y sont les coordonnées cartésiennes du robot

  • \psi est l’orientation (position angulaire) du robot

Calcul des déplacements élémentaires

Pour commencer, calculons la vitesse linéaire de chaque roue:

\begin{array}{r c l} v_l &=& r.\omega_l \\ v_r &=& r.\omega_r\end{array}

La vitesse moyenne du robot est alors donnée par:

 v_{robot}=\frac {v_l + v_r} {2}

La vitesse du robot peut être projetée le long des axes x et y:

\begin{array}{r c l} \Delta_x &=& v_{robot}.cos(\psi)&=&\frac {r}{2} ( \omega_l.cos(\psi) + \omega_r.cos(\psi))\\ \Delta_y &=& v_{robot}.sin(\psi)&=&\frac {r}{2} ( \omega_l.sin(\psi) + \omega_r.sin(\psi))\end{array}

La vitesse angulaire du robot est calculée par la différence des vitesses linéaires des roues:

 2.l.\Delta_{\Psi}=r.\omega_r - r.\omega_l

L’équation précédente peut être reformulée:

 \Delta_{\Psi}=\frac {r.\omega_r - r.\omega_l} {2.l}

Le déplacement élémentaire du robot est donnée par la relation suivante:

\left[ \begin{matrix} \Delta_x \\ \Delta_y \\ \Delta_{\Psi} \end{matrix} \right]=\frac{r}{2}.\left[ \begin{matrix} cos(\psi) & cos(\psi) \\sin(\psi) & sin(\psi) \\\frac{1}{l} & \frac{-1}{l}\end{matrix} \right].\left[ \begin{matrix} \omega_r \\ \omega_l\end{matrix} \right]

Position absolue

La position absolue peut être calculée grâce aux équations suivantes:

\begin{array}{r c l}
x_{i}&=&x_{i-1}+\Delta_x \\
y_{i}&=&y_{i-1}+\Delta_y \\
\Psi_{i}&=&Psi_{i-1}+\Delta_{\Psi}
\end{array}

où:


  • x_{i} et y_{i} sont les coordonnées cartésiennes du robot à l’instant i

  • \Psi_{i} est l’orientation du robot à l’instant i

Bien sûr, ce modèle a quelques limitations. Le résultat est fortement dépendant de la précision de la mécanique du robot (ajustements, diamètre des roues, mesures …). Nous supposons ici qu’il n’y a pas de glissement, ce qui n’est pas vrai en pratique. Nous supposons également que la fréquence d’échantillonnage est suffisamment rapide pour garantir que \Delta_x, \Delta_y et \Delta_\Psi pourront être considérés comme des déplacements élémentaires.

Mesure de distance avec un Arduino et des capteurs Sharp

Le but de cet article est d’expliquer comment convertir la tension des capteurs de distance Sharp en une mesure de distance précise. Ces capteurs utilise la technique de triangulation pour estimer une distance. Il s’agit des références GP2Y0A02YK et GP2Y0A21YK avec des distances respetives de 20cm à 150cm et de 10 à 80cm.

Relevé des mesures

Un relevé des mesures a été réalisé avec un pas de 10 mm. Le graphique suivant montre la sortie du capteur GP2Y0A02YK en fonction de la distance. Comme cela est mentionné dans la documentation, le capteur ne peut pas effectuer de mesure en dessous de 20 cm. Cette plage de distance est difficilement utilisable car il est impossible de lever les ambiguïtés.

GP2Y0A02YK

La même méthodologie a été utilisée pour le capteur GP2Y0A21YK:

GP2Y0A21YK

Approximation par un polynome

Grâce à la fonction polyfit de Matlab, la courbe (pour le GP2Y0A02YK) a été approximée avec un polynôme d’ordre 4.  L’approximation couvrant la plage de 14cm à 150cm est illustré ci-dessous:

GP2Y0A02YK_Ap

Pour le capteur GP2Y0A21YK un polynôme d’ordre 5 a été nécessaire:

GP2Y0A21YK_Ap

Résultats

L’approximation pour le cpateur GP2Y0A02YK est donné par l’équation ci-dessous. ADC est la valeur brute retournée par la fonction analogRead() disponible dans les bibliothèques Arduino.

 Distance =  2583.711122992086 - 20.197897855471.ADC + 0.071746539329.ADC^2 -0.000115854182.ADC^3 +0.000000068590.ADC^4

La même approximation pour le capteur GP2Y0A21YK est donnée par l’équation suivante:

 Distance =  200.3775040589502 -2.2657665648980.ADC + 0.0116395328796 .ADC^2 -0.0000299194195.ADC^3 + 0.0000000374087 .ADC^4  -0.0000000000181.ADC^5

En s’appuyant sur ces résultats, une fonction C++ peut facilement être écrite afin de retourner la distance:

/*!
    \brief  make a distance measurement with a Sharp GP2Y0A02YK sensor
    \return the measured distance in mm

*/
float get_Sharp_GP2Y0A02YK_Distance(int PinID)
{
    // Read analog to digital converter value
    float ADCValue = (float)analogRead(PinID);

    // Convert in millimeters and return distance
    return  2583.711122992086
            - 20.197897855471*ADCValue
            + 0.071746539329 *ADCValue*ADCValue
            - 0.000115854182 *ADCValue*ADCValue*ADCValue
            + 0.000000068590 *ADCValue*ADCValue*ADCValue*ADCValue;
}

Pour le GP2Y0A21YK :

/*!
    \brief  make a distance measurement with a Sharp GP2Y0A21YK sensor
    \return the measured distance in mm

*/
float get_Sharp_GP2Y0A21YK_Distance(int PinID)
{
    // Read analog to digital converter value
    float ADCValue = (float)analogRead(PinID);

    // Convert in millimeters and return distance
    return  200.3775040589502
            - 2.2657665648980 *ADCValue
            + 0.0116395328796 *ADCValue*ADCValue
            - 0.0000299194195 *ADCValue*ADCValue*ADCValue
            + 0.0000000374087 *ADCValue*ADCValue*ADCValue*ADCValue
            - 0.0000000000181 *ADCValue*ADCValue*ADCValue*ADCValue*ADCValue;
}

Téléchargement

Acknowledgements

Cet article n’aurait jamais vu le jour sans l’aide d’Evan Guedon, Benjamin Buffard, Julien Thielleux, Rémi Gourdon et Nicolas Delanoue.