// Learn about the ESP32 WiFi simulation in
// https://docs.wokwi.com/guides/esp32-wifi


#include <LiquidCrystal_I2C.h>
#define NUM_BOARDS 39
#include <WiFi.h>
// Librerie BLE
#include <ArduinoBLE.h>

//Sensore Distanza
#include "Adafruit_VL53L0X.h"

//display
#define RIGHE_LCD 4
#define COLONNE_LCD 20
LiquidCrystal_I2C LCD = LiquidCrystal_I2C(0x27, COLONNE_LCD, RIGHE_LCD);

#define SENSOR1_WIRE Wire

WiFiServer Server (8010);

class pista{
  public:
  double MISURA_CANALE=23.50; //misura canale
double Misura_listello=2.667; //misura singolo listello dal 2 al 39
double Misura_1_listello=2.4;   //misura listello più a destra
double Misura_ult_listello=2.4;    //misura listello più a sinistra
char (*board_d[NUM_BOARDS]);
 byte num_boards=NUM_BOARDS;
char *pista_g[NUM_BOARDS];
};

class rilevatore {
  public:
  double diametro_palla=21.83; //Diametro palla
byte mancino=false;
byte installato_dx=true;
}  ;


byte TRIG_PIN = 17;
byte echoCount = 2;
byte echoPins =  16;
byte trigstart = 15;
double delta_minimo=2; //misura minima 

double measure( byte TRIG_PIN, byte ECHO_PIN) {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  int duration = pulseIn(ECHO_PIN, HIGH);
  Serial.print("durata");
  Serial.println(duration);
  return duration * 0.034 / 2;
}



//Configurazione BLE
BLEService LetturaSensoreService("1101");
BLEUnsignedCharCharacteristic LetturaSensoreChar("2101", BLERead | BLENotify);

//Sensore Laser
Adafruit_VL53L0X lox = Adafruit_VL53L0X();
Adafruit_VL53L0X::VL53L0X_Sense_config_t long_range = Adafruit_VL53L0X::VL53L0X_SENSE_LONG_RANGE;
//valore per il quale si attiva la misura per un secondo
int Trigger = 1900;
//campioni i cui acquisisco la misura
int datiMis[1000];
//misuraCiclica
int MisuraAttuale = 0;
//Valore Minimo
int ValoreMinimo = 10000;
int MisuraBLE = 0;
TwoWire *i2c = &Wire;





  pista mylane;
    rilevatore tarantometro;

void setup() {
  Serial.begin(115200);
  //Server.begin ();

  LCD.init();
  LCD.backlight();
  LCD.setCursor(0, 0);

  LCD.setCursor(0, 1);
  pinMode(TRIG_PIN, OUTPUT);
 pinMode (trigstart, INPUT_PULLUP);
 // wait until serial port opens for native USB devices
  while (! Serial) {
    delay(1);
  }
  
  Serial.println("Adafruit VL53L0X test");
  if (!lox.begin(0x29,false, i2c, long_range)) {
    Serial.println(F("Failed to boot VL53L0X"));
    //while(1);
  }
  // power 
  Serial.println(F("VL53L0X API Simple Ranging example\n\n")); 

  //setup BLE
  if (!BLE.begin()) 
  {
  Serial.println("starting BLE failed!");
  while (1);
  }
  
  BLE.setLocalName("LetturaSensore");
  BLE.setAdvertisedService(LetturaSensoreService);
  LetturaSensoreService.addCharacteristic(LetturaSensoreChar);
  BLE.addService(LetturaSensoreService);

BLE.advertise();
Serial.println("Bluetooth device active, waiting for connections...");



}



String ConvertData (double misura){
  String TempString =String (misura,2);

  return TempString;
}


void LeggiSensoreBLE(){
BLEDevice central = BLE.central();
if (central) 
{
Serial.print("Connected to central: ");
Serial.println(central.address());


while (central.connected()) {

      MisuraBLE=LeggiDistanza();
      Serial.print("BLE Distanza Misurata.. ");
      Serial.println(MisuraBLE);
      Serial.println(" mm ");


      LetturaSensoreChar.writeValue(MisuraBLE);
      delay(2000);

}
}

Serial.print("Disconnected from central: ");
Serial.println(central.address());

}

int LeggiDistanza(){
// put your main code here, to run repeatedly:
  VL53L0X_RangingMeasurementData_t measure;
  ValoreMinimo=10000;

 Serial.print("Reading a measurement... ");
  lox.rangingTest(&measure, false); // pass in 'true' to get debug data printout!


  //verifico che la misura sia valida
 if (measure.RangeStatus != 4) {  // phase failures have incorrect data
    Serial.print("Distance (mm): "); Serial.println(measure.RangeMilliMeter);
    MisuraAttuale = measure.RangeMilliMeter;
    
    //se ho il trigger allora memorizzo le variabili
    if (MisuraAttuale < Trigger) {

        for(int i=0; i<1000; i=i+1){
              MisuraAttuale = measure.RangeMilliMeter;
                int MisuraMedia[100];
                int SommaMedia = 0;
                int RisultatoMedia =0;
                  for (int z=0; z< sizeof(MisuraMedia); z=z+1){
                    MisuraMedia[z]=measure.RangeMilliMeter;
                    SommaMedia=SommaMedia+MisuraMedia[z];
                  }
                  //calcolo la media
                  RisultatoMedia=SommaMedia/sizeof(MisuraMedia);
                  //Assegno il valore della media
                  MisuraAttuale=RisultatoMedia;
                //confronto il valore attuale per trovare il valore minimo
                if(MisuraAttuale < ValoreMinimo){
                  ValoreMinimo = MisuraAttuale;
                }
                //MisuraAttuale = measure.RangeMilliMeter;
        }
        
    }
  
  } else {
    //Serial.println(" out of range ");
  }
 if(ValoreMinimo != 10000){
  Serial.print("DistanzaMinima (mm): "); Serial.println(ValoreMinimo);
  
  //rendo disponibile il dato per il web server
  return ValoreMinimo;
  
 }else{
  Serial.print("Nessun Valore Misurato");
  return 0;
 }
}

void display(byte Riga, byte Colonna, String Messaggio){
  LCD.setCursor (Colonna, Riga);
  LCD.print(Messaggio);
  }


 String convert_to_board (double misura) {
  if (tarantometro.installato_dx==false)
    misura=misura-(tarantometro.diametro_palla/2);
  else
    misura=misura+(tarantometro.diametro_palla/2);
    double lane=((mylane.num_boards-2)*(mylane.Misura_listello)+mylane.Misura_1_listello+mylane.Misura_ult_listello);
  Serial.print("Dimensione Pista Calcolata:");
  Serial.println(lane);
  Serial.print("MIsurazione:");
  Serial.println(misura);
   if ((misura>mylane.MISURA_CANALE)/*&(misura<=(lane+mylane.MISURA_CANALE))*/){
      double misura_temp=(misura -mylane.MISURA_CANALE);
    Serial. print("misura netta:");
    Serial.println(misura_temp);
    double listello_temp=misura_temp/mylane.Misura_listello;
     Serial. print("N. listello:");
    Serial.println(listello_temp);
    byte listello=int(listello_temp);
     Serial. print("approssimato:");
    Serial.println(listello);
      //  char* boards[num_boards];
byte ib=0;
    do 
   { LCD.print (ib);
  Serial.println(ib);
      if (ib==listello){
        //LCD.print("x");
        mylane.board_d[ib]="X";
        Serial.println("X");}
      ib++;
      return (String (listello));

 }
 while (ib<=listello);}
 else {
return ("CANALE!");
 }
   }

   
 

void loop() {
      display(0,0,"BBS Board Detector");
     display (1,0,"Pronto...");
    //disegna_pista (0);
    if (digitalRead(trigstart)==false){
      LCD.clear();
      display(0,0,"Misurazione:");
      //double misura=(measure(TRIG_PIN, echoPins));  //HC-SR04
      double misura=(LeggiDistanza()/1000);           //VL53L0X
      String d_data=(ConvertData(misura));
      //display(1,0,d_data);
      String esci_listello=(convert_to_board (misura));
      display(1,0,esci_listello);
      byte listello_int=esci_listello.toInt();
      disegna_pista (listello_int);
      display (2,10,esci_listello);
     //String test=String(board_d);
      //display(3,0,test);
      }
}

void disegna_pista (byte listello){
   byte v;
     
for (v=1;v<=mylane.num_boards;v++){
        Serial.print("|");
        //Serial.print(v);
       switch (v){
        case 5:
        case 10:
        case 15:
        case 20:
        case 25:
        case 30:
        case 35:
         mylane.pista_g[v]="^";
        if ((listello==v)&&(listello>0)){
                 mylane.pista_g[v]="X";}
         break;
        default:
          mylane.pista_g[v]="";
          if ((listello==v)&&(listello>0)){
                 mylane.pista_g[v]="X";}
            break;
        }
        
           Serial.print(mylane.pista_g[v]); 
}

           }
           
           //return;