/*
  * ===========================================================================================================================================================================
  * ======================================================================Le coffre Fort Arduino===============================================================================
  * ===========================================================================================================================================================================
  *
  *
  * ====================LE CONTEXTE====================
  * L'idee de faire ce projet de coffre a ete initie lors d'un atelier des petits debrouillards de Brest auquel les eleves de L'Ecole Nationale d'Ingenieurs de Brest ( ENIB ) ont participe durant l'intersemestre 2012/2013
  * Ceci dans l'objectif de le televerser sur le wikidebrouillard.
  *
  * ====================LE PRINCIPE====================
  * L'idee est de faire un coffre à code controle par une carte arduino.
  * Ce coffre à code sera compose de 5 LED, 1 potentiometre et 4 boutons, ainsi que 2 servomoteurs.
  * Par defaut, le code est compose de 5 verrous: il faut bien positionner le potentiometre (allumer le bon nombre de LED), puis composer un code à 4 chiffre
  * si l'utilisateur le veut, il peut changer le code, l'agrandir ou bien le reduire, en modifiant le code ci-dessous à un endroit particulier
  *
  * ====================LE CODE========================
  * Ce code permet de gerer les entrees et sorties de la carte Arduino.
  *
  * Realise par les eleves de l'Ecole Nationale D'ingenieurs de Brest:
  * Clement Le Fay
  * Glen Bertrand
  * Timothee Marescot
  * Simon Teneau
  * 
  * Realise en Janvier 2013
 */
 
 //La ligne ci-dessous importe la librairie "Servo.h" qui contient une liste de fonction permettant d'utiliser des servomoteurs
#include <Servo.h> 

/*
  * ================================= Declarations des fonctions du programme =================================
  * Les 3 lignes suivantes permettent de prevenir le logiciel que plus loin dans le code nous allons fabriquer 3 fonctions: remiseZeroCode,ouvrirCode et afficherCodeActuel.
  * Cela nous permet d'utiliser ces fonctions, qui sont des lors connues par le programme, avant meme d'avoir besoin de les implementer ( definir le code qui constituera ces fonctions )
*/

void remiseZeroCode(void);
void ouvrirPorte(int value);
void afficherCodeActuel(void);

/*
  * ================================= Fin de la declaration des fonctions =================================
  *
  *
  *
  *
  *================================= Definition des Variables globales du programme =================================
*/

/*
  * Variables definissant sur quels entrees et sorties sont places les composants
  * Variables d'entree, ce sont des variables de type "int" car on met des nombres entiers à l'interieur
*/

int sensorPin = 0;     // select the input pin for the potentiometer - le potentiometre est place sur l'entree 0 de l'arduino (attention, entree analogiques)
int switchPin1 = 2;    // input switch 1 - interrupteur sur la patte 2 de l'arduino ( entree numerique )
int switchPin2 = 3;    // input switch 2 - interrupteur sur la patte 3 de l'arduino ( entree numerique )
int switchPin3 = 4;    // input switch 3 - interrupteur sur la patte 4 de l'arduino ( entree numerique )
int switchPin4 = 5;    // input switch 4 - interrupteur sur la patte 5 de l'arduino ( entree numerique )

//============

/*
  * Variables pour les Led
  * Variables de sortie, ce sont des variables de type "int" car on met des nombres entiers à l'interieur
*/

int ledPin1 = 13;      // select the pin for the LED1 - La led 1 doit être placee sur l'entree/sortie numerique 13 de l'arduino
int ledPin2 = 12;      // select the pin for the LED2 - La led 2 doit être placee sur l'entree/sortie numerique 12 de l'arduino
int ledPin3 = 11;      // select the pin for the LED3 - La led 3 doit être placee sur l'entree/sortie numerique 11 de l'arduino
int ledPin4 = 10;      // select the pin for the LED4 - La led 4 doit être placee sur l'entree/sortie numerique 10 de l'arduino
int ledPin5 = 9;      // select the pin for the LED5 - La led 5 ( blanche qui signale l'ouverture du coffre) doit être placee sur l'entree/sortie numerique 9 de l'arduino

//============

/*
  * Ici, nous definissons deux variables qui permettront de commander les deux servomoteurs qui ouvrent la porte
  * Ce sont des variables de type Servo, un type de variable qui a ete importe avec la bibliotheque servo.h en debut de programme
*/

Servo servoPorte; 
Servo servoPorte2;

//============

/*
 * //======================================================
 * //=========== DEFINITION DU CODE D'OUVERTURE ===========
 * 
 * Ci dessous, c'est une partie tres importante dans notre programme, puisque elle definit le code d'ouverture du coffre !
 * Vous pouvez modifier le code à volonte et le tester ensuite pour verifier que ça fonctionne !
*/

// definit la taille du code d'ouverture, modifiez le 5 par le nombre de votre choix
const int sizeCode=5;
/*
  * le code qu'il faut rentrer si on veut ouvrir le coffre. Votre code doit être homogene avec le nombre rentre precedemment, par exemple ici nous avons un code à 4 chiffre: 2,1,3,4.
  * L'ordre est bien sur important, et chaque chiffre doit être separe du precedent par une ","
  * Attention, il s'agit bien ici d'un code à 4 chiffres, meme si le tableau fait 5 cases.
  * En effet, le premier chiffre correspond à la position du potentiometre. le 3 signifie 3 LED allumees à la surface du coffre, ce chiffre est bien sur modifiable, dans un intervalle de 1 à 4
*/
int code[sizeCode]={3,2,1,3,4};    
//cette variable contient à tout instant le code que l'on a rentre via les boutons. Ici, on le rempli de zero !
int codeActuel[sizeCode]={0}; 

//Variables qui permettent de faire fonctionner le programme, elles indiquent la situation des differentes parties du coffre à un moment donne
int emplacementActuelTableau=1;   //indexeur sur le tableau codeActuel
int porteOuverte=0;     //Indique quand la porte est ouverte (1) ou fermee (0)
int ouverturePorte=1;   //Indique quand il faut ouvrir la porte(1), ou la fermer (0);
int antirebond=0;       //permet d'eviter qu'à la suite d'un appui sur plusieurs boutons simultanement ou un appui long, le code tape soit mal interprete.
                        //permet egalement d'eviter qu'un appui court sur un bouton soit compte plusieurs fois dans le programme
int alarme=0;


//Variables qui permettent de recuperer les valeurs du potentiometre et du bouton
int sensorValue = 0;     //recupere la valeur du potentiometre
int sensorSwitch1 = 0;   //recupere la valeur du bouton poussoir 1
int sensorSwitch2 = 0;   //recupere la valeur du bouton poussoir2
int sensorSwitch3 = 0;   //recupere la valeur du bouton poussoir3
int sensorSwitch4 = 0;   //recupere la valeur du bouton poussoir4

/*
  * ================================= Fin de la definition des variables globales ==================
  * 
  * 
  *
  * ================================= Debut de programme principal =================================
*/

//Phase D'initialisation du programme avec la fonction setup qui est la premiere appelee lorsqu'on lance le programme
void setup() {

  //Ci-dessous, nous declarons que les pins associees aux variables ledPin1,ledPin2, .... declarees precedemment, seront utilisees comme des sorties.
  pinMode(ledPin1, OUTPUT);  
  pinMode(ledPin2, OUTPUT);  
  pinMode(ledPin3, OUTPUT);  
  pinMode(ledPin4, OUTPUT);  
  pinMode(ledPin5, OUTPUT); 
  .
  //Indique la vitesse de raffraichissement de la liaison serie entre l'ordinateur et la carte Arduino.
  Serial.begin(9600);
  
  //Ci-dessous, nous declarons que les pins associees aux variables switchPin1,switchPin2, .... declarees precedemment, seront configurees comme des entrees.
  pinMode(switchPin1, INPUT);  
  pinMode(switchPin2, INPUT); 
  pinMode(switchPin3, INPUT); 
  pinMode(switchPin4, INPUT); 
  
  //Pour les servomoteurs, c'est un peu particulier, il faut utiliser les fonctions contenu dans la librairie servo.h pour les initialiser.
  servoPorte.attach(6);  //Indique que le servomoteur numero 1 de la porte sera sur la pin 6 de l'arduino
  servoPorte.write(0);   //Indique au servomoteur sa Position initiale. ( la valeur entre "(NOMBRE)" est situee entre 0 et 180°.), la fonction write() permet de donner une position au servomoteur
  servoPorte2.attach(7); //Indique que le servomoteur numero 2 de la porte sera sur la pin 7 de l'arduino
  servoPorte2.write(180);//Indique au servomoteur sa Position initiale. ( la valeur entre "(NOMBRE)" est situee entre 0 et 180°)
  
}

//============

/*
  * Definition d'une fonction ouvrirPorte qui prend un parametre value.
  * Si value est egal à 1, la porte s'ouvre.
  * Si value est egal à 0, la porte se ferme.
*/
void ouvrirPorte(int value)
{
  //Ceci est une condition: le if veut dire "SI"
  //Si la condition entre parenthese est vraie, on execute les instructions entre crochets
  if (value==1) 
  {
     servoPorte.write(90);    //Ordonne le deplacement des servomoteurs en position ouverte
     servoPorte2.write(90);
     digitalWrite(ledPin5, HIGH);  //Allumage de la led signalant l'ouverture de la porte
     porteOuverte=1;               //On met cette variable à 1 pour dire que la porte est ouverte !
  }
  if (value==0)
  {
    servoPorte.write(0);  //Ordonne le deplacement des servomoteurs en position fermee
    servoPorte2.write(180);
    digitalWrite(ledPin5, LOW);    //Extinction de la led de la porte
    porteOuverte=0;            //la porte est refermee, cette variable est donc mise à zero
  }
}

//============

/*
    * Cette fonction, lorsqu'elle est appelee, permet de faire un reset du code qui a ete rentre precedemment.
    * Celà permet, par exemple en cause de mauvaise manipulation, de recomposer le code !
*/
void remiseZeroCode(void)
{
    for ( int i=0; i<sizeCode;i++)    //On passe autant de fois que necessaire (la taille du code), pour faire le reset ! D'ou l'interet d'une boucle pour ce faire
    {
         codeActuel[i]=0; 
    }
}

//============

/*
    * Cette fonction, permet d'afficher le code actuel qui a ete saisi au niveau de la liaison serie.
*/

void afficherCodeActuel(void)
{
     Serial.println("--------Affichage du code actuel-------");
     Serial.print(codeActuel[0]);
     Serial.print(codeActuel[1]);
     Serial.print(codeActuel[2]);
     Serial.print(codeActuel[3]);
     Serial.println(codeActuel[4]);
}

//============

void loop() {
  // Ici, on charge dans les differentes variables les valeurs recuillies par les capteurs
  sensorValue = analogRead(sensorPin);                //Valeur potentiometre
  sensorSwitch1 = digitalRead(switchPin1);            //valeur Switch 1
  sensorSwitch2 = digitalRead(switchPin2);            //valeur Switch 2
  sensorSwitch3 = digitalRead(switchPin3);            //valeur Switch 3
  sensorSwitch4 = digitalRead(switchPin4);            //valeur Switch 4

 /*
    * Ci dessous, en commentaire, des instructions permettant l'affichage des differentes valeurs recueillies par les capteurs.
    * Ce procede: affiche les valeurs, nous a permis de verifier le bon fonctionnement du programme durant son elaboration.
    *
    * Petite precision: La fonction Serial.print("VOTRETEXTEOUVARIABLE"); permet d'afficher sur la liaison serie ce que vous voulez.
    * LA liaison serie, c'est celle qui est etablie entre la carte et l'ordinateur via le calbe USB !
    *
    * Pour voir ces informations, dans le logiciel arduino, allez dans outils, puis moniteur Serie.
    * 
    * Une legere diference est à remarquer entre la fonction print et la fonction println, puisque cette derniere permet de sauter une ligne de maniere automatique !
 */


/*
  //Affichage des valeurs
  Serial.print("Valeur Potentiometre");
  Serial.println (sensorValue);
  Serial.print("Valeur Switch 1 : ");
  Serial.println (sensorSwitch1);
  Serial.print("Valeur Switch 2 : ");
  Serial.println (sensorSwitch2);
  Serial.print("Valeur Switch 3 : ");
  Serial.println (sensorSwitch3);
  Serial.print("Valeur Switch 4 : ");
  Serial.println (sensorSwitch4);
  
 //Affichage du code actuel
  Serial.println("--------Affichage du code vise-------");
 Serial.print(code[0]);
 Serial.print(code[1]);
 Serial.print(code[2]);
 Serial.print(code[3]);
 Serial.println(code[4]);
 
 Serial.println("--------Affichage du code actuel-------");
 Serial.print(codeActuel[0]);
 Serial.print(codeActuel[1]);
 Serial.print(codeActuel[2]);
 Serial.print(codeActuel[3]);
 Serial.println(codeActuel[4]);
*/

//==================================================================================
//ALLUMAGE DES LED EN FONCTION DE LA POSITION DU POTENTIOMETRE
  /*
      * Allumage des LED en fonction de la position du potentiometre: 1,2,3 ou 4 LED allumees
  */

  digitalWrite(ledPin1, HIGH); //Premiere led tout le temps allume  ( temoignant que l'on est en mode de fonctionnement normal )
  if (sensorValue<1000)
  {
    if (sensorValue>250)
    {
       digitalWrite(ledPin2, HIGH); //Allumage Deuxieme LED si on a assez tourne le potentiometre
       codeActuel[0]=2;
       if (sensorValue>500)
       {
           digitalWrite(ledPin3, HIGH);//Allumage Troiseme  LED si on a assez tourne le potentiometre
           codeActuel[0]=3;
           if (sensorValue>750)
           {
               digitalWrite(ledPin4, HIGH); //Allumage Quatrieme  LED  si on a assez tourne le potentiometre ( quasiment en butee )
               codeActuel[0]=4;
           }
       }
    }
  }
  else //POSITION RESET, butee du potentiometre, on effectue la remise à zero des variables, et la fermeture du coffre et la coupure de l'alarme si besoin
  {
    remiseZeroCode();                //Appel à la fonction de remise à zero du code rentre
    digitalWrite(ledPin1, LOW);      //on coupe toutes les LED !
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    digitalWrite(ledPin4, LOW);
    emplacementActuelTableau=1;      //On revient en situation initiale dans la tableau, pret à de nouveau le remplir avec la sequence de chiffre fourni par l'utilisateur
    
    //commande fermeture Porte
    ouvrirPorte(0);                  //On appelle la fonction ouvrirPorte en lui envoyant la valeur 0 -----> on lui demande de refermer la porte
    alarme=0;                        //On coupe le signal d'alarme !
    noTone(8); 
  }
  
  //============================================
  //Gestion extinction des LED
  /*
      * De meme que pour l'allumage des LED, on fait divers tests sur la valeur du potentiometre pour savoir à quel endroit il est actuelement, puis on eteint les LED si besoin.
  */
  if (sensorValue < 750)
  {
      digitalWrite(ledPin4, LOW);    
      codeActuel[0]=3;
  }
  if (sensorValue < 500)
  {
     digitalWrite(ledPin3, LOW);
     codeActuel[0]=2;
  }
  if (sensorValue < 250)
  {
    digitalWrite(ledPin2, LOW);
    codeActuel[0]=1;
  }
  
  
  //============================================
  //Gestion de l'arret de l'antirebond
  /*
      * Si tout les boutons sont relaches, on peut couper l'antirebond
      * 
      * Antirebond: permet d'eviter un appui simultane sur des boutons, et sa prise en compte plusieurs fois dans le code.
  */
  if((sensorSwitch1==LOW) && (sensorSwitch2==LOW)&& (sensorSwitch3==LOW) && (sensorSwitch4==LOW))
  {
      antirebond=0;
  }
  
  //============================================
  //Gestion des boutons
  /*
       * C'est ici que sont gerees les differentes actions associees aux boutons!
       * Quand on appui sur un bouton, son numero est rentre dans le tableau contenant le code de l'utilisateur.
       * à cet instant, on affiche le code actuellement contenu dans le tableau, puis on active l'antirebond qui ne sera desactive que quand il n'y aura plus d'actions sur les boutons
       * si l'antirebond est active ( =1), on n'effectue plus d'actions sur les boutons ( condition if ! )
  */
  if (antirebond==0)
  {
    if((sensorSwitch1==HIGH) && (sensorSwitch2==LOW)&& (sensorSwitch3==LOW) && (sensorSwitch4==LOW))
    {
        Serial.println("Passage switch 1");
       codeActuel[emplacementActuelTableau]=1;
       emplacementActuelTableau+=1;
        afficherCodeActuel();
        antirebond=1; 
    }
    else if((sensorSwitch2==HIGH) && (sensorSwitch1==LOW)&& (sensorSwitch3==LOW) && (sensorSwitch4==LOW))
    {
       Serial.println("Passage switch 2");
       codeActuel[emplacementActuelTableau]=2;
       emplacementActuelTableau+=1;
       afficherCodeActuel();
         antirebond=1;
    }
    else if((sensorSwitch1==LOW) && (sensorSwitch2==LOW)&& (sensorSwitch3==HIGH) && (sensorSwitch4==LOW))
    {
       Serial.println("Passage switch 3");
       codeActuel[emplacementActuelTableau]=3;
       emplacementActuelTableau+=1;
       afficherCodeActuel();
       antirebond=1;
    }
    else if((sensorSwitch1==LOW) && (sensorSwitch2==LOW)&& (sensorSwitch3==LOW) && (sensorSwitch4==HIGH))
    {
       Serial.println("Passage switch 4");
       codeActuel[emplacementActuelTableau]=4;
       emplacementActuelTableau+=1;
       afficherCodeActuel();
         antirebond=1;
    }
  }
  
  ouverturePorte=1; //Variable mise à 1 par defaut
  
  //===============================================================
  //test codeTableau compare au code que l'on doit rentrer
  /*
      * Une boucle qui permet de detecter si il y a une erreur dans le code, et donc de decider s'il faut ou non ouvrir ou fermer la porte du coffre
  */
  for ( int i=0; i< sizeCode;i++)
  {
     if (code[i]!=codeActuel[i])
     {
       ouverturePorte=0; // si une anomalie dans le code est detectee, mise à zero de la variable, la porte restera donc fermee pour ce passage dans la fonction loop
     }
  }
  
  //===============================================================
  //Alarme si mauvais code rentre
  /*
       * Le code ci dessous permet de determiner s'il faut oui ou non ouvrir l'alarme.
       * Si le code rentre par l'utilisateur ne correspond pas à celui defini dans le programme, la variable alarme est mise à 1, ce qui declenche le bruit du buzzer.
       * on compare chaque composante du tableau initial à celui de l'utilisateur, pour celà on utilise une boucle for qui fait la taille du tableau.
       * L'alarme ne peut être allume que si le potentiometre n'est pas en position reset (  sensorValue<1000 ), et seulement si la porte est fermee ( porteOuverte==0 )
  */
  if ((codeActuel[4]!=0) && (sensorValue<1000) && (porteOuverte==0))
  {
     for ( int i=0; i< sizeCode;i++)
      {
         if (code[i]!=codeActuel[i])
         {
           tone(8, 494, 500);
           alarme=1;
         }
      } 
  }

  //===============================================================
  //Gestion ouverture Porte
  /*
    * Si on demande l'ouverture de la porte ( variable OuverturePorte ==1 ), et si l'alarme est coupee ( alarme ==0 ), on demande à ouvrir la porte avec la fonction ouvrirPorte qui prend en parametre 1.
  */
  if ((ouverturePorte==1) && (alarme==0))
  {
     //COMMANDE OUVERTURE PORTE!
     ouvrirPorte(1);  
  }      


  /*
      *  //===============================================================
      * Arrive à cet endroit du programme, nous sommes à la fin de la liste d'instructions.
      * Le programme reboucle alors et repart au debut de la fonction Loop, en reprenant une à une les instrutions precedentes, jusqu'a l'arret de la carte ou l'insertion d'un nouveau programme )
      * 
      * 
      * Nous vous remercions d'avoir pris le temps de nous lire et d'avoir suivi cette experience.
      * Bon courage pour la realisation de votre coffre arduino.
      ****** les eleves de l'ENIB******
      *  //===============================================================
  */  
}