/*! \file cesi1.ino
    \brief Premier TD pour le CESI.
    \author Bertrand Vandeportaele IUT GEII
    \date  28/10/2021
*/ 
#include "lib_io_tp.h"
/** Variable globale indiquant la broche Arduino connectée à la LED */
const unsigned int LEDPIN=3;
/** Variable globale indiquant la broche Arduino connectée au bouton poussoir */
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;   
//-------------------------------------------------------------------
/*! \fn void setup()
    \brief Initialisation des périphériques et des variables globales
*/

int analogPin = A0;

void setup() {
  Serial.begin(115200);
  pinMode(LEDPIN, OUTPUT);
  pinMode(BUTTONPIN, INPUT_PULLUP);
  setupINT0();
}
//-------------------------------------------------------------------
/*!
  * \fn void loop()
  * \brief La fonction loop doit appeler une seule fonction exo... à la 
  * fois, vous devez conserver le code de tous les exercices mais n'en 
  * utiliser qu'un à la fois
*/
void loop() {
  SetupES();
  //exo1();
  //exo2();
  //exo3();
  //exo4();
  //exo5();
  //exo6();
  //exo7();
  //exo8();
  //exo9();
  //exo10();
  exo13();
}
//-------------------------------------------------------------------
/*!
  * \fn void exo1()
  * \brief Exercice 1:
  * Vous devez piloter le port de sortie en recopiant l'état du port 
  * entrée et afficher sur la console série en héxadécimal la valeur lue 
  * sur le port d'entrée
  * Utilisez les fonctions void SetupES(void); unsigned char readPort(void); 
  * et void writePort(unsigned char value); de lib_io_tp.h
  * Configurez et utiliser l'interface de communication Série/USB
  * https://www.arduino.cc/reference/en/language/functions/communication/serial
  * https://www.arduino.cc/reference/en/language/functions/communication/serial/print/
  * https://www.arduino.cc/reference/en/language/functions/communication/serial/println/
*/
void exo1(){
  unsigned char e = readPort();
  writePort(e);
  Serial.println(e,HEX);
}
//-------------------------------------------------------------------
/*!
  * \fn void exo2()
  * \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 entree(2..0)
*/
void exo2(){
  unsigned char e = readPort();

  int e7 = e >> 7;
  unsigned char e20 = e & 0b111;
  unsigned char s = (e7<<e20)-1024;

  writePort(s);
}
//-------------------------------------------------------------------
/*!
  * \fn void exo3()
  * \brief Exercice 3:
  * Vous devez piloter le port de sortie pour réaliser le transcodage de la 
  * valeur 4 bits lues sur entrée(3..0) vers les 7 bits du port de sortie 
  * (6..0) en utilisant le tableau tab fourni,
  * puis ajouter le pilotage de la sortie 7 avec l'entrée 7
*/
void exo3(){
  byte tab[]={0x3f,0x06,0x5b,0x4F,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
  unsigned char e = readPort();
  unsigned char e30 = e & 0b1111;
  unsigned char e7 = e & 0b10000000;
  unsigned char s = tab[e30] | e7;

  writePort(s);
}
//-------------------------------------------------------------------
/*!
  * \fn void exo4()
  * \brief Exercice 4:
  * Vous devez configurer les entrées sorties numériques de l'arduino numéro 
  * BUTTONPIN et LEDPIN, puis effectuer la recopie de l'entrée BUTTONPIN sur la 
  * sortie LEDPIN en boucle.  
  * https://www.arduino.cc/reference/en/language/functions/digital-io/pinmode/
  * https://www.arduino.cc/reference/en/language/functions/digital-io/digitalread/
  * https://www.arduino.cc/reference/en/language/functions/digital-io/digitalwrite/
*/
void exo4(){
  digitalWrite(3, (digitalRead(2)));
}
//-------------------------------------------------------------------
/*!
  * \fn void exo5()
  * \brief Exercice 5:
  * Vous devez configurer l'entrée analogique A0  puis effectuer la commande du 
  * port de sortie pour qu'une seule LED s'allume à la position approximative du 
  * potentiomètre.
  * https://www.arduino.cc/reference/en/language/functions/analog-io/analogread/
*/
void exo5(){
  uint16_t i = analogRead(analogPin);
  unsigned char s = 1<<(7-(i/128)); // (1<<(7-(val>>7)))

  writePort(s); 
}
//-------------------------------------------------------------------
/*!
  * \fn void exo6()
  * \brief Exercice 6:
  * Vous devez configurer l'entrée analogique A0  puis effectuer la commande de 
  * la LED connecté à la sortie LEDPIN afin qu'elle clignote à une fréquence 
  * pilotée par le potentiomètre. La commande de la durée des états hauts et bas 
  * de la sortie LEDPIN sera gérée à l'aide d'une fonction d'attente bloquante delay: 
  * https://www.arduino.cc/reference/en/language/functions/time/delay/
*/
void exo6(){
  uint16_t i = analogRead(analogPin);
  digitalWrite(3,0);
  digitalWrite(3,1);
  delay(i);

  /*
  static unsigned char etat = 0;

  etat = (etat +1)%2;
  etat = etat ^ 1;

  if (etat == 0) etat =1;
  else                =0;

  digitalWrite(LEDPIN, etat);
  delay (analogRead(analogPin));

  */
}
//-------------------------------------------------------------------
/*!
  * \fn void exo7()
  * \brief Exercice 7:
  * Vous devez configurer l'entrée analogique A0  puis effectuer la commande de 
  * la LED connecté à la sortie LEDPIN afin qu'elle clignote avec un rapport cyclique 
  * piloté par le potentiomètre. La commande de la durée des états hauts et bas de 
  * la sortie LEDPIN sera cette fois ci gérée à l'aide d'une sortie PWM (la broche 
  * LEDPIN est compatible PWM) à l'aide de la fonction analogWrite() : 
  * https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/
*/
void exo7(){
  //uint16_t i = analogRead(analogPin);
  //analogWrite(3,255-(i/4));

  static unsigned char etat;
  etat = (etat +1)%2;
  digitalWrite(LEDPIN,etat);
  delay(((etat^1)*analogRead(analogPin)/10) + (etat*(1023-analogRead(analogPin))/10));
}
//-------------------------------------------------------------------
/*!
  * \fn void exo8()
  * \brief Exercice 8:
  * Vous devez combiner les exercices 1 et 6 en utilisant une durée de 2 secondes 
  * pour les états hauts et bas du signal pilotant la sortie LEDPIN. Faire en sorte 
  * que la fonction génère une demi période du signal carré. Constatez si 
  * le port de sortie est mis à jour instantanément lorsque le port d'entrée est 
  * modifié.
*/
void exo8(){
  // exo1
  unsigned char e = readPort();
  writePort(e);
  Serial.println(e,HEX);

  //exo6
  digitalWrite(3,0);
  digitalWrite(3,1);
  delay(2000);
}
//-------------------------------------------------------------------
/*!
  * \fn void exo9()
  * \brief Exercice 9:
  * Vous devez modifier l'exercice 8 pour faire en sorte que la recopie du port 
  * d'entrée se fasse sur le port de sortie en permanence. Pour cela utiliser une 
  * fonction non bloquante pour gérer la temporisation à l'aide d'un timer par 
  * scrutation: 
  * https://www.arduino.cc/reference/en/language/functions/time/millis/
*/
void exo9(){

  unsigned char e = readPort();
  writePort(e);
  Serial.println(e,HEX);


  static unsigned char etat;

  static uint32_t previousMillis = millis();
  const uint16_t periode = 2000;
  
  digitalWrite(LEDPIN, 1);
  if( millis() - previousMillis >= periode) {
    etat=etat^1;
    digitalWrite(LEDPIN, etat);
    previousMillis += periode;
  }
}
//-------------------------------------------------------------------
/*!
  * \fn void exo10()
  * \brief Exercice 10:
  * Découverte du pseudo parallélisme: Dans un premier temps exo10 appelle juste 
  * la fonction tache1() puis réalise une attente bloquante de 500ms.
*/
void exo10(){
  tache1();
  delay(500);
}
//-------------------------------------------------------------------
/*!
  * \fn void tache1()
  * \brief tache1:
  * Découverte du pseudo parallélisme: la tache 1 consiste à réaliser un compteur 
  * sur 4 bits sur les bits (3..0) du port de sortie. La valeur maximale prise par 
  * ce compteur est réglé par les bits (3..0) du port d'entrée. "t1" doit être 
  * affiché dans la console série.
*/
void tache1(){
  static uint8_t cpt=0;
  unsigned char e = readPort();
  unsigned char e30 = e & 0xF;

  cpt = (cpt+1);
  if (cpt > e30)
    cpt=0;

  uint8_t   t = (imageSortie &0b11110000) | (cpt&0b1111);
  writePort(t);
  imageSortie = t;
  
  Serial.println("t1");
  
}
//-------------------------------------------------------------------
/*!
  * \fn void exo11()
  * \brief Exercice 11:
  * Découverte du pseudo parallélisme: Dans un second temps exo11 appelle les 
  * fonctions tache1() et  tache2() puis réalise une attente bloquante de 500ms.
*/
void exo11(){
  tache1();
  tache2();
  delay(500);
}
//-------------------------------------------------------------------
/*!
  * \fn void tache2()
  * \brief tache2:
  * Découverte du pseudo parallélisme: la tache 2 consiste à réaliser un 
  * chenillard sur 4 bits sur les bits (7..4) du port de sortie. 4 séquences 
  * différentes sont définies dans les tableaux tab1 à 4 fournis. Le choix de 
  * la séquence utilisée est réalisé à l'aide des bits d'entrées (6..5). Si le 
  * bit d'entrée 4 est à 0 alors la séquence est mise en pause. "t2" doit être 
  * affiché dans la console série.
*/
void tache2(){
  static unsigned char cpt = 0;

  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};

  unsigned char e = readPort();
  unsigned char e4 = (e & 0x10) >> 4; // (e>>4) & 1;
 
  cpt = (cpt+e4)%6; // cpt = tabcpt[cpt];
  // imageSortie = (imageSortie & 0b1111) | ((cpt & 0b1111)<<4);

  unsigned char v;
  unsigned char e65 = (e>>5)&3;
  /*
  switch(e65){
    case 0 :
      v = tab1[cpt];
      break;
    case 1 :
      v = tab2[cpt];
      break;
    case 2 :
      v = tab3[cpt];
      break;
    case 3 :
      v = tab4[cpt];
      break;
    default :
      Serial.println("probleme e63");
  }*/
  
  // v = tab[cpt + e65*6];
  unsigned char *tabtab[] = {tab1,tab2,tab3,tab4};
  
  imageSortie = (imageSortie & 0b1111) | (((tabtab[e65][cpt])&0b1111)<<4);
  writePort(imageSortie);

}
//-------------------------------------------------------------------
/*!
  * \fn void exo12()
  * \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 uint32_t previousMillis = millis();
  const uint16_t periodeTache1 = 500;
  
  if( millis() - previousMillis >= periodeTache1) {
    tache1();
    previousMillis += periodeTache1;
  }

  static uint32_t previousMillis2 = millis();
  const uint16_t periodeTache2 = analogRead(A0);
  
  if( millis() - previousMillis2 >= periodeTache2) {
    tache2();
    previousMillis2 += periodeTache2;
  }
}
//-------------------------------------------------------------------
/*!
  * \fn void exo13()
  * \brief Exercice 13:
  * Gestion d'une interruption matérielle: ajouter à l'exo12 la commande de la 
  * commutation de la LED connectée à LEDPIN par l'appui sur le bouton poussoir 
  * connecté à BUTTONPIN. Pour cela vous utiliserez une interruption sur broche. 
  * La liste des vecteur d'interruption est visible en page 49 de  
  * https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7810-Automotive-Microcontrollers-ATmega328P_Datasheet.pdf 
  * vous utiliserez external interrupt en page 53, BUTTONPIN doit être égal à 2 
  * car c'est uniquement cette broche qui peut déclencher cette interruption.
*/
void exo13(){
exo12();
}
//Début solution
void setupINT0(){
  pinMode(LEDPIN, OUTPUT);
  digitalWrite(LEDPIN,HIGH);
  pinMode(BUTTONPIN, INPUT_PULLUP);
  cli();           // disable all interrupts
  EICRA= (EICRA&0xFC) |2; //ICS0 = 10 pour front descendant
  EIMSK= EIMSK|1; //enable INT0
  sei();             // enable all interrupts
}
//-------------------------------------------------------------------
/* PROBLEME IL Y A LES REBONDS SUR LE POUSSOIR.... anti rebond par logiciel  
  * en inhibant les interruptions après la première pendant un certain temps
  */
ISR(INT0_vect) {
  unsigned int minTempsEntreIT0=300;
  static unsigned long timerIT0 = millis();
  static unsigned char counter=0;
  unsigned long timeActuel=millis();
  if ( timeActuel - timerIT0 >= minTempsEntreIT0) {
    timerIT0=timeActuel;
    if (counter==0)  
      digitalWrite(LEDPIN,LOW); //allume
    else
      digitalWrite(LEDPIN,HIGH); //eteind
    counter = (counter+1)%2;
    Serial.println("it");
    }
}
////autre exo à envisager: désactivation dans l'it puis réactivation dans loop via timer partagé
//-------------------------------------------------------------------
//temporisation avec interruption timer -> sera vu au tp suivant sur afficheur 7 segments
//-------------------------------------------------------------------
//Fin solution