#include "lib_io_tp.h"

const unsigned int LEDPIN=3;
const unsigned int BUTTONPIN=2;
/** Variable globale permettant de stocker la dernière valeur écrite sur le 
    port de sortie, pour pouvoir en modifier uniquement certains bits */
unsigned char imageSortie=0;   

//-------------------------------------------------------------------
/*! void setup() */
void setup() {
  SetupES();
  Serial.begin(115200);
  pinMode(LEDPIN, OUTPUT);
  pinMode(BUTTONPIN, INPUT_PULLUP);
}

/* void loop() */
void loop() {
  exo10(); // Appeler la fonction de l'exo en cours, une à la fois
}

//-------------------------------------------------------------------
/*! \brief Exercice 1:
  * Recopie l'état des switch sur les leds et print la valeur */
void exo1(){
  unsigned char val=readPort();
  writePort(val);
  if (val<=0xF) // On regarde si c'est à un seul chiffre
    Serial.print(0);
  Serial.print(val, HEX) ;
  Serial.println();
}

//-------------------------------------------------------------------
/*! \brief Exercice 2:
* Vous devez piloter le port de sortie en recopiant l'entrée 7 sur la 
* sortie dont le numéro est défini par les 3 switches les plus à droite (2..0) */
void exo2(){
  unsigned char val=readPort();
  unsigned char e20= val & 0b111; // On regarde la valeur sur les 3 premiers switch n
  unsigned char e7= (val >>7) & 0x1; // On regarde l'etat du switch 7

  val=e7<<e20; // On décale 7 de n
  writePort(val);
}

//-------------------------------------------------------------------
/*! \brief Exercice 3:
  * Afficher la valeur des switchs (3 à 0) sur l'afficheur 7 segment
  * puis ajouter le pilotage du point avec le switch 7 */
void exo3(){
  byte tab[]={0x3f,0x06,0x5b,0x4F,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};

  unsigned char val=readPort();
  unsigned char e30= val & 0b1111; // On regarde la valeur sur les 3 premiers switch n
  unsigned char e7= (val >>7) & 0x1; // On regarde l'etat du switch 7
  val=tab[e30] | (e7<<7); // valeur est égal à la valeur du tableau à l'index n + le point
  writePort(val);
}

//-------------------------------------------------------------------
/*! \brief Exercice 4:
  * Recopie etat du boutton vert sur led verte mais avec lib arduino */
void exo4(){
  int val=digitalRead(BUTTONPIN);
  digitalWrite(LEDPIN,val);
}

//-------------------------------------------------------------------
/*! \brief Exercice 5:
  * Allume la led en face du curseur du potar 
  * "si potar est tt à gauche, la LED tt à gauche allumé" */
void exo5(){
  uint16_t val=analogRead(A0); // Sur 10 bits
 
  // (val >> 7)      Garde les 3 bits les plus à droite
  // 7-(val >> 7)    Fait 0b111 - les 3 bits les plus à droite
  // 1<<(7-(val>>7)) Décale du résultat de la soustraction 1
  writePort(1<<(7-(val>>7)));
}

//-------------------------------------------------------------------
/*! \brief Exercice 6:
 * Fais clignoter la led à une fréquence indiqué par le potar (avec delay) */
void exo6(){
  uint16_t val=analogRead(A0);
  static uint8_t etat=0;

  digitalWrite(LEDPIN,etat);
  delay(val);
  etat=etat^1; // Inverse l'état
}

//-------------------------------------------------------------------
/*! \brief Exercice 7:
  * Gérer l'intensité de la led analogiquement avec le potar */
void exo7(){
  uint16_t val=analogRead(A0);
  analogWrite(LEDPIN,val>>2);
}

//-------------------------------------------------------------------
/*! \brief Exercice 8:
* Faites l'exo 1 et en plus clignoter la led tout les 2 secondes (exemple que ça marche pas de ouf) */
void exo8(){

  // Exo 1
  unsigned char val=readPort();
  writePort(val);

  // Clignote LED
  static uint8_t etat=0;
  digitalWrite(LEDPIN,etat);
  delay(2000);
  etat=etat^1;
}

//-------------------------------------------------------------------
/*! \brief Exercice 9:
* Comme le 8 mais sans le delais bloquant de 2 secondes */
void exo9(){
  unsigned char val=readPort();
  writePort(val);

  unsigned int periodicite=2000;
  static unsigned long timer=millis();
  if( ( millis() -timer )>=2000)
  {
    timer=timer+periodicite;
    static uint8_t etat=0;
    digitalWrite(LEDPIN,etat);

    etat=etat^1;
  }
}

//-------------------------------------------------------------------
/*! \brief Exercice 10:
  *  Appelle juste la fonction tache1() et attends 500ms. */
void exo10(){
  tache1();
  delay(500);
}

//-------------------------------------------------------------------
/*! \brief tache1:
  * Fais un compteur qui va de 0 à la valeur des switch (3 à 0) */
void tache1(){
  static unsigned char compteur=0;

  imageSortie=(imageSortie&0xf0) | (compteur&0x0f);
  writePort(imageSortie);

  unsigned char modulo=(readPort()&0x0f) +1; //On lis les 4 switch à droite
  
  compteur=(compteur+1)%modulo;
  Serial.println("t1");
}

//-------------------------------------------------------------------
/*! \brief Exercice 11:
  * Appelle tache1() et  tache2() et attent 500ms. */
void exo11(){
  tache1();
  tache2();
  delay(500);
}

//-------------------------------------------------------------------
/*! \brief tache2:
  * Réalise un chenillard sur les leds 7 à 4.
  * Le chenillard a plusieurs séquences : les 4 tableaux
  * On choisi la séquence gràace aux switch 6 et 5
  * Le switch 4 met en pause le chenillard */
void tache2(){
  byte tab1[]={0x1,0x2,0x4,0x8,0x4,0x2};
  byte tab2[]={0x1,0x3,0x7,0xf,0x7,0x3};
  byte tab3[]={0x8,0xC,0xE,0xf,0xC,0x8};
  byte tab4[]={0x8,0x1,0x4,0x2,0x1,0x4};

  byte * tabtab[4]={tab1,tab2,tab3,tab4};
  static unsigned char compteur=0;
  unsigned char entree=readPort();
  unsigned char e56=(entree>>5)&3;
  byte *ptrtab=tabtab[e56];
  byte val=ptrtab[compteur];

  imageSortie=(imageSortie&0x0F) | ((val&0x0f)<<4);
  writePort(imageSortie);
  if ( ((entree>>4)&1)==1) 
      compteur=(compteur+1)%6;


  Serial.println("t2");

}

//-------------------------------------------------------------------
/*! \brief Exercice 12:
  * Découverte du pseudo parallélisme: la tache1 doit être réalisée toutes les 
  * 500ms et la tache2 doit être réalisée toutes les Nms, N étant la valeur sur 
  * 10bits lue sur l'entrée analogique 0. */
void exo12(){
  static unsigned long clockCounterTache1 = 0;
  static unsigned long clockCounterTache2 = 0;

  #define PERIOD_TACHE_1 500

  double potValue = analogRead(A0);
  int periodTache2 = (int)(potValue+0.5);

  if ((millis() - clockCounterTache1) > PERIOD_TACHE_1) {
    tache1();
    clockCounterTache1 += PERIOD_TACHE_1;
  }

  if ((millis() - clockCounterTache2) > periodTache2) {
    tache2();
    clockCounterTache2 += periodTache2;
  }
}