Dès qu’on veut faire de la robotique qui roule, tout le monde parle de codeurs incrémental. Mais qu’est-ce que c’est ? A quoi ça sert ? Comment ça marche et comment c’est fait dedans ? Et pour les meilleurs un petit exemple pratique sur Arduino.

Un codeur c’est quoi ?

Un codeur est un capteur qui permet de déterminer une position angulaire. Plus simplement, c’est un instrument qui permet de mesurer de combien de degrés un élément a tourné. Les codeurs sont un peu partout, dans nos voitures, dans nos cuisines mais il sont surtout très présent dans l’industrie. Un bon exemple est le gros bouton du volume de votre chaîne HiFi (ou ampli home cinéma). Ce bouton fait de plastique est relié à un codeur et en fonction de l’angle que vous lui faite faire le volume s’ajuste.

Mais alors, qu’elle est la différence avec un potentiomètre rotatif ?

Déjà pour déterminer facilement s’il s’agit d’un potentiomètre ou d’un codeur c’est simple. Un potentiomètre est « fini » j’entends par là qu’il n’a qu’un nombre de tours limités (certains peuvent avoir jusqu’à 16 tours donc il faut faire attention …), chose que le codeur n’a pas, il est infini (vous pouvez faire autant de tour que vous voulez avec). Mais la différence est bien plus importante que la comparaison de leur course. Le potentiomètre peut être vu comme une résistance variable (c’est une image ! ne dite pas ça à un électronicien sinon il ne va pas être content). En fonction de comment vous positionnez votre potentiomètre sa valeur de résistance varie. Si vous vous mettez au minimum sa résistance est faible (voire nulle) et si vous vous mettez en butée maximum sa résistance vaut plusieurs kΩ en général. Le potentiomètre donne une image électrique de sa position. Le codeur ne fait absolument pas ça. Nous allons donc voir comment fonctionne un codeur.

Comment fonctionne un codeur rotatif ?

Un codeur rotatif peut avoir plusieurs technologies (magnétique, optique, …). Nous allons nous intéresser ici aux codeurs optique, mais les autres technologies sont très semblables par leur comportement.

Principe général

Le codeur optique dispose d’un disque avec de nombreuses fenêtres (le nom technique est tic). Ces fenêtres laissent passer la lumière. Une LED dans le codeur émet un faisceau lumineux qui tente de passer au travers du disque, lorsque qu’une fenêtre se présente la lumière passe et est captée par un phototransistor. Une petite illustration va nous faire comprendre tout ça.

Quand le phototransistor capte de la lumière il délivre un signal logique. Si notre codeur est alimenté en 5V nous aurons alors un 0V quand la lumière ne passe pas et 5V quand elle passe. Ce qui donne (à vitesse de rotation constante) un beau signal carré comme ceci :

Détermination de l’angle

Étant donné qu’il est possible de savoir le nombre de fenêtres qui sont passées grâce au nombre de créneaux dans le signal électrique, il est alors possible de déterminer l’angle qu’a parcouru le codeur.

Partons du principe que notre codeur est un codeur à 360 tics/tour. Si nous avons 18 créneaux dans notre signal, le codeur à donc tourné de 18°.

Détermination du sens de rotation

En vrai, les codeurs rotatif sont un peu plus complexe car il faut aussi pouvoir déterminer leurs sens de rotation. Pour ça on met une seconde piste de tics en dessous de la première mais décalée de 25% de la position précédente (on dit que la piste à un déphasage de 90° ou de π/2 par rapport à la première). On y rajoute même souvent une 3ème piste avec seulement un tic pour avoir le début d’un tour. Voila à quoi ressemble un disque de codeur incrémental complet et les signaux qu’il génère :

Grâce à la deuxième piste, le codeur ne renvoie pas le même type de signal en fonction de son sens de rotation. S’il va dans un sens, A et B sont déphasés de 90° alors que s’il tourne dans l’autre sens, A et B sont déphasés de -90° ce qui donne le résultat suivant :

Utiliser un codeur sur une Arduino Uno

/************************************************************
				   ___    _____  ____ 
				  / _ \  / ___/ / __ \
				 / , _/ / /__  / /_/ /
				/_/|_|  \___/  \____/ 

	Auteur : Association Robotique Club de l'Ouest
	
	Petit exemple de logiciel pour l'acquisition de tics
	pour codeurs incrementals. 

	Cet exemple vos pour l'acquisition de deux codeurs
	incrementaux sur une Arduino Uno mais il est très 
	simplement adaptable sur d'autres types d'arduino

************************************************************/

//-----------------------------------------------------------
// Déclaration des constantes

// Numéro de l'intéruption 0, il correspond à la pin 2
const int interuptG = 0;
// Numéro de l'intéruption 1, il correspond à la pin 3
const int interuptD = 1; 	

// Pin 9 de l'Arduino Uno
const int canalBG 	= 9;	
// Pin 10 de l'Arduino Uno
const int canalBD 	= 10;	

// Fin déclaration des constantes
//-----------------------------------------------------------

//-----------------------------------------------------------
// Déclaration des fonctions

void Reagir();
void ReagirBis();

// Fin déclaration des fonctions
//-----------------------------------------------------------

//-----------------------------------------------------------
// Déclaration des variables globales
  
// Variables (compteurs) qui vont stocker 
// le nombre de tics comptés pour chaque codeur
long comptD = 0;
long comptG = 0;

// Fin Déclaration des variables globales
//-----------------------------------------------------------

//-----------------------------------------------------------
// Fonction d'initialisation
void setup()
{
	// Permet un affichage du résultat sur la consol Série
	Serial.begin(9600);		

	// Initialisation des pin 9 et 10 en entrèes
	pinMode(canalBG, INPUT);	
	pinMode(canalBD, INPUT);

	// Déclaration des intéruptions
	// Ici les fonctions d'intéruptions s'éxecutent
	// sur fronts montants : RISING
	attachInterrupt(interuptG, Reagir, RISING);
 	attachInterrupt(interuptD, ReagirBis, RISING);
}
// Fin initialisation
//-----------------------------------------------------------


//-----------------------------------------------------------
// Fonction principale
// Avec l'utilisation des intéruptions la fonction loop qui
// habituellement est très remplie, la ne sert presque à rien
// sinon afficher le résultat du comptage sur le port série
void loop()
{
	Serial.print("Compt G");
	Serial.print(comptG); 

	Serial.print("   Compt D");
	Serial.println(comptD);
}
// Fin fonction principale
//-----------------------------------------------------------

//-----------------------------------------------------------
// Fonction d'intéruption pour le codeur gauche
// 
// Fonction appelée par un tic du codeur gauche. 
// On regarde le sens de rotation de celui-ci 
// (on teste l'état de la voie déphasée) et on 
// incrémente ou décrémente le compteur comptG.
void Reagir()
{  
	if(digitalRead(canalBG) == HIGH)
	{
		comptG--;        
	}
	else
	{
		comptG++;      
	}      
}
// Fin fonction d'intéruption pour le codeur gauche
//-----------------------------------------------------------


//-----------------------------------------------------------
// Fonction d'intéruption pour le codeur droit
// 
// Fonction appelée par un tic du codeur droit. 
// On regarde le sens de rotation de celui-ci 
// (on teste l'état de la voie déphasée) et on 
// incrémente ou décrémente le compteur comptD.
void ReagirBis()
{     
	if(digitalRead(canalBD) == HIGH)
	{
		comptD ++;
	}
	else
	{
		comptD--;     
	}
}
// Fin fonction d'intéruption pour le codeur droit
//-----------------------------------------------------------

Vous pouvez télécharger le fichier du code source : codeurs_incrementaux.ino