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
 
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
  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 ;
////////////////////////////////////////////////////////////////////
//Implémentation de la méthode constructeur
CStateMachineRotary::CStateMachineRotary(int brocheAinit, int brocheBinit){
   etat=0;    //numéro de l'état actif
 brocheA = brocheAinit;
 brocheB = brocheBinit;
 pinMode(brocheA, INPUT);
 pinMode(brocheB, INPUT);
 entreeA = digitalRead(brocheA); //valeur lue sur l'entrée A
 entreeB = digitalRead(brocheB);//valeur lue sur l'entrée B
 position = 0;
// à compléter
}
//Implémentation de la méthode clock
void CStateMachineRotary::clock(){
  //lecture et mémorisation des entrées
entreeA = digitalRead(brocheA);
entreeB = digitalRead(brocheB);

//actions sur transition
 if (etat == 0 && entreeA == 1)
 {
   position ++;
 }
 if (etat == 1 && entreeA == 0)
 {
   position --;
 }
//évolution de l'état
 switch (etat){
	case 0: if (entreeA == 1)
      {
			etat=1;
      }
		else if (entreeB == 1)
    {
			etat=3;
    }
		break;

    case 1: if (entreeB == 1)
    {
			etat=2;
    }
		else if (entreeA == 0)
    {
			etat=0;
    }
		break;

    case 2: if (entreeB == 0)
    {
			etat=1;
    }
		else if (entreeA == 0)
    {
			etat=3;
    }
		break;

    case 3: if (entreeA == 1)
    {
			etat=2;
    }
		else if (entreeB == 0)
    {
			etat=0;
    }
		break;

        default:break;
        }
// à compléter

}
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é
};
////////////////////////////////////////////////////////////////////
//Implémentation du constructeur de la classe fille, exécutée après avoir exécuté le constructeur de la classe mère
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
}  
////////////////////////////////////////////////////////////////////
//implémentation de la méthode frontDetecte() qui n'était pas implémentée dans la classe mère
void CStateMachineRotaryWithSpeed::frontDetecte()
{
  // à compléter
 
 }
//implémentation de la mesure de vitesse
float CStateMachineRotaryWithSpeed::getSpeed(){
  //à faire: calculer la vitesse et l'affecter à l'attribut speed
  return speed;
}
CStateMachineRotary encoder1(A4,A5);
CStateMachineRotary encoder2(A0,A1);
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.print(encoder1.getPosition());
    Serial.print(" ");
    Serial.print(encoder2.getPosition());
    Serial.println();;
}
 
}