/************************************************
 *  Auteur : D. Rouan  26/03/2021
 *   Gestion par une carte ESP32 Lilygo TTGO t-display 
 *   de différents types de capteurs connectables à la carte
 *   pour mise en forme et envoi en bluetooth BLE 
 *   en particulier vers l'application FIZZIQ  
 *   (https://www.fizziq.org/arduino)
 *   Les capteurs envisagés et ayant été testés sont :
 *   - sonde de température de type CTN
 *   - hygromètre type DHT 11
 *   - balance basée sur ampli différentiel HX711
 *   - capteur de distance infrarouge type Sharp 2Y0A21
 *   - autres capteurs fournissant une tension entre 0 et 2.7 V (domaine de l'ADC du ESP32)
 *   - ... 
 *   Le type de capteur est reconnu en lisant une tension sur  l'ADC ID_CAPT
 *   (point milieu d'un pont de résistances r1+r2 = 100 k sur entrée pin ID_CAPT)
 *   Le capteur fournit soit une information analogique sur pin ADC_PIN soit numérique
 *   via les pins CAPTN1 et CAPTN2
 *   Suivant le capteur, un traitement est effectué avant d'envoyer une chaîne de
 *   caractères capteur:valeur,  comme "temperature:18.2", par BLE
 ***********************************************/
#include <TFT_eSPI.h>
#include <SPI.h>
#include <Wire.h>
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLE2902.h>
#include <ESP32AnalogRead.h>
#include "HX711.h"
#include <dht11.h>

ESP32AnalogRead adcID;
ESP32AnalogRead adcSIG;
ESP32AnalogRead adcREF;
TFT_eSPI tft = TFT_eSPI(135, 240);
HX711 scale;
dht11 DHT11;

BLEServer* pServer = NULL;
BLECharacteristic* pCharacteristic = NULL;
bool deviceConnected = false;
bool oldDeviceConnected = false;
String captname = "inconnu" ;
static char outstr[15];
int th ; // hauteur écran TFT
int tw ; // largeur écran TFT
float id ; 
#define SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
#define CHARACTERISTIC_UUID_RX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E" // Noter que le ESP32 est peer 
#define CHARACTERISTIC_UUID_TX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define ADC_PIN 32
#define REF 33
#define ID_CAPT 36
#define COE 3800
#define CAPTN1 25 // input numérique  (data par ex ou niveau logique) 
#define CAPTN2 26 // output numérique  (vlock par ex)
#define DHT11PIN 5
#define calibration_factor -24000.0 //Calibration balance
#define cc1 1 // à ajuster pour loi linéaire en tension
#define cc2 0
#define cd1 150 // coefficient loi de distance à ajuster
#define cd2 0
#define DELAY 5000 

class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};

class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string rxValue = pCharacteristic->getValue();

      if (rxValue.length() > 0) {
        Serial.println("*********");
        Serial.print("Received Value: ");
        for (int i = 0; i < rxValue.length(); i++)
          Serial.print(rxValue[i]);

        Serial.println();
        Serial.println("*********");
      }
    }
};

unsigned long lastTime = 0;
unsigned long timerDelay = 10000;
int capt = 0 ; // index capteur

// Accueil
void EcranAccueil(int capt) {
  tft.fillScreen(TFT_WHITE);
  tft.setTextSize(3);
  tft.setTextColor(TFT_RED);
  int tw = tft.width() / 2 ;
  int th = tft.height() / 2 ;
  tft.drawString("KAPTOR",tw, th-25);
  tft.drawString("ID:"+String(id),tw, th+5);
  //tft.drawString(String(id),tw+50, th+5);

  tft.drawString(captname,tw, th+35);
  delay(3000) ;
  tft.setTextColor(TFT_GREEN,TFT_BLACK);
}


float getVoltage() { // lecture analogique 
        //int v = analogRead(ADC_PIN);
        float v = adcSIG.readVoltage() ;
        //int v0 = analogRead(REF);
        float v0 = adcREF.readVoltage() ;
        //Serial.println(v);
        //Serial.println(v0);
        float voltage = ((float)v / (float)v0 *10)  ; // référencer à tension "3.3V" 0-10
        return voltage ;
}

int ID_capteur() {
  id = adcID.readVoltage() ;  
  Serial.println(id);
   if (abs(id - 2.95) < .15) {
    Serial.write(" Temperature");
    capt = 1 ; 
    captname = "Temperature" ;
  }
  else if (abs(id - 2.6) < .15)  {
    Serial.write("Poids"); 
    capt = 2 ; 
    captname = "Poids" ;
  }

  else if (abs(id - 2.0) < .15)  {
    Serial.write(" concentration");
    capt = 3 ; 
    captname ="concentration>";
   }
   
  else if (abs(id - 1.7) < 1.15)  {
    Serial.write(" Distance");
    capt = 4 ;  
    captname ="Distance" ;
  }
  else if (abs(id - 1.4) < .15)  {
    Serial.write(" Hygrometre"); 
    capt = 5 ; 
    captname ="Hygrometre" ;
  }  
  else {
    Serial.write(" Capteur inconnu"); 
    capt = 0 ;
    captname ="inconnu" ;
  }
  Serial.println();
  return capt; 
}

void setup() {  
  
  // ports série de debug 
  Serial.begin(115200);
  // initialise l'écran
  tft.init();
  delay(20);
  tft.setRotation(1);
  tft.fillScreen(TFT_BLACK);
  tft.setTextDatum(MC_DATUM); // imprime la string middle centre
  tft.setTextSize(2);
  tft.setTextColor(TFT_BLUE);
  // GPIO
  pinMode(ADC_PIN, INPUT) ;
  pinMode(REF, INPUT) ;  
  pinMode(ID_CAPT, INPUT) ;
  pinMode(CAPTN2, OUTPUT) ;
  pinMode(CAPTN1, INPUT) ;
  adc1_config_channel_atten(ADC1_CHANNEL_4, ADC_ATTEN_11db);
  adc1_config_channel_atten(ADC1_CHANNEL_5, ADC_ATTEN_11db);
  adcID.attach(ID_CAPT);
  adcSIG.attach(ADC_PIN);
  adcREF.attach(REF);
  /* Test possible des 3 ADC 
  tft.fillScreen(TFT_BLACK);
  Serial.println(adc32.readVoltage());
  Serial.println(adc33.readVoltage());
  Serial.println(adc36.readVoltage());
  tft.drawString(String(adc32.readVoltage()),20, 40);
  tft.drawString(String(adc33.readVoltage()),20, 55);
  tft.drawString(String(adc36.readVoltage()),20, 70); 
  delay(10000) ;
*/
// scale  init
  scale.begin(CAPTN1, CAPTN2);
  scale.set_scale(calibration_factor); //This value is obtained by using the SparkFun_HX711_Calibration sketch


 // Create the BLE Server  
  BLEDevice::init("Arduino Kaptor");

  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  // Create the BLE Service
  BLEService *pService = pServer->createService(SERVICE_UUID);

  // Create a BLE Characteristic
  pCharacteristic = pService->createCharacteristic(
                    CHARACTERISTIC_UUID_TX,
                    BLECharacteristic::PROPERTY_NOTIFY
                  );
                      
  pCharacteristic->addDescriptor(new BLE2902());

  BLECharacteristic * pRxCharacteristic = pService->createCharacteristic(
                       CHARACTERISTIC_UUID_RX,
                      BLECharacteristic::PROPERTY_WRITE
                    );

  pRxCharacteristic->setCallbacks(new MyCallbacks());

  // Start the service
  pService->start();
  // Start advertising
  pServer->getAdvertising()->start();
  Serial.println("Waiting a client connection to notify...");
  
  // écran d'accueil
  capt =  ID_capteur(); // quel capteur 
  EcranAccueil(capt);
}

////////////////////////// LOOP 
void loop() {
  int i;
  String   affich ;
  
  // afficheur TFT 
  tft.fillScreen(TFT_BLACK);
  tft.setTextDatum(MC_DATUM);
  tft.setTextSize(2);
  //
  if(capt == 1){// Temperature   
     float voltage = getVoltage() ;
     float temp = (COE/(log(10/(10.-voltage) -1.)+COE/298.)-273) ;
     affich  = captname + ":" + String(temp);
  }

  if(capt == 2){// poids
     float pds = 0;  
     for(i=0; i<20; i++){
      pds += scale.get_units(); //scale.get_units() returns a float
     }
     Serial.println(String(pds));  
     pds /= -20 ;
     pds += -2.79 ;
     dtostrf(pds,7, 2, outstr);
     affich  = captname + ":" + outstr ;
     Serial.println(affich);  
  }
       
  if(capt == 3){ // CO2
    float voltage = getVoltage() ;
    float co2 = (voltage * cc1 + cc2) ;
    dtostrf(co2,7, 2, outstr);
    affich  = captname + ":" + outstr ;
  }

  if(capt == 4){// Distance   
     float voltage = getVoltage() ;
     float dist = ( cd1 / voltage + cd2) ; ;
     affich  = captname + ":" + String(dist);
  }

  if(capt == 5){// humidité / température        
    int chk = DHT11.read(DHT11PIN);
    switch (chk)
    {
      case DHTLIB_OK: 
      //hc06.println("OK"); 
      break;
      case DHTLIB_ERROR_CHECKSUM: 
      //hc06.println("Checksum error"); 
      break;
      //case DHTLIB_ERROR_TIMEOUT: 
      //hc06.println("Time out error"); 
      break;
      default: 
      //hc06.println("Unknown error"); 
      break;
    }  
    dtostrf((float)DHT11.humidity,7, 2, outstr);
    affich  = captname + ":" + outstr ;
  }
  
  if(capt == 0){// inconnu : tension    
     float voltage = getVoltage() ;
     float dist = ( cc1 * voltage + cc2) ; // ajuster les coefficients 
     affich  = captname + ":" + String(dist);
  }
 
  // affichage écran TFT
  tft.drawString(affich,  tft.width() / 2, tft.height() / 2 );
  // affichage moniteur     
  Serial.println(affich);      
  // envoi BLE 
  if (deviceConnected) {        
       uint8_t arr[20]  ;
       for( i =0; i< affich.length(); i++){
         arr[i] = affich[i] ;
       }
       pCharacteristic->setValue(arr, affich.length());
       pCharacteristic->notify(); 
  }

  // disconnecting
  if (!deviceConnected && oldDeviceConnected) {
        delay(500); // give the bluetooth stack the chance to get things ready
        pServer->startAdvertising(); // restart advertising
        Serial.println("disconnected : start advertising");
        oldDeviceConnected = deviceConnected;
   }
    // connecting
    if (deviceConnected && !oldDeviceConnected) {
    // do stuff here on connecting
        Serial.println("reconnected ");
        oldDeviceConnected = deviceConnected;
    }
    delay(DELAY); // attend XX secondes avant la prochaine mesure
  }