Cours:MiniQ v2
Corrections uniquement accessibles aux enseignants
Sommaire
Programmation avec arduino
Le robot miniQ est architecturé autour d'un processeur ATMega32U4. C'est le processeur qui équipe les cartes Leonardo et il est d'ailleurs complètement compatible. Il faut donc changer de board qui est par défaut "Arduino UNO" qui est essentiellement utilisé pour les TPs.
Le processeur 32U4 est capable de gérer une liaison série USB sans l'aide d'un circuit spécialisé (FTDI par exemple).
Le schéma peut être trouvé sur cette page commerciale avec des exemples de code et des exercices en anglais.
En résumé :
- La carte Arduino équivalente est la : Arduino Leonardo
- Le programmateur d'origine est : AVR ISP MK2 ou USBASP
**********************************************
**********************************************
Attention : pour programmer aller dans le menu
Croquis : Téléverser avec un programmateur
**********************************************
**********************************************
Utilisation de analogWrite() pour la MLI
Commande d'un moteur
Vous trouverez des détails sur le moteur à courant continu et sa commande sur cette page
Vous pourrez consulter plus tard cette page pour comprendre le signal PWM/MLI
Pour faire varier la vitesse d'un moteur il suffit de faire varier sa tension de commande. En général ceci est réalisé avec un signal MLI ou PWM (signal à rapport cyclique variable), nous n'entrerons pas dans le détail dans ce TP.
Tout ceci se fait dans le monde Arduino avec une commande "analogWrite()"
- analogWrite(broche,255); => tension moyenne de 5v sur la broche
- analogWrite(broche,127); => tension moyenne de 2.5v sur la broche
- analogWrite(broche,0); => tension moyenne de 0v sur la broche
Commande d'un moteur : :
- Il y a deux sorties de commandes du moteur gauche (il faudra donc les positionner en sortie) :
- broche 5 Arduino (PC6) pour la commande rapport cyclique variable : vitesse de rotation
- broche 12 Arduino (PD6) pour le sens de rotation
- On vous donne la fonction ci-dessous qu'il faudra utiliser pour changer la vitesse du moteur :
- Le paramètre est une valeur entre -255 et 255 qui indique la valeur souhaitée pour la vitesse du moteur
void MotorG(int vitesse)//control the motor
{
if (vitesse<0)
{
vitesse=-vitesse;
digitalWrite(12,1);
}
else
{
digitalWrite(12,0);
}
if (vitesse>255) vitesse=255;
analogWrite(5,vitesse);
}
Exemple d'utilisation
void setup()
{
MoteurG(0);
}
On complète la commande du moteur gauche par celle du moteur droit.
- Il y a deux sorties de commandes du moteur droit (il faudra donc les positionner en sortie) :
- broche 6 Arduino (PD7) pour la commande rapport cyclique variable
- broche 7 Arduino (PE6) pour le sens de rotation
- La fonction suivante permet de changer la vitesse du 2ème moteur
void MotorD(int vitesse)//control the motor
{
if (vitesse<0)
{
vitesse=-vitesse;
digitalWrite(7,1);
}
else
{
digitalWrite(7,0);
}
if (vitesse>255) vitesse=255;
analogWrite(6,vitesse);
}
Travail à faire
Vous devez réaliser une commande du robot pour qu'il réalise un huit (deux cercles connectés par un point). Vous choisirez le rayon de vos cercles en jouant sur les rapports cycliques. Puis vous jouerez sur les temporisations pour gérer tout cela. Bien entendu, le fait qu'il n'y ait pas d'information de retour sur l'endroit où vous êtes complique un peu la mise au point.
Vous pouvez chercher à innover sur les trajectoires. Des étudiants, par exemple, ont mis deux obstacles et cherché à réaliser un créneau entre ces deux obstacles. Faites-vous plaisir. Il vous faut à tout prix comprendre comment on va en ligne droite et comment on tourne.
Suivre une source de lumière par Conversion Analogique Numérique
Le travail demandé dans cette section utilise encore la conversion analogique numérique.
La différence est que maintenant c'est la position d'une source de lumière qui va faire changer les valeurs analogiques.
Le capteur est connecté sur la broche A5
Étalonnage des capteurs
Vous disposez de deux capteurs de lumière monté comme dans le schéma ci-contre. Utilisez une liaison série pour trouver les zones pour :
- lumière au centre
- lumière à droite
- lumière à gauche
Ecrire un programme qui permet d'orienter le robot face à la lumière en utilisant l'information droite/centre/gauche
Correcteur proportionnel
Pour le moment, nous n'utilisons que 3 valeurs différentes pour faire le suivi de lumière. Afin de faire un suivi plus performant, nous allons calculer la vitesse de rotation du robot en fonction de la position de la lumière par rapport au robot :
Trouver une équation permettant de donner l'angle entre l'axe du robot et la source de lumière, en fonction de la valeur du CAN. On considérera qu'il s'agit d'une relation affine :
- relever les valeurs de l'entrée analogique pour :
- angle -45°
- angle 0°
- angle +45°
- tracer la caractéristique angle en fonction de la valeur de l'entrée analogique
- donner l'équation de la droite
La vitesse du robot peut être décomposée en une translation et une rotation. On aura donc :
- vt : vitesse de translation (ex 20)
- wr : vitesse de rotation
- vitMoteurD = vt + wr
- vitMoteurG = vt - wr
- wr = k * positionAngulaireLumiere
Ecrire un programme permettant de faire le suivi de la lumière d'après ce principe.
Utilisation de l'infra-rouge pour suivre une ligne
On souhaite maintenant programmer un robot suiveur de ligne, qui sera de couleur noire.
Principe
5 capteurs photoréflectifs sont disposés sur le robot tel que résumé dans le tableau ci-dessous.
| Position du capteur | extrême gauche | gauche | centre | droite | extrême droite |
| broche arduino | A0 | A1 | A2 | A3 | A4 |
| entrée CAN | ADC7 | ADC6 | ADC5 | ADC4 | ADC1 |
On peut considérer dans un premier temps que la valeur lue sur le CAN est :
- inférieure à 300 sur du noir
- supérieur à 300 pour le blanc
On décomposera la vitesse du robot de la même façon que précédemment :
- vt : vitesse de translation, constante par ex 30
- wr : vitesse de rotation, dépendra de la position du robot par rapport à la ligne
- vitMoteurD = vt + wr
- vitMoteurG = vt - wr
Position de la ligne
Le plus important est de trouver la position du robot par rapport à la ligne, que l'on notera pos.
Le principe est d'attribuer un poids à chaque capteur, d'autant plus grand que le capteur est excentré. Le signe donne le côté du capteur :
| Position du capteur | extrême gauche | gauche | centre | droite | extrême droite |
| poids du capteur | 24 | 12 | 0 | -12 | -24 |
L'algorithme est le suivant :
- initialiser pos à 0
- initialiser nbCaptOnLine à 0
- pour chaque capteur
- si le capteur est sur la ligne
- incrémenter nbCaptOnLine
- ajouter le poids du capteur à pos : pos <- pos + poids[numeroCapteur]
- si le capteur est sur la ligne
- normaliser pos : pos <- pos / nbCaptOnLine
Exemples :
pos = (0 + (-12))/2 = -6 |
pos = (12 + 0 + (-12))/3 = 0 |
pos = (24)/1 = 24 |
Vérification des capteurs
La première étape dans la conception du programme va consister à vérifier le Convertisseur Analogique Numérique, en utilisant la led.
Ceci peut être réalisé par un programme affichant les données sur la liaison série :
const uint8_t pinCapteur[5]={A0,A1,A2,A3,A4};
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
}
void loop() {
int valeurCapteur[5];
uint8_t i;
// put your main code here, to run repeatedly:
for (i=0;i<5;i++)
{
valeurCapteur[i]=analogRead( pinCapteur[i] );//store the value read from the sensors
Serial.print(valeurCapteur[i]);
Serial.print(" - ");
}
Serial.println();
delay(500);
}
Un essai avec un Robot a donné les résultats suivants.
| Position du capteur | extrême gauche | gauche | centre | droite | extrême droite |
| broche µc | 36 | 37 | 38 | 39 | 40 |
| entrée CAN | ADC7 | ADC6 | ADC5 | ADC4 | ADC1 |
| entrée Arduino | A0 | A1 | A2 | A3 | A4 |
| BLANC | 836 | 982 | 980 | 974 | 970 |
| NOIR | 210 | 390 | 338 | 305 | 305 |
| Seuil | 523 | 686 | 659 | 639 | 637 |
Position de la ligne
Il est temps maintenant de calculer la variable pos tel qu'indiqué ci-dessus.
Calculer la valeur pos et l'afficher sur la liaison série
Marche
Il ne reste qu'à modifier la vitesse angulaire du robot (wr) en fonction de la variable pos
Remarque : attention au signe, sinon la correction se fait dans le mauvais sens !
