#include <Adafruit_NeoPixel.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_VL53L0X.h"
#include "DHT.h"

#define NUMPIXELS 10 // Popular NeoPixel ring size
#define DELAYVAL 200 // Time (in milliseconds) to pause between pixels


//----------------------------------------------------------------------
//                        NANO 
//  
//                        ===============    
//                       -|             |- 
//                       -|             |- 
//                       -|             |- 
//      Tension BAT   A0 -|             |-
//      Alarme        A1 -|             |- D8  DONE  
//                       -|   NANO      |- D7  VL53L0X 1
//                       -|             |- D6  VL53L0X 2
//              SDA   A4 -|             |- D5  Panneau 2
//              SCL   A5 -|             |- D4  Panneau 1
//                       -|             |- D3  LDR
//                       -|             |- D2  DHT
//                   +5V -|             |- GND
//                       -|             |- 
//                   GND -|             |- 
//                   DRV -|             |-  
//                        ===============
//-----------------------------------------------------------------------

   
// Capteurs vl53l0x..............................
#define pinLOX1  7                  //* Capteur 1           */
#define pinLOX2  6                  //* Capteur 2           */
#define LOX1_ADDRESS         0x30                //* Adresse I2C : 0x30  */
#define LOX2_ADDRESS         0x29                //* Adresse I2C : 0x29  */
#define maxDistance          100                 //* distance max 100 mm */
Adafruit_VL53L0X LOX1      = Adafruit_VL53L0X();
Adafruit_VL53L0X LOX2      = Adafruit_VL53L0X();
VL53L0X_RangingMeasurementData_t measure1;
VL53L0X_RangingMeasurementData_t measure2;
 
// DHT22.........................................
#define pinDHT               2                  
DHT dht(pinDHT, DHT22);                          // DHT22  (AM2302), AM2321
 
// Mesure Batterie...............................
#define pinVp                A0                  //* mesure BATT                                 */
#define VccMin               3.2                 //* Niveau minimum attendu de BAT, en Volts     */
#define VccMax               4.2                 //* Niveau maximum attendu de BAT, en Volts     */
#define VccRange             VccMax - VccMin        
const float Ratio          = 100.0 ;             // Eviter les divisions par la suite


// Branchements ...................................................... 
#define pinLDR                3                   //* LDR            */
#define pinAlarm             13                   //* Alarme      */
#define DONEPIN               8                   //* TPL5110 pin DONE  */
#define pinP1                 4                   //* Panneau 1 ouvert */
#define pinP2                 5                   //* Panneau 2 ouvert /*
 
// Variables
bool P1                    = 0;                  // 0: ferme, 1: ouvert
bool P2                    = 0;                  // 0: ferme, 1: ouvert
bool isDark                = 0;                  // Luminosité faible
bool isRaining             = 0;                  // Humidité forte
int pp                     = 0;
int tt                     = 0;
int hh                     = 0;
bool n1                    = 0;
bool n2                    = 0;
int  valarme               = 0;
bool donneesEnvoyees       = false;
bool vDHT                  = false;
bool vVCC                  = false;

//unsigned long previousMillis = 0; 
//const long interval = 30000;    

Adafruit_NeoPixel pixels(NUMPIXELS, pinAlarm , NEO_GRB + NEO_KHZ800);
 

void ReadPanels() {  // Lire l'état des panneaux ***********************************************************************
     
   // Capteur1 en lecture........................
   // P1 = 1 si panneau n°1 ouvert
   Serial.print(F("Panneau N°1 => "));
   LOX1.rangingTest(&measure1, false);    // 'true' pour avoir les données de débogage
   //P1 = (measure1.RangeMilliMeter - 10 >  maxDistance); 
   P1 = (measure1.RangeMilliMeter >  maxDistance); 
   Serial.print(P1);
   if(P1) Serial.print(F("- Ouvert")); else Serial.print(F("- Fermé"));
   Serial.println();
  
   // Capteur2 en lecture........................
   // P2 = 1 si panneau n°2 ouvert
   Serial.print(F("Panneau N°2 => "));
   LOX2.rangingTest(&measure2, false);  // 'true' pour avoir les données de débogage
   //P2 = (measure2.RangeMilliMeter - 10 >  maxDistance);
   P2 = (measure2.RangeMilliMeter >  maxDistance);
   Serial.print(P2);
   if(P2) Serial.print(F("- Ouvert")); else Serial.print(F("- Fermé"));
   Serial.println();
   
   if (P1 != 0) digitalWrite(pinP1 , HIGH); else digitalWrite(pinP1 , LOW);
   if (P2 != 0) digitalWrite(pinP2 , HIGH); else digitalWrite(pinP2 , LOW);
   
 }
 

void ReadDHT() { // Lire Température et humidité********************************************************************
   float h = dht.readHumidity();
   float t = dht.readTemperature();
   //float correction = 3 ;
   // Check DHT22.
   if(isnan(t) || isnan(h))  {
     Serial.println("Impossible de lire la sonde DHT!");
     return;
   }
   Serial.print("Humidite : ");     Serial.print(round(h));    Serial.println("%");
   Serial.print("Temperature : ");  Serial.print(round(t));    Serial.println("°C");
   tt = t;
   hh = h;
   isRaining = h >= 90.0; // Test =35
   delay(100);
}
 

void ReadVcc() { // Lire la tension de la batterie *****************************************************************
	 
	  // lire la rension en A0 
    float v = analogRead(pinVp); // AnalogRead renvoi une valeur entre 0 et 1023
    float tension = (v * 1.1) / analogReadReference(); 
    float tensionRedressee = (tension / ( 33.74 / ( 33.74 + 110))*0.945 );
    Serial.print("tension Mesurée = " );   Serial.print(tensionRedressee);       Serial.println(" V");
     		
	  // Calculer Niveau de charge BATT 
	  int p = round(Ratio*((tensionRedressee-VccMin)));
    if(p > 100) p = 100 ; else if(p < 0) p = 0; 
    pp = p;	
    Serial.print("BAT = ");    Serial.print(pp);     Serial.println(" %");
       
 }


void alarme() { //******************************************

   Serial.print("vAlarme: ");    Serial.print(valarme);      Serial.println();	 
   for(int i=0; i<NUMPIXELS; i++) 
	 { // For each pixel...
       
       if (valarme==1){
          pixels.setPixelColor(i, pixels.Color(255, 0, 255)); // Sombre = VIOLET
       }
       if (valarme==2){
          pixels.setPixelColor(i, pixels.Color(255, 0, 0)); // Pluie = ROUGE
       }   
       if (valarme==3){
          pixels.setPixelColor(i, pixels.Color(0, 255, 0)); // Batterie = VERT
       }
        
        pixels.show();   // Envoyez les couleurs de pixel mises à jour au matériel.
        delay(DELAYVAL); // Pause avant le passage suivant dans la boucle
        pixels.setPixelColor(i, pixels.Color(0, 0, 0));
        pixels.show(); 
   }
  
} 


void alarmeOFF() { // Alarme OFF*****************************************
    pixels.clear();
	  pixels.show(); 
    isDark                = 0;                  // Luminosité faible ?
    isRaining             = 0; 
	  valarme = 0;
}	
 

void CheckAlarm() { // Vérifier si une alarme est nécessaire ******************

    pixels.clear();
    pixels.show(); 
    if ((P1 != 0) || (P2 != 0)) {                                  // > 0 si au moins l'un des panneaux est ouvert
      Serial.println(F("Panneaux ouverts..."));
      if (P1) (n1= 1) ;     // panneau 1 ouvert
      if (P2) (n2= 1) ;     // panneau 2 ouvert
      isDark = digitalRead(pinLDR);
        	  
     if(isDark || isRaining || (pp<=30) )
     {
       if(isDark) {
         Serial.println(F("Alarme obscurite..."));
         valarme = 1 ;
       }
       if(isRaining) {
        Serial.println(F("Alarme pluie..."));
        valarme  = 2 ;
       }

       pp = 100; // Test 
       if(pp<=30) {
        Serial.println(F("Batterie faible..."));
        valarme = 3;
       }
      
     alarme(); 
       
     }else{ 
          Serial.println(F("CheckAlarme ..OK "));
          alarmeOFF();
                   
     }  
    } else { // Les deux sont fermés
      Serial.println(F("Panneaux clos..."));
	    alarmeOFF();
    }  
    
}
 
// Initialiser les capteurs d'ouverture des panneaux **********************************************
void setID() {
   // tout est remis à zéro
   digitalWrite(pinLOX1, LOW);                   
   digitalWrite(pinLOX2, LOW);
   delay(10);
   // initialisation LOX1........................
   digitalWrite(pinLOX1, HIGH);
   delay(10);
   if(! LOX1.begin(LOX1_ADDRESS)) {
      Serial.println(F("Échec init 1er VL53L0X"));
      while(1);
    }
   // initialisation LOX2........................
   digitalWrite(pinLOX2, HIGH);
   delay(10);
   if(! LOX2.begin(LOX2_ADDRESS)) {
      Serial.println(F("Échec init 2nd VL53L0X"));
      while(1);
    }
}


//**************************************************
//             SETUP                               *
//**************************************************
void setup() {

   Serial.begin(9600);
   //Wire.begin (); 

   pinMode(pinAlarm, OUTPUT);                    // Sortie Alarme
   pinMode(pinLDR,   INPUT);                     // Entree LDR
   pinMode(pinLOX1, OUTPUT);                     // Sortie LOX1  
   pinMode(pinLOX2, OUTPUT);                     // Sortie LOX2
   pinMode(pinP1, OUTPUT);                       // Sortie Panneau 1 Ouvert
   pinMode(pinP2, OUTPUT);                       // Sortie Panneau 2 Ouvert

   //pinMode(DONEPIN, OUTPUT);
   //digitalWrite(DONEPIN, LOW);
 
   //Serial.println(F("Broches d'arrêt activées..."));
   digitalWrite(pinLOX1, LOW);
   digitalWrite(pinLOX2, LOW);
   setID();
     
   // Init DHT22
   dht.begin(); 
   
   //Bandes LED Init
   pixels.begin(); // INITIALISER l'objet bande NeoPixel (OBLIGATOIRE)
   pixels.clear(); // Définir toutes les couleurs de pixel à 'off'.
   
   valarme = 0; 
   delay(100);
}   
 
//**************************************************
//             LOOP                                *
//**************************************************
void loop() {

      // Position des Panneaux
      ReadPanels();  
      delay(500); 
      //if ((P1==0)&&(P2==0)) done(); // Si les 2 panneaux sont fermés
                  
      // Lecture Temperature & Humidité
      ReadDHT();                 
      delay(500);   

       // Lecture Tension batterie 
      ReadVcc();                
      delay(500);
          
      Serial.println() ;
      Serial.print("Sombre ? ");    Serial.print(isDark);      Serial.println();
      Serial.print("Pluie ? ");     Serial.print(isRaining);   Serial.println();
         
      //CheckAlarm();

      /*        
      if (valarme==0) {
  		   done();
      } 
      */  
      delay(1000);
}



//**********************************************
// toggle DONE so TPL5110 knows to cut power!
//********************************************** 
void done()

{
 delay(500);
 while (1) {
      digitalWrite(DONEPIN, HIGH);
      delay(1);
      digitalWrite(DONEPIN, LOW);
      delay(1);
 }  
}

//*********************************************
/** Mesure la référence interne à 1.1 volts */
//*********************************************
unsigned int analogReadReference(void) {
  
  /* Elimine toutes charges résiduelles */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#endif
  delayMicroseconds(5);
  
  /* Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#endif
  delayMicroseconds(200);

  /* Active le convertisseur analogique -> numérique */
  ADCSRA |= (1 << ADEN);
  
  /* Lance une conversion analogique -> numérique */
  ADCSRA |= (1 << ADSC);
  
  /* Attend la fin de la conversion */
  while(ADCSRA & (1 << ADSC));
  
  /* Récupère le résultat de la conversion */
  return ADCL | (ADCH << 8);
}