#include "libencodeur.h"

CStateMachineRotaryWithSpeedAndReset encoder2(A0,A1,A2);
CStateMachineRotary encoder1(A4,A5);

void setup() {
Serial.begin(115200);
}

void loop() {
  encoder1.clock();
  encoder2.clock();
//affichage de la valeur mesurée 10 fois par seconde
  unsigned int periodiciteTache1=100;
  static unsigned long timerTache1 = millis();
  if (millis() - timerTache1 >= periodiciteTache1) {
      timerTache1 += periodiciteTache1;
      Serial.println(encoder1.getPosition());
      Serial.print(" ");
      Serial.println(encoder2.getPosition());
      Serial.print(" ");
      Serial.println(encoder2.getSpeed());

  }

  unsigned int periodiciteTache2=10000;       //10s
  static unsigned long timerTache2 = millis();
  if (millis() - timerTache2 >= periodiciteTache2) {
      timerTache2 += periodiciteTache2;
      encoder1.setPosition(encoder1.getPosition()+4);
  }
 
}

sketch.ino

diagram.json

#ifndef LIB_ENCODER_H
#define LIB_ENCODER_H

#include <Arduino.h>

class CStateMachineRotary //déclaration de la classe
{
public:            //membres accessibles depuis l'extérieur de la classe, il s'agit de l'interface d'interaction de la classe
  CStateMachineRotary(int brocheAinit, int brocheBinit); //Constructeur avec paramètres pour régler les 2 broches Arduino utilisées
  void clock();    //méthode pour cadencer la machine à état (faire 1 coup d'horloge)
  int getPosition()//méthode accesseur pour accéder à l'attribut privé position
	{ return position;} //on parle de méthode inlinée car l'implémentation est faite dans la déclaration de la classe
  void setPosition(int newposition)
    {position = newposition;}

private:        //membres privés pour réaliser l'encapsulation: ces attributs sont inacessibles directement depuis l'extérieur de la classe
  //byte etat;    //numéro de l'état actif
  enum Etat_mae 
  {
  etat0 =0,
  etat1 =1,
  etat2 =2,
  etat3 =3,
  };
  Etat_mae etat;

  byte entreeA; //valeur lue sur l'entrée A
  byte entreeB; //valeur lue sur l'entrée B
  int brocheA;  //numéro de broche Arduino utilisée pour l'entrée A
  int brocheB;  //numéro de broche Arduino utilisée pour l'entrée B
  virtual void frontDetecte(){}; //methode abstraite, sera implémentée dans la classe fille
  virtual void actionSurTousLesEtats(){}; //methode abstraite, sera implémentée dans la classe fille
protected:      //ces membres peuvent être accédés dans les classes filles
  int position; //position angulaire mesurée    
};  //ne pas oublier le ;

class CStateMachineRotaryWithSpeed: public CStateMachineRotary
{
public:
  CStateMachineRotaryWithSpeed(int brocheAinit, int brocheBinit);
  float getSpeed(); //méthode accesseur pour accéder à l'attribut privé speed
 
private:
  float speed;  //vitesse mesurée
  unsigned long lastPulseTime; //horodatage du dernier front
  void frontDetecte(); //implémentation pour effectuer des traitements lorsqu'un front est detecté
  virtual void actionSurTousLesEtats(){};
};

class CStateMachineRotaryWithSpeedAndReset: public CStateMachineRotaryWithSpeed 
{
public:
  CStateMachineRotaryWithSpeedAndReset(int brocheAinit, int brocheBinit,int brocheRinit);

private:
  byte entreeReset;
  int brocheReset;
  void actionSurTousLesEtats();
};



CStateMachineRotary::CStateMachineRotary(int brocheAinit, int brocheBinit);
void CStateMachineRotary::clock();


CStateMachineRotaryWithSpeed::CStateMachineRotaryWithSpeed(int brocheAinit, int brocheBinit);
void CStateMachineRotaryWithSpeed::frontDetecte();
float CStateMachineRotaryWithSpeed::getSpeed();


CStateMachineRotaryWithSpeedAndReset::CStateMachineRotaryWithSpeedAndReset(int brocheAinit, int brocheBinit,int brocheRinit);
void CStateMachineRotaryWithSpeedAndReset::actionSurTousLesEtats();

#endif 

libencodeur.h

#include "SevSeg.h"
#include "libencodeur.h"

CStateMachineRotary::CStateMachineRotary(int brocheAinit, int brocheBinit){
  brocheA = brocheAinit;
  brocheB = brocheBinit;
  position = 0;
  pinMode(brocheA, INPUT);
  pinMode(brocheB, INPUT);
}

void CStateMachineRotary::clock()
{
//lecture et mémorisation des entrées
  entreeA =digitalRead(brocheA);
  entreeB =digitalRead(brocheB);
//actions sur transition
  if((etat == etat0) && (entreeA ==1))
  {
    position++;
    frontDetecte();
  }
  if((etat == etat1) && (entreeA ==0))
  {
    position--;
    frontDetecte();
  }

//évolution de l'état
 switch (etat){
	case etat0 : 
          if (entreeA == 1)
			      etat = etat1 ;
            else if(entreeB == 1)
            etat = etat3;
          break;
	case etat1 : 
          if (entreeA == 0)
			      etat = etat0 ;
          else if(entreeB == 1)
            etat = etat2;
          break;
	case etat2 : 
          if (entreeA == 0)
			      etat = etat3 ;
          else if(entreeB == 0)
            etat = etat1;
          break;
	case etat3 : 
          if (entreeA == 1)
			      etat = etat2 ;
          else if(entreeB == 0)
            etat = etat0;
          break;          
  default :
            etat = etat0;
        }
  //action sur état
  actionSurTousLesEtats();
}


CStateMachineRotaryWithSpeed::CStateMachineRotaryWithSpeed(int brocheAinit, int brocheBinit): CStateMachineRotary(brocheAinit, brocheBinit){
 lastPulseTime=micros(); //initialisation de la date initiale pour l'horodatage des fronts
 speed=0; //initialise vitesse nulle au démarrage. Attention, en simu, l'encodeur génère des fronts parasites
}  


void CStateMachineRotaryWithSpeed::frontDetecte(){
  unsigned long newPulseTime = micros();
  speed = 1000000./(newPulseTime - lastPulseTime);

  lastPulseTime = newPulseTime;
}


float CStateMachineRotaryWithSpeed::getSpeed(){
  unsigned long newPulseTime = micros();
  if ((newPulseTime - lastPulseTime)>4000000)
    speed = 0;
  return speed;
}


CStateMachineRotaryWithSpeedAndReset::CStateMachineRotaryWithSpeedAndReset(int brocheAinit, int brocheBinit,int brocheRinit):CStateMachineRotaryWithSpeed(brocheAinit, brocheBinit)
{
  brocheReset = brocheRinit;
  pinMode(brocheReset, INPUT);
}

void CStateMachineRotaryWithSpeedAndReset::actionSurTousLesEtats(){
  if(digitalRead(brocheReset) != entreeReset)
  {
    position = 0;
    entreeReset = !entreeReset;
  }
    
}

libencodeur.cpp

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
SevSeg
# ---
