Encodeur rotatif I2C

Placé sur 2019-10-01

Codeur rotatif I²C

Je vais couvrir deux sujets dans cet article.

Le premier concerne les encodeurs rotatifs et (brièvement) leur fonctionnement. Le second concerne le protocole Inter-Integrated Circuit (I²C) développé par Philips.

encodeurs rotatifs

Un encodeur rotatif est un appareil qui (physiquement) ressemble à un potentiomètre, mais ne fait pas varier la résistance entre deux/trois connecteurs mais donne plutôt des impulsions lorsque l'arbre est tourné. Une autre différence avec le potentiomètre est que vous pouvez faire tourner l'arbre à 360° (il n'y a en fait aucune limite au nombre de degrés que vous pouvez faire tourner l'arbre).

La plupart des encodeurs rotatifs ont un interrupteur qui s'active lorsque vous appuyez sur l'arbre. Et il existe des encodeurs rotatifs dotés d'une LED tricolore interne (appelée encodeur rotatif RVB) avec laquelle vous pouvez donner un retour à un utilisateur avec une palette de couleurs.

Encodeur rotatif RVB

L'encodeur rotatif génère des impulsions lorsque l'arbre est tourné. La plupart des encodeurs rotatifs génèrent 24 impulsions à chaque rotation de 360°, mais il existe également des encodeurs rotatifs qui délivrent plus ou moins d'impulsions par tour. Dans votre programme, vous pouvez compter ces impulsions et y réagir (par exemple : augmenter ou diminuer la tension de sortie d'une alimentation ou parcourir une liste de menus).

Vous vous demandez peut-être : " pourquoi utiliser un encodeur rotatif et pas seulement un potentiomètre ? ". Bien sûr, il n'y a pas de réponse " ceci vaut mieux que cela " à cela. Cela depend du projet. Si vous construisez un ampli hi-fi analogique, le potentiomètre est probablement le meilleur choix. Si vous avez un projet avec un microprocesseur, l'encodeur rotatif vous offre de nombreuses options pour créer une interface utilisateur agréable (avec peut-être un changement fin/grossier en fonction de l'appui court ou long sur l'axe et un retour coloré pour montrer quel mode est actif) .

Vous trouverez ci-dessous un exemple de croquis pour "lire" un encodeur rotatif. Pour que ce programme fonctionne correctement et de manière fiable, vous avez besoin d'un contrôle de rebond matériel (réseau RC) sur les broches A et B de l'encodeur :

Demo Sketch Rotary Encoder

 #define outputA 6
 #define outputB 7

 int rotVal = 0; 
 int rotState;
 int rotLastState;  

 void setup() { 
   pinMode (outputA,INPUT);
   pinMode (outputB,INPUT);
   
   Serial.begin (115200);
   // Reads the initial state of the outputA
   rotLastState = digitalRead(outputA);   
 } 

 void loop() { 
   rotState = digitalRead(outputA);
   // If the previous and the current state of the outputA are different, 
   // that means a Pulse has occured
   if (rotState != rotLastState){     
     // If the outputB state is different to the outputA state, 
     // the encoder is rotating clockwise
     if (digitalRead(outputB) != rotState) { 
       rotVal ++;
     } else {
       rotVal --;
     }
     Serial.print(F("Position: "));
     Serial.println(rotVal);
   } 
   rotLastState = rotState; // Update the previous state to the current state
 }

Malheureusement, l'utilisation d'un encodeur rotatif dans un projet présente également un inconvénient : vous avez besoin de beaucoup de broches GPIO !

Un encodeur rotatif RVB nécessite deux broches GPIO pour l'encodeur lui-même (plus GND), puis vous avez besoin d'une broche GPIO pour le bouton-poussoir et de trois broches GPIO pour la LED RVB. C'est un total de six broches GPIO ! Sur un ESP8266 par exemple, il ne vous reste plus que trois broches GPIO pour contrôler le reste de votre projet ! Sur un Arduino UNO, vous avez plus de broches GPIO, donc un encodeur rotatif ne sera pas un problème. Mais que se passe-t-il si vous souhaitez connecter deux, trois ou même plusieurs encodeurs rotatifs. Ce n'est pas possible sur un ESP8266, mais sur un Arduino UNO vous serez bientôt à court de broches GPIO !

Heureusement, il existe une solution !

Le bus de circuit inter-intégré (I²C)

C'est ce qu'on appelle un "bus" (de données) car vous pouvez y connecter de nombreux appareils. Le "bus" se compose de deux lignes. Une ligne d'horloge (SCL) et une ligne de données (SDA). Il y en a toujours (au moins) un'maître'-device et tous les autres appareils sont 'esclave' dispositifs. Chaque appareil a une adresse unique pour se distinguer les uns des autres. Je n'entrerai pas dans les profondeurs du protocole I²C, mais normalement le maître réclamera le contrôle du bus et enverra une requête à un esclave avec une adresse spécifique. L'esclave, à son tour, agira sur la demande, soit en effectuant une action spécifique dans l'esclave lui-même, en renvoyant des données au maître, soit en renvoyant simplement un accusé de réception au maître pour lui faire savoir qu'il a reçu la demande. Ici vous pouvez en savoir plus sur le protocole I²C.

Le codeur rotatif I²C

Ne serait-il pas agréable de pouvoir connecter un encodeur rotatif en utilisant uniquement les deux fils du bus I²C ! ?

Et c'est de cela qu'il s'agit vraiment dans cet article : un encodeur rotatif que vous connectez via le bus I²C et que vous contrôlez à l'aide du protocole I²C.

J'ai conçu le firmware et un petit circuit imprimé avec un microprocesseur ATtiny841. L'ATtiny841 a intégré filmatériel (la couche sous I²C), ce qui le rend extrêmement approprié comme esclave I²C pour cette conception.

Encodeur rotatif I2C v2.2 vue de dessous

Le micrologiciel garantit que l'ATtiny841 se comporte, d'une part, comme un esclave I²C "normal" et, d'autre part, fournit l'interface avec un encodeur rotatif RVB. Pour contrôler facilement le RotaryEncoder I²C, j'ai un correspondant et facile à utiliser Librairie Arduino / ESP8266 écrit.

Avec cette configuration, il est possible de connecter autant (littéralement !) d'encodeurs rotatifs I²C à votre microprocesseur que vous le souhaitez tout en n'ayant besoin que de deux broches GPIO. Vous pouvez même connecter d'autres périphériques I²C (écrans, capteurs, etc.) aux deux mêmes broches GPIO, laissant de nombreuses broches GPIO libres à d'autres fins.

BUS I2C

Si vous le souhaitez, vous pouvez utiliser la broche d'interruption du RotaryEncoder I²C pour rendre votre programme "piloté par les interruptions".

La broche d'interruption génère une interruption à chaque changement de position de l'arbre rotatif ou du bouton-poussoir. Tous les RotaryEncoders I²C partagent la même ligne d'interruption.

Comment pouvez-vous utiliser le RotaryEncoder I²C dans votre projet ?

Le code ci-dessous est un exemple de croquis pour communiquer avec le RotaryEncoder I²C (à l'aide de la broche d'interruption) :

Basic I2C_RotaryEncoder Sketch

/* Sketch to show the use of the I2C_RotaryEncoder */

#define I2C_DEFAULT_ADDRESS  0x28    // the 7-bit address 

#include <I2C_RotaryEncoder.h>

I2CRE Encoder; // Create instance of the I2CRE object

int16_t       rotVal;

volatile bool interruptPending  = false;

//====================================================================
ISR_PREFIX void handleInterrupt()
{
  interruptPending = true;
}


//====================================================================
void handleRotaryEncoder()
{
  byte statusReg = Encoder.getStatus();
  if (statusReg == 0) return;

  if (Encoder.isRotValChanged() ) {
    Serial.print(F("Request Value of ROTARY .......... "));
    rotVal = Encoder.getRotVal();
    Serial.print(F("["));
    Serial.print(rotVal);
    Serial.println(F("]"));
  }

  if (Encoder.isButtonPressed() ) {
    Serial.println(F("-------> Button Pressed"));
  }
  if (Encoder.isButtonQuickReleased() ) {
    Serial.println(F("-------> Quick Release"));
    Encoder.setRotVal(0);	        // or do something usefull
    Encoder.setRGBcolor(200, 0, 0); // Light the Red LED
  }
  if (Encoder.isButtonMidReleased() ) {
    Serial.println(F("-------> Mid Release"));
    Encoder.setRotVal(255);	        // or do something usefull
    Encoder.setRGBcolor(0, 200, 0); // Light the Green LED
  }
  if (Encoder.isButtonLongReleased() ) {
    Serial.println(F("-------> Long Release"));
    Encoder.setRotVal(128);	         // or do something usefull
    Encoder.setRGBcolor(0, 0, 200);  // Light the Blue LED
  }

} // handleRotaryEncoder();

//====================================================================
void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start I2C-Rotary-Encoder Basic ....\n"));
  Serial.print(F("Setup Wire .."));
  Wire.begin();
  Serial.println(F(".. done"));

  pinMode(_INTERRUPTPIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(_INTERRUPTPIN)
                         , handleInterrupt
                         , FALLING);

  if (!Encoder.begin(Wire, I2C_DEFAULT_ADDRESS)) {
    Serial.println(F(".. Error connecting to I2C slave .."));
    delay(1000);
    return;	// restart the micro processor
  }

  Encoder.setLedGreen(128);      // turn green led on half intensity

  interruptPending  = false;

  Serial.println(F("setup() done .. \n"));

} // setup()

//====================================================================
void loop()
{
  if (interruptPending) {
    interruptPending = false;
    handleRotaryEncoder();
  } // handle interrupt ..

  // do other important stuff ..

} // loop()

Sparkfun Qwiic Twist - Encodeur rotatif RVBLe Sparkfun Qwiic Twist est un encodeur rotatif RVB numérique convivial qui simplifie le câblage et le codage. Il dispose d'un bouton intégré, prend en charge jusqu'à 16 millions de couleurs et se connecte facilement au système Qwiic. Idéal pour les projets Arduino . Disponible immédiatement € 29,95

Page actuelle 1. Introduction Page suivante 2. Bibliothèque d'encodeurs rotatifs I2C 1. Introduction 2. Bibliothèque d'encodeurs rotatifs I2C 3. Codeur rotatif schématique I2C Posté par Willem Aandewiel Site Internet Willem Aandewiel (1955) a une formation en électronique et en techniques numériques. Cependant, la majeure partie de sa vie professionnelle, il a travaillé dans l'automatisation où il a travaillé dans à peu près toutes les disciplines, du programmeur au chef de projet et au chef de projet. Willem a été l'un des premiers Néerlandais à posséder un micro-ordinateur (KIM-1, 1976) à une époque où le PC n'avait pas encore été inventé. Aujourd'hui, il s'occupe principalement de la conception et de la production de petits circuits électroniques à microprocesseurs. Sa «mission dans la vie» est de rendre les gens enthousiastes à l'idée de fabriquer leurs propres circuits électroniques, micro-ordinateurs et programmes.