#include <Arduino.h>
#include <U8g2lib.h>
#include <DHT.h>
#include <OneWire.h>
#include <DallasTemperature.h>

//****************************************************************************************//
//           Constante de temps et broches de connexion des capteurs                      //
//****************************************************************************************//

const int pause_affichage_ms = 100;      // temps de pause d'affichage en milliseconde

#define TDS_Sensor_Pin_Num Ax           // TDS sensor on Analog pin Ax
#define Turbidity_Sensor_Pin_Num Ax     // Turbidity sensor on Analog pin Ax
#define pH_Sensor_Pin_Num Ax            // pH sensor on Analog pin Ax
#define DS18S20_Pin_Num_v2 Dx           // DS18B20 sensor on digital pin Dx                      <======= Zone d'affectation des capteurs et actionneurs
#define DHT_Sensor_Pin_Num Dx           // DHT on Digital pin Dx

//****************************************************************************************//

//Données et configuration pour le capteur DHT
#define ref_DHT DHT22                     // référence du DHT (DHT11, DHT22...)
char Hum_DHT[8], Temp_DHT[8];
DHT dht(DHT_Sensor_Pin_Num, ref_DHT);

// Données pour le capteur pH meter (v2) ==> site DFRobot
const int numMeasure = 10;
char pH_2[8];
float offset_pH2 = 0;    // valeur standard = -1.8 avec la carte pH alimentée en 3.3V et -2.5 avec carte alimentée en 5V

// Donnée TDS meter (v1)
char TDS_1[8];
float temperature = 25;

// Données pour le capteur de turbidité
char Turbi_volt[8], NTU_strg[8];
float Turbi_val = 0;

// Configuration pour le capteur de température DS18B20 (v2)
OneWire ds(DS18S20_Pin_Num_v2);  //on digital pin 2
char Temp_DS_2[8];


// Configuration de l'afficheur SSD1315
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(/* rotation=*/ U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);    //Low spped I2C
/*
  U8g2lib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.   
*/

void get_DHT()
{
  float h = 0.0;
  float t = 0.0;

  h = dht.readHumidity();
  dtostrf(h, 5, 1, Hum_DHT);      // conversion digital to string 
  t = dht.readTemperature();
  dtostrf(t, 5, 1, Temp_DHT);

  Serial.print("DHT ==>    Humidité : ");
  Serial.print(Hum_DHT);
  Serial.print("    Température (°C) : ");
  Serial.println(Temp_DHT);

}

void get_pH_2()
{
  int buf[10],temp;
  
  for(int i=0;i<numMeasure;i++)       //Get 10 sample value from the sensor for smooth the value
  { 
    buf[i]=analogRead(xxxxx);
    delay(10);
  }
  
  for(int i=0;i<numMeasure-1;i++)        //sort the analog from small to large
  {
    for(int j=i+1;j<numMeasure;j++)
    {
      if(buf[i]>buf[j])
      {
        temp=buf[i];
        buf[i]=buf[j];
        buf[j]=temp;
      }
    }
  }

  unsigned long int sumValue = 0;  //Store the average value of the sensor feedback
  
  for(int i=2;i<numMeasure-2;i++)                      //take the average value of 6 center sample
    sumValue+=buf[i];
  
  float phValue=(float)sumValue*5.0/4096/(numMeasure-4);    //convert the analog into millivolt
//  phValue=3.5*phValue + offset_pH2;                       //convert the millivolt into pH value avec carte pH alimentée en 5v
  phValue=5.3*phValue + offset_pH2;                         //convert the millivolt into pH value avec carte pH alimentée en 3.3v
  
  dtostrf(phValue, 5, 1, pH_2);
 
  Serial.print("pH_2 value: ");  
  Serial.println(phValue,2);

}

void get_TDS_1()
{
  int TDS_ADC = 0;
  float TDS_volt = 0;
  float compensationCoefficient = 1.0+0.02*(temperature-25.0);    //temperature compensation formula: fFinalResult(25^C) = fFinalResult(current)/(1.0+0.02*(fTP-25.0));
  float compensationVolatge = 0;  //temperature compensation
  float TDS_val = 0;

  TDS_ADC = analogRead(yyyyy);

  TDS_volt = TDS_ADC/4096.0*5.0;
  compensationVolatge = TDS_volt/compensationCoefficient;
  TDS_val=(133.42*compensationVolatge*compensationVolatge*compensationVolatge - 255.86*compensationVolatge*compensationVolatge + 857.39*compensationVolatge)*0.5; //convert voltage value to tds value

  dtostrf(TDS_val, 5, 1, TDS_1);  

  Serial.print("TDS_1 valADC (0 à 4095) : ");
  Serial.print(TDS_ADC);
  Serial.print("    voltage (V) : ");
  Serial.print(TDS_volt);
  Serial.print("    ppm : ");
  Serial.println(TDS_val);

}

void get_Turbidity()
{
  int sensorValue = 0;
  float voltage = 0, NTU = 0;

  sensorValue = analogRead(zzzzz);   // read the input on analog pin
  
  voltage = sensorValue * (5.0 / 4096);             // Convert the analog reading (which goes from 0 - 4095) to a voltage (0 - 5V)

  dtostrf(voltage, 5, 1, Turbi_volt);

  NTU = -1120.4*voltage*voltage + 5742.3*voltage - 4352.9;   //

  dtostrf(NTU, 5, 0, NTU_strg);

  Serial.print("Turbidity (volt) : "); // print out the value you read:
  Serial.print(voltage); // print out the value you read:
  Serial.print("    Turbidity (NTU) : "); // print out the value you read:
  Serial.println(NTU); // print out the value you read: 

  Turbi_val = voltage; 
}

void get_TempDS_2()
{
  //returns the temperature from one DS18S20 in DEG Celsius
  
  byte data[12];
  byte addr[8];

  if (!ds.search(addr))
  {
    //no more sensors on chain,reset search
    Serial.println("No more addresses.");
    Serial.println();
    ds.reset_search();
  }
  
  Serial.print("ROM =");
  for(int i = 0; i < 8; i++) 
  {
    Serial.write(' ');
    Serial.print(addr[i], HEX);
  }
  Serial.println();

  if (OneWire::crc8(addr,7)!=addr[7])
  {
    Serial.println("CRC is not valid!");
  }
  
  // the first ROM byte indicates which chip
  byte type_s;
  switch (addr[0]) 
  {
    case 0x10:
      Serial.println("  Chip = DS18S20");  // or old DS1820
      type_s = 1;
      break;
    case 0x28:
      Serial.println("  Chip = DS18B20");
      type_s = 0;
      break;
    case 0x22:
      Serial.println("  Chip = DS1822");
      type_s = 0;
      break;
    default:
      Serial.println("Device is not a DS18x20 family device.");
      break;
  } 

  if (addr[0] != 0x10 && addr[0] != 0x28)
  {
    Serial.print("Device is not recognized");
  }

  ds.reset();
  ds.select(addr);
  ds.write(0x44,1);   //start conversion, with parasite power on at the end
  
  byte present = ds.reset();
  ds.select(addr);
  ds.write(0xBE);     //ReadScratchpad
  
  for(int i=0; i<9; i++) //weneed9bytes
  {
    data[i]=ds.read();
  }
  ds.reset_search();

  byte MSB=data[1];
  byte LSB=data[0];

  float tempRead=((MSB<<8)|LSB);    //using two's compliment
  float TemperatureSum = tempRead/16;
  
//  return TemperatureSum;

  dtostrf(TemperatureSum, 5, 1, Temp_DS_2);
  Serial.print("Temperature DS (en °C) : ");
  Serial.println(TemperatureSum);

}



void setup()
{
  // put your setup code here, to run once:
  
  Serial.begin(115200);
  
  Serial.println("**********************************************");
  Serial.println("Setup Serial monitor OK");

  u8g2.begin();
  Serial.println("Setup écran OLED OK");

  dht.begin();

  pinMode(pH_Sensor_Pin_Num,INPUT);             // Set pH sensor pin to input mode
  pinMode(Turbidity_Sensor_Pin_Num, INPUT);     // Set the turbidity sensor pin to input mode

  Serial.println("End of setup");
  Serial.println("**********************************************");
}

void loop()
{
  // put your main code here, to run repeatedly:   
 
  get_DHT();
  get_pH_2();

  // affichage des données

  u8g2.setFont(u8g2_font_ncenB08_tr);   // choose a suitable font

//****************************************************************************************//
// écran OLED SSD1315 :
// fonction U8g2.drawStr(n°colonne,n°ligne,string)

  u8g2.clearBuffer();                     // clear the internal memory
  u8g2.drawStr(0,10,"Station eau");       // write something to the internal memory  
  u8g2.drawStr(0,25,"Humidity DHT :");    // affichage du texte "Humidity DHT:"
  u8g2.drawStr(92,25,Hum_DHT);            // affichage de la valeur de l'humidité
  u8g2.drawStr(0,30,"Temp DHT :");        // affichage du texte "Temp DHT :"
  u8g2.drawStr(68,30,Temp_DHT);           // affichage de la valeur de température fournie par le capteur DHT            <== zone à modifier (remplacer xx par des valeurs)
  u8g2.drawStr(0,35,"pH :");              // affichage du texte "pH :"
  u8g2.drawStr(20,35,pH_2);               // affichage de la valeur du pH
  u8g2.sendBuffer();                      // transfer internal memory to the display

  delay(pause_affichage_ms);

//****************************************************************************************//
  
  get_TDS_1();
  get_Turbidity();
  get_TempDS_2();

//****************************************************************************************//

  u8g2.clearBuffer();                       // clear the internal memory
  u8g2.drawStr(0,25,"TDS :");               // affichage du texte "TDS :" 
  u8g2.drawStr(35,25,TDS_1);                // affichage de la valeur de conductivité TDS
  u8g2.drawStr(0,37,"Turbidity (V) :");     // affichage du texte "Turbidity (V) :"
  u8g2.drawStr(80,37,Turbi_volt);           // affichage de la valeur de turbidité en volt                 <== zone à modifier
  u8g2.drawStr(0,49,"Temp DS :");           // affichage du texte "Temp_DS :" à la position
  u8g2.drawStr(57,49,Temp_DS_2);            // affichage de la valeur de température du DS18B20
  u8g2.sendBuffer();

//****************************************************************************************//


//****************************************************************************************//
//                              Code pour gérer une LED                                   //
//****************************************************************************************//

// Affciher un message d'alerte selon la valeur de la turbidité 

/*
  float seuil = x;                    // valeur du seuil

  if (Turbi_val > seuil)              // comparaison par rapport au seuil
  {
    u8g2.drawStr(0,62,"Eau limpide !");
    u8g2.sendBuffer();
  }
  else
  {
    u8g2.drawStr(0,62,"Eau trouble !");
    u8g2.sendBuffer();
  }
*/


  delay(pause_affichage_ms);


  Serial.println();

}