Les machines à commande numérique, tels que les perceuses, les imprimantes 3D, utilisent des moteur pas à pas pour exécuter avec précision les mouvements. Il suffit de donner au système de pilotage le nombre pas à effectuer.

Même s'ils ne sont pas fréquents dans ce type de machines, les moteurs à courant continus quant à eux ont pour avantage de tourner beaucoup plus vite, avec un temps de réponse court; au prix des erreurs de positionnement.

Mais, si on a un capteur qui permet de connaître à tout instant la position angulaire de l'arbre d'un moteur à courant continu, les choses peuvent changer;  il devient possible de supprimer ces erreurs et commander avec précision l’axe du moteur en position ou en vitesse. C'est le principe des servomoteurs, que l'on peut rencontrer en robotique par exemple.

Il existe deux types de moteurs à courant continus: des moteurs à conrant continu avec balais (Brush motor), et des moteurs à courant continu sans balais (Brushless motor).

Cette réalisation a pour but de commander en position l'axe d'un moteur à courant continu à balais, doté d’un codeur incrémental.

Avant de poursuivre, voici les différents points qu'on va aborder:

• • • • • Le principe de fonctionnement du montage;
        • La réalisation pratique de la maquette;
        • La mise en oeuvre du programme de commande;
        • Le test de fonctionnement;
        • La conclusion.

De quoi aura-t-on besoin?

• Une carte Arduino Uno;
• Un moto-réducteur muni d'un codeur incrémental à effet hall, ayant pour caractéristiques:
  • •    Tension nominale: 12V;
    •    Nombre de tours/mn: 110;
    •    Courant à vide: 120mA;
    •    Courant en charge: 350mA;
    •    Puissance dévéloppée: 3W;
    •    Couple en charge: 3,4Kg.cm;
    •    Couple de décrochage: 13Kg.cm;
    •    Courant de décrochage: 1A;
    •    Rapport de réduction: 1:90              
• Un pont en H basé sur le circuit L298
• Un bloc d'alimentation 12V/2A
• Un potentiomètre 10KΩ - 1tour

Principe de fonctionnement du montage:

Schéma de principe:

1 : Potentiomètre

2 : Différentiateur

3 : Dispositif de contrôle - commande

4 : Moteur à courant continu 12V

5 : Capteur de position magnétique à effet Hall

Fonctionnement:

La consigne d'angle souhaitée sera fixée grâce au potentiomètre (1); le système de contrôle - commande (3) envoie un ordre électrique au moteur (4) qui déplacera son axe vers la position θ désirée. Un capteur de position (5), indique la position de l'axe du moteur au différentiateur (2); celui-ci va calculer la différence entre la position réelle cet axe et la position de consigne. L'erreur calculée par le différentiateur sera prise en compte par le système de contrôle, qui pourra ainsi envoyer de nouveau un ordre au moteur (si cette erreur n'est pas nulle) afin que celui-ci ramene son axe vers la position de consigne.

Ce montage fonctionne ainsi en boucle fermée. L'erreur de position est évaluée en permanence, dès que celle-ci est différente de zéro, le système de contrôle va donc envoyer un ordre pour corriger la position du moteur de façon proportionnelle.

Approche théorique:

On peut dire dans ce cas présent qu'on a affaire à une boucle de régulation; et le dispositif de contrôle (3) en est le régulateur, qui en théorie, est un régulateur PID.

On peut modéliser ce régulateur de la façon suivante:

P : représente le terme Proportionnel à l'erreur courante;

I : représente le terme Intégral, il tient compte des valeurs passées de l'erreur;

D : représente le terme Derivée, il permet d'estimer le sens futur de l'erreur.

En ce qui concerne les signaux,

r(t) :  est la consigne ou la position souhaitée;

c(t) :  l'image de la position de l'arbre moteur;

e(t) :  l'erreu de position;

u(t) :  le signal de contrôle, issue du régulateur;

y(t) :  l'angle du déplacement de l'arbre moteur.

L'erreur est déterminée par l'équation (1): e(t) = r(t) - c(t)  

Le rôle du régulateur consiste à ramener cette erreur au plus près possible de zéro. Ainsi la correction apportée prendra la forme d'un signal u(t), dont l'équation (2) est donnée par:

\[u(t) = K_p e(t) + K_i \int_{0}^{t} e(τ)dτ + K_d \frac{de(t)}{dt}\]

Ces deux équations vont servir pour le programme de la carte Arduino.

Dans l'équation (2), on a les constantes:

• Kp : la constante proportionnelle, détermine la rapidité du mouvement du moteur vers sa nouvelle position;
• Ki  : la constante intégrale, détermine comment le moteur va se positionner à la fin de son mouvement. L'angle de positionnement n'est pas tout à fait égal à la valeur de consigne. Il en résulte une erreur appelé erreur statique. C'est cette erreur statique que le terme Integral va minimiser le plus possible.
• Kd : constante dérivée, lorsque le moteur va vers la position demandée, il dépassera celle-ci, oscillera éventuellement, avant de se stabiliser. C'est donc ce dépassement que la constante dérivée va réduire.

Le choix de ces trois constantes n'est pas le fait du hasard, un mauvais choix peut entraîner des résultats inattendus. Le montage peut se mettre à osciller (l'arbre moteur fera des va et vient sur lui-même sans jamias se stabiliser), par exemple. Il existe des méthodes permettant de déterminer ces constantes:  par des abaques ou autres outils numériques.

Réalisation pratique de la maquette:

La tension de consigne issue du potentiomètre 10KΩ-1tour, pourra varier de 0 à 5V. A 0V, l'arbre moteur sera à 0°; à 5V il sera à 360°.

Le capteur utilisé est un codeur incrémental magnétique, directement fixé sur l'arbre moteur.  Ce codeur possède un disque à pôles magnétiques, et deux capteurs inductifs montés en quadrature, générant ainsi des signaux carrés décalés d'un quart de période lorsque le disque est en rotation.

La détection des fronts montants et/ou descendants permet de déterminer le nombre d'impulsions par tours, ou le sens de rotation du moteur.

Le calcul de l'erreur et de la tension de commande sera effectué par la carte Arduino. Afin de piloter le moteur à courant continu 12V, une carte d'interface de puissance, sous forme de pont en H, construite autour d'un L298 sera utilisée. Ce type de carte se trouve dans le commerce. Mais on a utilisé pour la démonstration une carte faite maison, dont certaines connectiques ont été configurées selon nos besoins. Le principe reste le même.

Le câblage dans sa globalité:

Ce montage utilise un pont en H basé sur le circuit intégré L298 issue du commerce. Les différentes connexions donnent:

Côté moteur:

• le fil rouge et le fil noir sont reliés aux sorties Moteur du pont en H;
• le fil vert représente la masse de l'encodeur magnétique, il est relié à la masse de la carte Arduino et celle du pont en H;
• le fil violet c'est la sortie A des impulsions de l'encodeur, il est relié à la broche 2 de la carte Arduino;
• le fil jaune c'est la sortie B des impulsions de l'encodeur, il est relié à la broche 4 de la carte Arduino;
• le fil marron clair c'est l'alimentation +5V de l'encodeur, il est relié à +5V du pont en H.

Côté carte pont en H:

• le fil rouge de l'alimentation stabilisée est relié à +12V du pont en H;
• le fil noir de l'alimentation stabilisée est relié à la masse du pont en H (en somme tooutes les masses sont reliées);
• le fil marron foncé est une entrée de commande du moteur, il est relié à la broche 5 de la carte Arduino;
• le fil gris c'est l'autre entrée de commande du moteur, il est relié à la broche 6 de la carte Arduino;
• le fil bleu c'est l'entrée "Enable" du pont en H, il est relié à la broche 7 de la carte Arduino.

Pour le potentiomètre:

• les deux fils d'extrémité, l'orange et le bleu sont reliés respectivement à +5V et à la masse;
• le point milieu, fil gris, est relié à la broche A0 de la carte Arduino.

L'alimentation stabilisée sera réglée à +12V.

Attention ce schéma de câblage montre les liaisons entre les différents composants du montage. Le code de couleur utilisé dépend du type du moteur, du codeur, du pont en H utilisés. Il sera donc nécessaire d'avoir la documentation technique du moteur ainsi que du module en H.

Le programme de commande:

Pour réaliser le programme de commande, on va respecter le principe présenté dans l'approche théorique vue précédemment. Le programme principal devra contenir les fonctions qui vont permettre de calculer l'erreur de position, du régulateur PID, les paramètres de régulation seront fournis sous forme de constante.

Dans un souci de facilité de lecture toutes les variables ainsi que les commentaires sont en Anglais.

La mise en oeuvre du programme va se scinder en plusieurs étapes:

1. 1. 1. Création d'un programme de test pour connaitre le nombre d'impulsions de codeur pour un tour complet de l'arbre moteur;
      2. Création du programme permettant de piloter la position de l'arbre moteur; mise en oeuvre et test;
      3. Pour aller plus loin commander simultanément deux moteurs à courant continu. 

Calcul du nombre d'impulsions du codeur incrémental:

L'entrée A du codeur incrémental sera relié à la broche 2 de la carte Arduino;

L'entrée B du codeur incrémental sera relié à la broche 4 de la carte Arduino

 #define encoderPinA 2
 #define encoderPinB 4

Les impulsions comptées seront stockées dans la variable "pulses_counted",  et envoyées sur le port série de la carte Arduino, puis affichées à l'écran.

On commencera par définir les les broches 2 et 4 de la carte Arduino en entrée; puis la vitesse de transfert sur la liaison série:

  Serial.begin(9600);
  pinMode(encoderPinA, INPUT);
  pinMode(encoderPinB, INPUT);

Pour compter les impulsions on utilisera les interruptions par détection de front sur la broche 2 de la carte Arduino

attachInterrupt(digitalPinToInterrupt(encoderPinA), Dc_Motor_Encoder,RISING);

A chaque front détecté, le sous_progamme "Dc_Motor_Encoder" sera exécuté. Dans ce sous programme on va juste vérifier l'état de la broche 4; si elle est à l'état haut, alors la variable "pulses_counted" sera incrémentée, et si elle est à l'état bas, la variable sera décrémentée.

Le programme princinpal se contente juste d'envoyer le contenu de cette variable vers la liaison série.

Ci-après le programme de test complet:

/*==============================================================
 * This test program is for rotary encoder, we are using
 * Arduino Uno.
 * For encoder, pin A is connected to pin 2 of Arduino and pin B 
 * is connected to pin 4 of Arduino
 * Author: JtBB
 */
//Encoder pin connections with Arduino
#define encoderPinA 2
#define encoderPinB 4 
//Variables
int pulses_counted = 0;
//Setup
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode(encoderPinA, INPUT);
  pinMode(encoderPinB, INPUT);
  attachInterrupt(digitalPinToInterrupt(encoderPinA), Dc_Motor_Encoder,RISING);
}

void loop() {
  // put your main code here, to run repeatedly:
  Serial.print("Result:   ");
  Serial.println(pulses_counted);
  //end of encoder output printing
}
//This called by isr, is to count encoder pulses
void Dc_Motor_Encoder(){
  int b = digitalRead(encoderPinB);
  if (b > 0){
    pulses_counted ++;
  }else
    {
      pulses_counted --;
    }
}

Après avoir Uploadé le programme sur la carte Arduino, à l'aide du moniteur série de l'IDE Arduino, on constate bien que le nombre d'impulsions du codeur augmente ou diminue lorsqu'on fait tourner l'arbre moteur à la main dans un sens ou dans l'autre; capteur alimenté en +5V.

Le potentiomètre étant relié à l'entrée analogique A0 de la carte Arduino, et alimenté en +5V, on a jugé inutile d'exécuter le même test que celui fait avec le codeur; étant donné que, le convertisseur analogique - numérique de la carte Arduino est un convertisseur 10 bits. Donc si la tension sur le curseur du potentiomètre varie de 0 à 5V, la valeur numérique va varier de 0 à 1024.

Commande du moteur en position

Pour réaliser ce programme, on peut utiliser la formule du régulateur vue dans l'un des paragraphes précédents, pour calculer u(t), c'est cette grandeur qui servira pour faire avancer ou reculer le moteur jusqu'à la position désirée.

Mais dans le cas présent, on va plutôt utiliser la librairie PID de l'environnement de programmation intégré d'Arduino. Cette librairie comporte plusieurs fonctions utiles pour réaliser un régulateur PID à base d'Arduino. On ne va pas s'étendre dessus cette librairie est expliquée en long et en large par son auteur dans le site arduino/cc. Un grand merci à: Bret Beauregard, pour son formidable boulot.

On commence donc par charger la librairie avec l'instruction:

#include 

Ensuite on va attribuer des noms de variables aux différentes broches qui seront utilisées par Arduino pour ce fait:

#define encodPinA   2
#define encodPinB   4 
#define enablePin;  7
#define motorA      5 
#define motorB      6

Puis les variables: input, output, setpoint, sont toutes du types "double";

La variable encoderPos contiendra le nombre d'impulsions total du codeur incrémental, dans le sens de rotation directe et inverse. Puisqu'elle sera appelée par le sous programme d'interruption, elle est du type "volatile long".

Les constantes Kp, Ki, et Kd ont été choisies pour mettre en oeuvre l'exemple proposé, celles-ci peuvent être changées selon les cas.

A présent il faudra créer une instance appelée motor grâce à l'instruction:

PID motor(&input, &output, &setpoint, Kp, Ki, Kd, DIRECT);

Il est possible qu'il y ait des dysfonctionnements, à la mise sous tension du montage, dans ce cas changer la variable "DIRECT", par "REVERSE", ou alors inverser les deux entrées du codeur sur la carte Arduino.

Le sous programme Setup() va se charger d'initialiser les broches de la carte, la liaison série (qui peut servir ici pour le déboggage), des fonctions SetMode(), SampleTime(), SetoutputLimit().

Les impulsions de commande sont en fait des ondes PWM (modulées en largeur d'impulsion); lorsqu'elles sont utilisées pour piloter un moteur à courant continu cells-ci ont tendance à générer un bruit qui peut rapidement devenir nuisible même lorsque le moteur est à l'arrêt.

Pour éliminer ce bruit on a utilisé toujours dans Setup(), une instruction directement adressée au niveau du régistre interne du composant en question:

TCCR0B = TCCR0B & 0b11111000 | 1;

Le sous-programmme pwmOut() se charge de commander le moteur dans les deux sens de rotation, et le sous-programme read_Encoder() lit et cumule ou retranche le nombre d'impulsions du codeur incrémental.

Et pour finir le programme principal va lire la valeur du potentiomètre pour la consigne (setpoint), puis le nombre total d'impulsions du codeur pour savoir la position de l'arbre du moteur, puis effectuera le calcul en se servant de la formule mathématique discutée auparavant, puis enverra le résultat sous forme d'un signal PWM au moteur pour tourner dans un sens ou dans l'autre.

Ci-dessous le programme complet du régulateur:

/*==============================================================
 * Motor position control and rotary encoder as feedback, we are using
 * Arduino Uno.
 * Rotary encoder, pin A is connected to pin 2 of Arduino and pin B 
 * is connected to pin 4 of Arduino
 * Author: JtBB
 */
#include <PID_v1.h>
#define encodPinA       2                      // Quadrature encoder A pin
#define encodPinB       4                      // Quadrature encoder B pin
#define enablePin       7
#define motorA          5                      // PWM outputs to L298N H-Bridge motor driver module
#define motorB          6 
//
#define setpointInput   A0                     // Setpoint from potentiometer
//Program variables
double kp = 5.4 , ki = 1.0 , kd = 0.01;             //You can modify this for your own need
double input = 0, output = 0;
double setpoint = 0;
long temp;
volatile long encoderPos = 0;
const int encoderPulsesperRev = 1024;
PID motor(&input, &output, &setpoint, kp, ki, kd, DIRECT);  //REVERSE or DIRECT if turn continuously

void setup() {
  pinMode(encodPinA, INPUT_PULLUP);                  // quadrature encoder input A
  pinMode(encodPinB, INPUT_PULLUP);                  // quadrature encoder input B              
  pinMode(enablePin, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(encodPinA),read_Encoder,RISING); // update encoder position
  TCCR0B = TCCR0B & 0b11111000 | 1;                   // PWM frequency to prevent motor noise see ATMEGA328P datasheet
  motor.SetMode(AUTOMATIC);
  motor.SetSampleTime(1);
  motor.SetOutputLimits(-255, 255);
  digitalWrite(enablePin, LOW);
  Serial.begin (115200);                              // for debugging
}

void loop() {
  setpoint = analogRead(setpointInput);                           //Potentiometer is connected to A0
  setpoint = map(setpoint, 0, 1023, 0, encoderPulsesperRev);         //map for rotation of motor 
  input = encoderPos;                                 // data from encoder
  Serial.println(encoderPos);                         // monitor motor position for debug porpose
  Serial.println(setpoint);
  motor.Compute();                                    // calculate new output
  pwmOut(output);                                     // drive L298N H-Bridge module
}

void pwmOut(int out) {                                // to H-Bridge board
  digitalWrite(enablePin, HIGH);
  if (out > 0) {
    analogWrite(motorA, out);                         // drive motor CW
    analogWrite(motorB, 0);
  }
  else {
    analogWrite(motorA, 0);
    analogWrite(motorB, abs(out));                    // drive motor CCW
  }
}

void read_Encoder()  {                                // pulse and direction, direct port reading to save cycles
  int b = digitalRead(encodPinB);
  if (b > 0){
            encoderPos++;             
  }
  else { encoderPos--;             
  }
}

Test de fonctionnement:

Après avoir Uploadé le programme vers la carte Arduino Uno le programme est prêt à fonctionner. On peut tourner le potentiomètre et on observera l'axe du moteur bouger. Ici on a choisi un motoréducteur à 110tr/mn de vitesse maximale, afin d'avoir de déplacer l'axe du moteur plus lentement. attention à la position initiale de l'axe du moteur et du potentiomètre avant de mettre le tout sous-tension.

Pour aller plus loin on se propose de commander deux moteurs simulatnément avec deux potentiomètres. On va donc utiliser deux moteurs de robot LEGO, car ceux-ci sont aussi équipés chacun d'un codeur incrémental, tout comme le moteur à courant continu de l'exemple précedent.

Le programme:

Il est intégralement calqué sur le programme précédent à ceci près que deux instances motor1 et motor2 ont été crées pour être utilisées par la fonction PID.

Ci-dessous le listing du programme:

/*===================================================
 * Position control of two DC motor with Arduino Uno
 * Autor: JtBB
 * Ver: 
 * Setpoint are made with two potentiometers
 */
 //We are using PID library. Thanks to Bret Beauregard for
 //his great job
 #include 
 //Driver pins to Arduino
 #define enablePin1     7 //enablePin for motor 1
 #define enablePin2     8 //enablePin for motor 2
 #define motor1A        5 //pwm output for motor 1
 #define motor1B        6 //pwm output for motor 1
 #define motor2A        9 //pwm output for motor 2
 #define motor2B        10 //pwm output for motor 2
 //Encoder pins to Arduino
 #define encoderPinA1   2 //encoder A pin 1
 #define encoderPinB1   3 //encoder B pin 1
 #define encoderPinA2   4 //encoder A pin 2
 #define encoderPinB2   11 //encoder B pin 2
 //Potentiometer pins to Arduino
 #define setpointInput1      A0 //potentiometer 1
 #define setpointInput2      A1 //potentiometer 2
 //Variables
 //
 //PID parameters
 double kp1 = 5.0, ki1 = 1.0, kd1 = 0.01;
 double kp2 = 5.0, ki2 = 1.0, kd2 = 0.01;
 double input1 = 0, input2 = 0, output1 = 0, output2 = 0;
 double setpoint1 = 0, setpoint2 = 0;
 //Encoder variables
 volatile long encoderAPos = 0;
 volatile long encoderBPos = 0;
 const int encoderPulsesperRev = 1024;
 PID motor1(&input1, &output1, &setpoint1, kp1, ki1, kd1, DIRECT); 
 PID motor2(&input2, &output2, &setpoint2, kp2, ki2, kd2, REVERSE);
 //Setup 
 void setup(){
      motorsInit();
      encodersInit();
      motorsCtlInit();
      TCCR0B = TCCR0B & 0b11111000 | 1; //change PWM frequency on  5 - 6 pins
      TCCR1B = TCCR1B & 0b11111000 | 1; // set 31KHz PWM to prevent motor noise
      Serial.begin(115200);
 }
 //Main program
 void loop(){
      double value1 = analogRead(setpointInput1);
      setpoint1 = map(value1, 0, 1023, 0, encoderPulsesperRev); //map for motor 1 rotation
      double value2 = analogRead(setpointInput2);
      setpoint2 = map(value2, 0, 1023, 0, encoderPulsesperRev); //255 map for motor 2 rotation
      Serial.println(encoderBPos);
      input1 = encoderAPos;
      input2 = encoderBPos;
      motor1.Compute();
      pwmOut1(output1);
      motor2.Compute();
      pwmOut2(output2);
 }
 //Functions
 //Motors initialization
 void motorsInit(){
    pinMode(enablePin1, OUTPUT);
    pinMode(enablePin2, OUTPUT);
    pinMode(motor1A, OUTPUT);
    pinMode(motor1B, OUTPUT);
    pinMode(motor2A, OUTPUT);
    pinMode(motor2B, OUTPUT);
    digitalWrite(enablePin1, LOW);
    digitalWrite(enablePin2, LOW);
 }
 //Encoders initialization
 void encodersInit(){
    pinMode(encoderPinA1, INPUT_PULLUP);
    pinMode(encoderPinA2, INPUT_PULLUP);
    pinMode(encoderPinB1, INPUT_PULLUP);
    pinMode(encoderPinB2, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(encoderPinA1), read_EncoderA,RISING);
    attachInterrupt(digitalPinToInterrupt(encoderPinB1), read_EncoderB,RISING);
 }
 //motor control initialization
 void motorsCtlInit(){
    motor1.SetSampleTime(1);
    motor2.SetSampleTime(1);
    motor1.SetOutputLimits(-255, 255);
    motor2.SetOutputLimits(-255, 255);
    motor1.SetMode(AUTOMATIC);
    motor2.SetMode(AUTOMATIC);
 }
 //Encoders interrupt routine
 //Encoder A
 void read_EncoderA()  {         // pulse and direction, direct port reading to save cycles
  int enca = digitalRead(encoderPinA2);
  if (enca > 0){
            encoderAPos++;       // if(digitalRead(encodPinB1)==HIGH)   count ++;
  }
  else { encoderAPos--;          // if(digitalRead(encodPinB1)==LOW)   count --;
  }
}
//Encoder B
void read_EncoderB()  {                                     // pulse and direction, direct port reading to save cycles
  int encb = digitalRead(encoderPinB2);
  if (encb > 0){
            encoderBPos++;             // if(digitalRead(encodPinB1)==HIGH)   count ++;
  }
  else { encoderBPos--;             // if(digitalRead(encodPinB1)==LOW)   count --;
  }
}
//To motor driver
//Send PWM signal to motor 1
void pwmOut1(int out1){
  if(out1 > 0){
    digitalWrite(enablePin1, HIGH);
    analogWrite(motor1A, out1);
    analogWrite(motor1B, 0);
  }
  else {
    digitalWrite(enablePin1, HIGH);
    analogWrite(motor1A, 0);
    analogWrite(motor1B, abs(out1));
  }
}
//Send PWM signal to motor 1
void pwmOut2(int out2){
  if(out2 > 0){
    digitalWrite(enablePin2, HIGH);
    analogWrite(motor2A, out2);
    analogWrite(motor2B, 0);
  }
  else {
    digitalWrite(enablePin2, HIGH);
    analogWrite(motor2A, 0);
    analogWrite(motor2B, abs(out2));
  }
}

La vidéo accessible par le lien ci-après montre le fonctionnement de la maquette avec un moteur et avec deux moteurs: elle n'a pas de son, il faudra activer le sous-titrage. Nous présentons vraiment toutes nos excuses pour cette défaillance.

Conclusion:

Ce montage a permis de voir qu'on peut piloter un moteur à courant continu en position. Le capteur de boucle utilisé est un codeur incrémental. On pourrait aussi utiliser un potentiomètre fixé sur l'arbre moteur si on est sûr que le nombre de tours de l'arbre moteur ne dépassera pas 1 (pour un potentiomètre 1 tour) ou 10 (pour un potentiomètre 10 tours). Si on opte pour ce choix alors il faudra aussi tenir compte de la résolution du convertisseur analogique numérique.

Un autre point à noter aussi c'est que dans ce montage, l'algorithme de comptage du nombre d'impulsions du codeur mis en oeuvre comporte des pertes de résolution du fait qu'on teste un seul signal parmi le deux. Pour améliorer la résolution, il faudrait tester les deux signaux lorsque l'un ou l'autre change; cela suppose une entrée d'interruption supplémentaire rien que pour le codeur. En conséquence on a plutôt accepté de perdre en résolution afin de piloter deux moteurs avec la carte Arduino Uno.

JtBB