Cours:MiniQ v2

Corrections uniquement accessibles aux enseignants

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

**********************************************
**********************************************
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 le fonction ci-dessous qu'il faudra utiliser pour changer la vitesse du moteur :
  • Le premier paramètre est ce qui ira dans la broche 12 : 0 pour marche en avant et 1 pour marche arrière
  • Le deuxième le rapport cyclique qui ira sur la broche 5

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);
}

Indications : 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
• On vous donne le code source ci-dessous :
  • Le premier paramètre est ce qui ira dans la broche 7 : 0 pour marche en avant et 1 pour marche arrière
  • Le deuxième le rapport cyclique qui ira sur la broche 6
• La commande Mi_EN (pour i=1 et i=2) qui choisit le rapport cyclique ne doit pas dépasser 75 !

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 : Exercice 1 (arduino)

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.

Étalonnage des capteurs

Détecteurs de lumière sur MiniQ version 2

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 légèrement à droite
• lumière très à droite
• lumière légèrement à gauche
• lumière très à gauche

Travail à faire exercice 2 : Réalisation d'un suivi de lumière

On vous demande de réaliser un programme capable de suivre parfaitement rotation de la source de lumière qui a servi au calibrage. Pour cela le robot devra tourner sur place.

Correcteur proportionnel

Pour le moment, nous n'utilisons que 5 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.

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 µc	36	37	38	39	40
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 sur la ligne
  • incrémenter nbCaptOnLine
  • ajouter le poids du capteur à pos : pos <- pos + poids[numeroCapteur]
• normaliser pos : pos <- pos / nbCaptOnLine

Exemples :

Position du capteur ex gauche gauche centre droite ex droite poids du capteur 24 12 0 -12 -24 Valeur CAN 100 100 10 20 100 Capteur sur la ligne N N O O N pos = (0 + (-12))/2 = -6

Position du capteur ex gauche gauche centre droite ex droite poids du capteur 24 12 0 -12 -24 Valeur CAN 100 15 10 20 100 Capteur sur la ligne N O O O N pos = (12 + 0 + (-12))/3 = 0

Position du capteur ex gauche gauche centre droite ex droite poids du capteur 24 12 0 -12 -24 Valeur CAN 5 150 100 200 100 Capteur sur la ligne O N N N N 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.

On testera individuellement chaque capteur :

Écrire un programme qui allume la led si le capteur est au dessus de la ligne

Modifier ensuite le programme pour boucler sur le 5 capteurs :

• lumière bleue avant de lancer les conversions
• pour chaque capteur
  • allumer la led en rouge si présence ligne
  • allumer en vert pour indiquer qu'on passe au capteur suivant

Comment calibrer correctement les capteurs pour trouver les seuils

Ceci peut être réalisé par un simple programme Arduino qui nous permet de garder la liaison série :

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
  int data[5];
  uint8_t i;
  // put your main code here, to run repeatedly:
  for (i=0;i<5;i++)
   {
    data[i]=analogRead(i);//store the value read from the sensors
    Serial.print(data[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.

Modifier la couleur de la led suivant la valeur de pos :

• vert si pos = 0
• rouge si pos>0
• bleu si pos<0
• éteindre la led si aucun capteur n'est sur la ligne.

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 !