Vous êtes sur la page 1sur 24

Remerciement

Liste des abréviations

PWM : Modulation par largeur d’impulsion.


PID : (contrôleur) proportionnel, intégrateur, dérivateur.
TM : temps de montée
LP-WPAN : Low Power – Wireless Personal Area Network)
Table des matières
INTRODUCTION : ............................................................................................................................................. 8
1. MATERIEL POUR ETUDIER LE DEPLACEMENT DU ROBOT : ...................................................... 8
2. REGULATION DU DEPLACEMENT DU ROBOT :............................................................................... 8
3. RECUPERER LES INFORMATIONS DES CODEURS :........................................................................ 9
4. CONVERTIR LES INFORMATIONS DES CODEURS EN DISTANCE ET DEGRES : ..................... 11
............................................................................................................................................................................ 11
4.1 CALCULER LA POSITION EN X, Y ET ORIENTATION DU ROBOT : .......................................................................................... 11
CHAPITRE II : ASSERVISSEMENT POLAIRE DU ROBOT. ...................................................................... 13
INTRODUCTION ............................................................................................................................................. 14
1. RECUPERATION DES INFORMATIONS CODEUSES : ..................................................................................... 14
2. CREATION DE LA FONCTION D'ASSERVISSEMENT : ..................................................................................... 14
3. SCHEMATIQUE DE L'ASSERVISSEMENT ....................................................................................................... 16
CHAPITRE III : ................................................................................................................................................ 21
Liste des figures

Figure 1 : la base du robot ............................................................................................................... 9


Figure 2 : fonctionnement d'un codeur ............................................................................................ 9
Figure 3 : canaux des codeurs ....................................................................................................... 10
Figure 4 : changement de données ................................................................................................ 11
Figure 5 : position de l'adversaire ................................................................................................. 12
Figure 6 : changement d'ongles ..................................................................................................... 12
Figure 7 : schéma PID ................................................................................................................... 15
Figure 8 : schéma général du PID ................................................................................................. 16
Figure 9 : schéma Pid Simulink .................................................................................................... 17
Figure 10 : test des différentes valeurs ......................................................................................... 18
Figure 11 : réponse du signal ........................................................................................................ 19
Figure 12 : configuration Xbee en émetteur................................................................................. 23
Figure 13 : configuration Xbee en récepteur ................................................................................ 23
Introduction

La programmation d'un robot est comme la programmation de tout programme : simple et


Complexe il ne s'agit ni plus ni moins que d'une succession de fonctions ingénieusement
combinées. Chaque fonction est prise séparément La complexité se situe quant à elle au niveau
dans l'optimisation du regroupement de ces actions basiques dans le but de réduire les temps de
calcul et par conséquent d'obtenir un meilleur fonctionnement.

Dans le cadre de cette compétition l'informatique permet avant tout de programmer le


déplacement et l'actionnement des déférents systèmes dans les deux robots, c'est-à-dire la mise
en mouvement des moteurs à des vitesses variables ou constantes en fournissant des signaux
PWM, aux moteurs. Cette partie est également utilisée comme outil permettant de traiter les
données entrantes ou réceptionné des capteurs provenant des diverses cartes et contrôleurs
électroniques et de faire réagir le système en conséquence en fournissant des données sortantes
sur les actionneurs
Chapitre I : Localisation du robot

Nous allons traiter la partie du déplacement du robot à faire en sorte qu’un robot se déplace de
façon autonome.
Le but étant que notre robot soit capable d’aller d’un point A à un point B de façon
complétement autonome, ainsi que le robot pourras se déplacer en ligne droite, mais quand on dit
ligne droite, c’est vraiment droit ! On va ainsi voire comment faire pour que le robot sache où il
est, où il en est de son parcours et comment faire pour qu’il se dirige dans la bonne direction et
de façon le plus propre possible.
INTRODUCTION :

1 .Matériel pour étudier le déplacement du robot :

Pour réaliser toutes ces fonctionnalités on aura besoins du matériel suivant :

 Des moteurs CC, L’avantage principal des machines à courant continu réside
dans leur adaptation simple aux moyens permettant de régler ou de faire varier
leur vitesse, leur couple et leur sens de rotation : les variateurs de vitesse, voire
leur raccordement direct à la source d'énergie : batteries d’accumulateur.

 Un pont en H pour pouvoir contrôler les moteurs directement, composant dépendant


directement de vos moteurs. Nous utilisons des ponts en H MC33926
car ils sont bien puissants et précis.

 Des codeurs incrémentaux de type, le nombre de tics influencera la précision de votre


déplacement. Avoir 1000 tics par tours de roues permet d’avoir une précision plus que
satisfaisante.

 Une carte électronique Arduino MEGA permettant de programmer


l’ensemble des composants.

2 .Régulation du déplacement du robot :

La technique utilisée est une technique permettant de connaître la position, en temps réel, du
robot par rapport à une position d’origine. On utilise pour cela les informations que nous donnent
les codeurs externes et qui correspondent aux déplacements des roues motrices du robot. On va
ainsi être capable de calculer la distance parcourue par chaque roue et ainsi d’en déduire une
nouvelle position du robot.
3.Récupérer les informations des codeurs :

La première étape pour programmer le déplacement du robot est de récupérer les tics que génère
nos codeurs. On a des codeurs bi-canaux alors les informations que renvoient celui-ci se
traduisent par un même signal sur les canaux A et B déphasé de 90° l’un par rapport à l’autre. Ce
déphasage permet de déterminer le sens de rotation du codeur (et donc de la roue de direction).
En effet, le principe est de regarder l’état du canal B lors d’un front montant et/ou descendant du
canal A. Si le premier est à l’état bas alors on se déplace dans un sens et s’il est à l’état haut alors
on se déplace dans le sens opposé.

Figure 1 : la base du robot

Figure 2 : fonctionnement d'un codeur


Figure 3 : canaux des codeurs

En pratique sur notre Arduino MEGA, on a connecté le canal A de chacun de nos codeurs sur
une pin d’interruption et chaque canal B sur une pin numérique de la carte Il suffit maintenant, à
chaque front d’un des canaux A, de regarder l’état du canal B correspondant et d’incrémenter ou
décrémenter un compteur en fonction du sens de rotation.

Code 1 : programmation des interruptions

Code 2 : calcul des impulsions


4.Convertir les informations des codeurs en distance et degrés :

Informations
réceptionnées Conversion Distance
du codeur mathématique
Angle
Figure 4 : changement de données

5 Calculer la position en x, y et orientation du robot :

On sait désormais déterminer la distance parcourue par chaque roue ainsi que leurs variations en
angle à l’aide des codeurs, on a la possibilité maintenant de calculer la position du robot, pour
commencer il faut fixer les conditions initiales de notre système, soit les positions x0 et y0 ainsi
que l’orientation initiale angle à l’instant 0. Une fois cela fixé, notre but va être de calculer des
deltas en x, y et en angle.
Avec les équations de trigonométries on pourra alors déterminer les distances parcourues et les
nouveaux coordonnés du robot xn et yn et On.
Par exemple on étudie le déplacement à partir des conditions initiales du robot, on va donc
maintenant faire bouger notre robot, pour cela on a besoin de plusieurs choses : la première va
être de fixer les conditions initiales, soit les coordonnées x0 et Y0 au départ et l’angle d’origine
θ0 du robot. Ensuite, il faut déterminer la cible à viser, soit les coordonnées xC et yC du point
que vise le robot. Maintenant que tout cela est fixer, on doit vérifier si le robot est arrivé à
destination ou pas. Pour cela rien de mieux que l’algorithme de Pythagore :

Code 1 : fonctions mathématiques


Maintenant qu’on connait la distance qu’il reste à parcourir, à nous de déterminer si
celle-ci est suffisamment petite pour qu’on estime être arrivée à destination.

Figure 5 : position de l'adversaire

Figure 6 : changement d'ongles

Le premier schéma nous montre les coordonnées pour un déplacement et la distance que l’on
cherche. Le cercle bleu représente le robot et celui en rouge la cible qu’on doit atteindre
Maintenant qu’on sait la distance à parcourir, il faut s’assurer qu’on va dans la bonne direction
du coup l’angle doit être bien calculé, pour cela la trigonométrie nous servira aussi Si on reprend
le schéma précédant, le 0° correspond à être parallèle à l’axe X et à tourner le dos à l’axe Y. De
plus, on cherche un angle comprit entre 180 et -180° et non compris entre 0 et 360°. Pour
différencier cela, on commence par regarder si le y du robot est supérieur ou inférieur au y de la
cible. S’il est supérieur alors l’angle sera positif, sinon il est négatif. On obtient donc la formule
suivante pour l’angle.
Chapitre II : Asservissement
polaire du robot.

Dans cette partie nous allons aborder la notion de l’asservissement et on va programmer notre
robot et l’asservir en position et en vitesse.
INTRODUCTION

Le moteur DC fonctionne quand on lui envoie un courant. Le rotor va donc tourner plus ou
moins vite selon celui-ci, puis s’arrêter dès lors qu’il n’est plus alimenté. Cependant, on ne
connait ni la distance angulaire parcourue, ni la vitesse de rotation. Aussi, si l’on veut réaliser un
asservissement en vitesse ou en position, il faut transformer la consigne pour envoyer un
courant pendant le temps nécessaire pour atteindre l’objectif. Il faut pouvoir mesurer ce qu’il se
passe pendant que le moteur est en marche, calculer une position ou une vitesse, en déduire une
erreur, puis la corriger pour atteindre la consigne de sortie. Il faut donc se servir de codeurs
incrémentaux, acquérir les données, faire les calculs et commander le moteur en même
temps. Comment réaliser tout cela ?

1. Récupération des informations codeuses :

On souhaite connaitre le nombre de tours de l'arbre moteur grâce à la codeuse. Comme nous
l'avons vu dans une première partie, il y a 400 transitions montantes ET descendante qui
s'opèrent pendant un seul tour de l'arbre moteur.
Ainsi, il suffit de mettre une interruption qui se déclenche à chaque transition de la codeuse et
qui exécute une fonction qui viendra simplement incrémenter un compteur.

Code 1 : Impulsions

2. Création de la fonction d'asservissement :

Pour mettre en place un asservissement numérique, il faut que les calculs de la commande du
moteur se fassent à un intervalle de temps régulier. Pour cela, on a utilisé un timer qui permet
d'exécuter une fonction précise toutes les 20 millisecondes. Le timer n'est pas un objet inclut de
base à Arduino, on a donc installé une bibliothèque externe, « SimpleTimer », qui remplit cette
tâche.

Code 2 : timer simple


la fonction avancepid() est exécutée toutes les 20ms (50Hz) et les deux fonctions codeur() est
exécuté à chaque fois que la codeuse passe en front montant.

Code 3 : les interruptions du PID

L’asservissement de ce code se fait sur le positionnement en « thêta-alpha ». En effet,


l'asservissement ne se fait pas comme dans la plupart des robots avec un PID sur chacun des
moteurs, mais avec un PID sur la différence de position des roues codeuses (angle alpha) et un
PID sur la distance parcourue par la moyenne des deux roues (distance thêta). Ce type
d'asservissement trouve tout son avantage dans le recalage sur une bordure quelconque : il est
seulement nécessaire d'asservir la distance et non l'angle. Cela permet dès lors à la plate-forme
de n'opposer aucune résistance en angle lors du recalage et donc une mise en mouvement plus
guide. Il apparaît dès lors plus logique, en ce qui concerne un asservissement de plate-forme
robotique, d'utiliser un positionnement en thêta-alpha par rapport aux codes dans lesquels on
asservit les deux roues de propulsion indépendamment l'une de l'autre. Par ailleurs, la génération
de trajectoire se verra également grandement facilitée du fait du choix de cette méthode.

Figure 7 : schéma PID

Comme nous utilisons ici un asservissement polaire, nous ne pouvons donc pas directement
utiliser les données des codeurs ou directement appliquer des PWM à chacun des moteurs. Une
conversion est nécessaire. La conversion à partir des données des codeurs se fait alors
simplement comme suit :
Code 4 : fonction distance

3. Schématique de l'asservissement

Au sein du code de l'asservissement, nous pouvons trouver plusieurs modules spécifiques ayant
chacun un but particulier. On distingue quatre grand groupes fonctionnels : Régulation
proprement dite ; Calcul de la position courante en x, y; Surveillance du bon fonctionnement des
déplacements et détection des éventuelles erreurs (blocage, patinage...).

Figure 8 : schéma général du PID


Pour aller vite dans la théorie, on a utilisé un correcteur PID, c’est à dire à effets proportionnel,
intégral, et dérivé. Cet asservissement peut être modélisé par la formule ci-dessous, où V est la
consigne à envoyer au moteur, et Ki, Kd, Kp des coefficients à modifier à la main jusqu’à
trouver les coefficients les plus satisfaisants :

V = Kp x Erreur + Kd x ∆ Erreur + KI x ∫ Erreur

Avec :

Erreur = Consigne (Tr/s par ex.) – Nombre Tour roue par seconde mesuré
∆ Erreur = Erreur – Erreur précédente
∫ Erreur = ∑ erreurs

Code 5 : erreur

A l’aide du logiciel Matlab on a modélisé notre système afin de trouver les valeurs de KP, KD et
KI qui correspondent à une réponse adéquate à notre système.
La figure (9) illustre le schéma bloque en boucle fermée :

Bruit

STEP

PID

FT

Figure 9 : schéma Pid Simulink

Les paramètres du PID influencent sur la réponse du système de la manière suivante :


 Kp : Lorsque Kp augmente, le temps de montée (TM) est plus court mais il y a un
dépassement plus important. Le temps d'établissement varie peu et l'erreur statique se trouve
améliorée.  Ki : Lorsqu’il augmente, le temps de montée est plus court mais il y a un
dépassement plus important. Le temps d'établissement au régime stationnaire s'allonge mais dans
ce cas on assure une erreur statique réduite. Donc plus ce paramètre est élevé, moins l'erreur
statique est grande, mais plus la réponse du système est ralentie.
 Kd : Lorsque Kd augmente, le temps de montée change peu mais le dépassement diminue. Le
temps d'établissement au régime stationnaire est meilleur. Pas d'influences sur l'erreur statique.
Si ce paramètre est trop élevé, le système anticipe trop et la consigne n'est pas atteinte dans des
délais adéquats. Pour ces trois paramètres, le réglage au-delà d'un seuil trop élevé a pour effet
d'engendrer une oscillation du système de plus en plus importante menant à l'instabilité.
Et donc par essai, on a varié les facteurs PID et on regarde en sortie la réponse et le
comportement du robot, voici quelques énumérations des valeurs attribuées au PID.

Pour KP = 3, KI = 4, KD = 2

Pour KP = 3, KI = 4, KD = 2

Pour KP = 2, KI = 10, KD = 100

Figure 10 : test des différentes valeurs


Donc pour KP = 50, KI = 3, KD = 2 on peut constater que pour ces paramètre le temps de
réponse est optimal et par vérification sur le robot

Figure 11 : réponse du signal

Et donc on a implémenté ces variables dans le code, la fonction « avancepid » est la fonction qui
permet l’asservissement du robot en vitesse et en position.
Chapitre III : interfaçage et contrôle à
distance.
1. Communication Xbee

Xbee est un LP-WPAN un réseau sans fil à bas débit et à courte portée qui utilise les ondes
hertziennes pour transporter des messages entre deux ou plusieurs entités réseaux.
Alors l’utilité de ce dispositif dans notre projet est de déclencher l’expérience à un instant t du
match et ce d’une façon autonome sans l’intervention d’un membre de l’équipe. Et donc le
module Xbee répond à notre besoin ,il est caractérisé par une portée comprise entre quelques
mètres et quelques centaines de mètres et un débit faible (maximum 250 Kbits/s) assez suffisante
pour déclencher un signe pour que le servo moteur de l’expérience se déclenche. La différence
entre Xbee et la plupart des autres réseaux locaux et personnels sans fil (Wifi, Bluetooth) se situe
au niveau de l’utilisation du medium hertzien : Xbee est optimisé pour une faible utilisation du
medium partagé par tous.

Afin de configurer nos 2 Xbee on a utilisé une interface de configuration (XTCU) un logiciel de
test et configuration car chaque XBee possède un firmware (qui peut être mis à jour) et qu'il est
aussi possible, voire indispensable, de régler les différents paramètres :
 Identifiant du réseau (PANID)
 Channel de communication
 Le mode de fonctionnement Et plein d'autre paramètres (pour une utilisation plus poussée)
Ce test permet dans un premier temps de vérifier le fonctionnement, la version du firmware, et
de régler le mode de fonctionnement de chaque Xbee . L'adapteur usb/xbee est très utile pour
cette étape.
Figure 12 : configuration Xbee en émetteur

Figure 13 : configuration Xbee en récepteur


2. Communication serial :

Envoyer une commande depuis une Raspberry à Arduino via une interface série est assez trivial
en Python. Sur les systèmes de type Unix, on peut lire et écrire sur le périphérique série comme
s'il s'agissait d'un fichier, mais il existe également une bibliothèque appelée pySerial qui
fonctionne bien sous tous les systèmes d'exploitation.

Après avoir installé pySerial, la lecture des données depuis la Raspberry devient simple, donc on
a écrit les 2 scripts suivant afin d’envoyer les 3 commandes de distance, angle, direction et
vitesse.
Pour les tests on était amené à écrire des script en python et les manipuler via ssh ( ordinateur –
robot )