//-------------------------------------------------------------------------------
//  Partie 1 du programme : La détection

// Inclut les bibliothèques Arduino requises:
#include <MD_Parola.h>
#include <MD_MAX72XX.h>
#include <SPI.h>
#include <Ethernet.h>

// Définissez le type de matériel, la taille et les broches de sortie:
#define HARDWARE_TYPE MD_MAX72XX :: FC16_HW
#define MAX_DEVICES 4
#define CS_PIN 10

// Créer une nouvelle instance de la classe MD_Parola avec une connexion SPI matérielle:
// MD_Parola myDisplay = MD_Parola ( HARDWARE_TYPE, CS_PIN, MAX_DEVICES ) ;

// Configuration pour le logiciel SPI:
#define DATAPIN 11
#define CLK_PIN 13
#define HP_Pin 7 // Brancher haut-parleur sur pin 7
 MD_Parola myDisplay = MD_Parola (HARDWARE_TYPE, DATAPIN, CLK_PIN, CS_PIN, MAX_DEVICES);
/*
// L'adresse MAC du shield
byte mac[] = { 0x90, 0xA2, 0xDA, 0x0E, 0xA5, 0x7E };
// L'adresse IP que prendra le shield
IPAddress ip(192,168,0,143);

// Initialise notre serveur
// Ce dernier écoutera sur le port 4200
EthernetServer serveur(4200);
char *url = (char *)malloc(100); // L'url recu à stocker
char index = 0; // index indiquant où l'on est rendu dans la chaîne
*/
// Modifier le nombre limite ici : 
int y = 2 ; //Limites maximal de personnes dans la pièce
int i = 0; //Nombre de visiteurs
int currentState = 0;
int previousState = 0;
int currentState2 = 0;
int previousState2 = 0;

#define trigPin 2 
#define echoPin 3 
#define trigPin2 4 
#define echoPin2 5 

void setup() {
  Serial.begin (9600); // on va utiliser notre ordinateur afin de lire ce que dit la carte Arduino
  pinMode(trigPin, OUTPUT); // on active la borne trigger du capteur 1
  pinMode(echoPin, INPUT); // on active la borne echo du capteur 1
  pinMode(trigPin2, OUTPUT); // on active la borne trigger du capteur 2
  pinMode(echoPin2, INPUT); // on active la borne echo du capteur 2
  Serial.println("Demarrage du programme"); // Indique lorsque à l'utilisateur lorsque le programme démarra
  
  // Initialisez l'afficheur :
  myDisplay. begin () ;
  // Réglez l'intensité (luminosité) de l'affichage (0-15):
  myDisplay. setIntensity ( 0 ) ;
  // Effacer l'affichage:
  myDisplay. displayClear () ;

/*// On démarre la voie série pour déboguer
 char erreur = 0;
  // On démarre le shield Ethernet SANS adresse IP (donc donnée via DHCP)
  erreur = Ethernet.begin(mac);

  if (erreur == 0) {
    Serial.println("Parametrage avec ip fixe...");
    // si une erreur a eu lieu cela signifie que l'attribution DHCP ne fonctionne pas. On initialise donc en forçant une IP
    Ethernet.begin(mac, ip);
  }
  Serial.println("Init...");
  // Donne une seconde au shield pour s'initialiser
  delay(1000);
  // On lance le serveur
  serveur.begin();
  Serial.print("Pret !");*/
}

void loop() {

 long duration, distance;
 digitalWrite(trigPin, LOW); 
 delayMicroseconds(2); 
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10); 
 digitalWrite(trigPin, LOW);
 duration = pulseIn(echoPin, HIGH);
 distance = (duration/2) / 29.1;
 long duration2, distance2;
 digitalWrite(trigPin2, LOW); 
 delayMicroseconds(2); 
 digitalWrite(trigPin2, HIGH);
 delayMicroseconds(10); 
 digitalWrite(trigPin2, LOW);
 duration2 = pulseIn(echoPin2, HIGH);
 distance2 = (duration2/2) / 29.1;
 // object entering in the system
 if (distance <= 10){
 currentState = 1;
 }
 else {
 currentState = 0;
 }
 //delay(100);
 if(currentState != previousState){
 while(currentState == 1) {
 long duration2, distance2;
 digitalWrite(trigPin2, LOW); 
 delayMicroseconds(2); 
 digitalWrite(trigPin2, HIGH);
 delayMicroseconds(10); 
 digitalWrite(trigPin2, LOW);
 duration2 = pulseIn(echoPin2, HIGH);
 distance2 = (duration2/2) / 29.1;
 if (distance2 <= 10){
 currentState2 = 1;
 }
 else {
 currentState2 = 0;
 }
 //delay(100);
 if(currentState2 != previousState2){
 if(currentState2 == 1) {
 i = i+1;
 
 delay(1000); // pause for 1/2 second
 }
 if ( i < 0 ) { i = 0 ; }
 Serial.println(i) ;
 return;
 
   }
  }
 }
 // object exit from the system 
if (distance2 <= 10){
 currentState2 = 1;
 }
 else {
 currentState2 = 0;
 }
 delay(100);
 if(currentState2 != previousState2){
 while (currentState2 == 1) {
 long duration, distance;
 digitalWrite(trigPin, LOW); 
 delayMicroseconds(2); 
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10); 
 digitalWrite(trigPin, LOW);
 duration = pulseIn(echoPin, HIGH);
 distance = (duration/2) / 29.1;
 if (distance <= 10){
 currentState = 1;
 }
 else {
 currentState = 0;
 }
 delay(100);
 if(currentState != previousState){
 if(currentState == 1) {
 i = i-1; 
if ( i < 0 ) { 
  i = 0 ; } 
 delay(1000); // pause for 1/2 second
 }
Serial.println(i) ;
 return;
   }
  }
 }

//-------------------------------------------------------------------------------
//  Partie 2 du programme : L'affichage 
//------------------------------------------------------------------------------- 
       // si le nombre de personnes est inférieur à la limite

if (i<y){
    myDisplay. setTextAlignment ( PA_LEFT ) ;
    myDisplay. print ( i ) ;
   delay (200) ;
    myDisplay. setTextAlignment ( PA_RIGHT);
    myDisplay. print( y );
    delay (200) ;
}
 
else {
   tone(HP_Pin,400,1000);
   delay(100) ;
    myDisplay. setTextAlignment ( PA_CENTER ) ;
    myDisplay. print ( "STOP" ) ;
    delay ( 500 ) ;
    myDisplay. setTextAlignment ( PA_LEFT ) ;
    myDisplay. print ( i ) ;
    delay (200) ;
    myDisplay. setTextAlignment ( PA_RIGHT);
    myDisplay. print ( y ) ;
   delay (200) ;
    
   }
}
  
 /*----------------------------------------------------------------
 Partie; Shield Ethernet 
 ----------------------------------------------------------------*/
/* // Regarde si un client est connecté et attend une réponse (Est-ce que quelqu'un s'est connecté à l'arduino ?)
EthernetClient client = serveur.available(); 
 if (client) {      // Un client est là ?
    Serial.println("Ping !");
    url = ""; // on remet à zéro notre chaîne tampon
    index = 0;
    while(client.connected()) { // Tant que le client est connecté
      if(client.available()) { // A-t-il des choses à dire ?
        // traitement des infos du client
        char carlu = client.read(); //on lit ce qu'il raconte
        if(carlu != '\n') { // On est en fin de chaîne ?
          // non ! alors on stocke le caractère
          Serial.print(carlu);
          url[index] = carlu;
          index++;
        } else {
          // on a fini de lire ce qui nous intéresse
          // on marque la fin de l'url (caractère de fin de chaîne)
          url[index] = '\0';
          boolean ok = interpreter(); // essaie d'interpréter la chaîne
          if(ok) {
            // tout s'est bien passé = on met à jour les données reçu
            action();
          }
          // et dans tout les cas on répond au client
          repondre(client); //ici repondre est une fonction que l'on a créer
          // on quitte le while
          break;
        }
      }
    }
    // Donne le temps au client de prendre les données
    delay(10);
    // Ferme la connexion avec le client
    client.stop();
    Serial.println("Pong !");
  }
}
boolean interpreter() {
  // On commence par mettre à zéro la limite : 
  y = 0 ; 
  // Puis maintenant on va chercher les caractères/marqueurs un par un.
  index = 0; // Index pour se promener dans la chaîne (commence à 4 pour enlever "GET ")
  while(url[index-1] != 'y' && url[index] != '='&& index<100){ // On commence par chercher le "y="
    index++; // Passe au caractère suivant
    if(index == 100) {
      // On est rendu trop loin !
      Serial.println("Oups, probleme dans la recherche de 'y='");
      return false;
    }
  }
   // Maintenant, on va fouiller jusqu'a trouver un espace
  while(url[index] != ' ') { // On cherche le ' ' final
    if(url[index] >= '0' && url[index] <= '9') {
      // On a trouve un chiffre !
      char val = url[index]-'0'; // On ramene ca au format decimal
      y= (y*10)+ val; // On stocke dans y
    }
    index++; // Passe au caractère suivant
    if(index == 100) {
      // On est rendu trop loin !
      Serial.println("Oups, probleme dans la lecture de la limite");
      return false;
    }
  }
  // Rendu ici, on a trouvé toutes les informations utiles !
  return true;
}
void action() {
  // On met à jour nos données 
  y= y; 
}
void repondre(EthernetClient client) {
  // La fonction prend un client en argument
  Serial.println("\nRepondre"); // debug
  // On fait notre en-tête
  // Tout d'abord le code de réponse 200 = réussite
  client.println("HTTP/1.1 200 OK");
  // Puis le type mime du contenu renvoyé, du json
  client.println("Content-Type: application/json");
  // Autorise le cross origin
  client.println("Access-Control-Allow-Origin: *");
  // Et c'est tout !
  // On envoi une ligne vide pour signaler la fin du header
  client.println();

  // Puis on commence notre JSON par une accolade ouvrante
  client.println("{");
  // On envoie la première clé : "Visiteurs"
  client.print("\t\"Visiteurs\": ");
  // Puis la valeur de x qui correspond au nombre actuel de visiteurs
  client.print(i);
   // On envoie la deuxième clé : "Limite"
  client.print("\t\"Limite\": ");
    // Puis la valeur de V qui correspond au nombre maxi de visiteurs
  client.print(y);
  client.println("\t}");
  // Et enfin on termine notre JSON par une accolade fermante
  client.println("}");  
}*/