//************************Librerías*********************************************
  #include <Wire.h>                  //Esta librería se usará para la comunicación I2C entre el MCU, LOS ADS1115 y los PCF8574
  #include <WebServer.h>            //Librería para iniciar el servidor HTML para introducir los datos del WIFI
  #include <Preferences.h>         //Librería para conectar a la NVRAM en la que se guardarán los datos del WIFI
  #include <WiFi.h>               //Librería para realizar la conexión a una RED WIFI
  #include <WiFiClientSecure.h>	 // Biblioteca para realizar peticiones por WIFI para conectar a la INTERFAZ
  #include <SPI.h>
  #include <MFRC522.h>
  #include <Adafruit_ADS1X15.h>
//******************************************************************************

//***********************Definición de Macros***********************************
  #define cantidad_ADS 7             //Número de ADC conectados
  #define ads_direccion 0x49        //Dirección de los ADS1115
  #define mux_direccion 0x27       //Dirección del multiplexor para los ADS1115
  #define lcd_direccion 0x20      //Dirección de las LCD
  #define puerto 80              //Puerto de comunicación TCP
  #define ganancia 16           //Ganancia del ADC
  //Definición de salidas/entradas
  #define conectado 32   
  #define acceso 25
  #define opto 21
  #define magnet 35
  #define SS_PIN 16
  #define SDA_PIN 16
  #define SCK_PIN 17
  #define MISO_PIN 2
  #define MOSI_PIN 15
  #define RST_PIN 14
//******************************************************************************

//***********************Variables globales a utilizar**************************
  //Declaración de FLAGS  -- var tipo bits
  bool rfid_on = false;              //Este flag está relacionado con la detección del sensor RFID
  bool wifi_on = false;             //Este flag está relacionado con la conexión a una red WIFI.
  bool server_on = false;          //Este flag está relacionado con la conexión a la interfaz.
  bool rfid_correct = false;      //Este flag está relacionado con la validación de la recepción de datos por parte del sensor RFID.
  bool user_correct = false;     //Este flag está relacionado con la valicación del usuario por parte de la interfaz.
  bool new_lcd_data = false;    //Este flag indica cuando se reciben datos nuevos para las LCD.
  short er=0;
  //Declaración de variables globales
  byte lectura_adc_bytes[10];         //En Esta variable se guardarán los datos de los ADC. 
  byte rfid_bytes[4];       //En esta variable se almacenarán los datos leídos desde la RFID-RC522
  char lcdH[16][16];        //Esta cadena de caracteres se guardarán los datos concernientes a la parte superior de las LCD.
  char lcdL[16][16];       //Esta cadena de caracteres se guardarán los datos concernientes a la parte inferior de las LCD.
  char lcdLl[16][16];       //Esta cadena de caracteres se guardarán los datos concernientes a la parte inferior de las LCD.
  char bytep;             //En esta variable se almacenarán los datos a enviar a las LCD.
  String interfaz_ip;    //En esta variable se almacena la IP del servidor.
  short pc=0;
//******************************************************************************

//***********************Instancia de objetos***********************************
  WiFiServer server(80);         //Objeto usado para conectarse a la interfaz por WIFI
  WiFiClient client;            //Objeto usado para realizar la conexión con un dispositivo por WIFI
  WebServer pagina_html(80);      //Objeto usado para manejar solicitudes HTTP.
  Preferences preferences;    //Objeto usado para almacenar y buscar valores desde la NVRAM
  MFRC522 mfrc522(SDA_PIN , RST_PIN); // Create MFRC522 instance
  Adafruit_ADS1115 ads;
//******************************************************************************

//***********************Declaración de funciones*******************************
  bool init_wifi();                          //Función para iniciar la comunicación WIFI
  void init_lcd();                          //Función para inicializar las LCD
  bool init_rfid();                        //Función que comprueba la existencia de un sensor RFID
  byte read_ads();                        //Función que realiza la lectura de los ADS1115
  bool interfaz_com(String ip_interfaz);                   //Función que comprueba la comunicación entre equipo-Interfaz
  void pruebas_COM();                   //Función que realiza pruebas de conexión 
  byte rfid_read();                    //Función para realizar la lectura de las tarjetas RFID
  void puerta_abierta();              //Función que realiza la tarea de leer el sensor de la puerta.
  void recibe_datos();               //Función que realiza la tarea de recibir datos desde la interfaz.
  void interrupcion_rfid();         //Esta función servirá como interrupción para la lectura del sensor RFID
  void counter_lcd(int j, int t);  //Función que realiza un conteo para la programación de las LCD
  void enviar_Datos(String ip_interfaz,byte data[],size_t len);  //Función que realiza la tarea de enviar los datos a la interfaz.
  void update_lcd(char LCDA[16][16], char LCDB[16][16],int h);  //Función que realiza la tarea de actualizar los datos en las LCD.
//******************************************************************************

void setup() {

    //Puertos físicos a utilizar
 /*******************************************************************************************/
  pinMode(conectado, OUTPUT);               //Configuración del PIN 2 como ENTRADA   //conexion
  pinMode(acceso, OUTPUT);              //Configuración del PIN 2 como ENTRADA   //acceso
  pinMode(opto, OUTPUT);             //Configuración del PIN 15 como ENTRADA   //solenoide
  pinMode(magnet, INPUT);             //Configuración del PIN 2 como ENTRADA   //PUERTA
 /*******************************************************************************************/

    //Inicialización de puertos de comunicación
 /*******************************************************************************************/   
  Serial.begin(9600);                     // Se Inicializa el puerto serial del ESP32 a 9600 baudios
  Wire.begin(22,19);                     // Se inicializa la comunicación por I2C     

  SPI.begin(SCK_PIN,MISO_PIN,MOSI_PIN,SDA_PIN); // Init SPI bus

  mfrc522.PCD_Init(); 
 /*******************************************************************************************/   
  digitalWrite(acceso,LOW);
  digitalWrite(conectado,LOW);

  //Inicialización del Hardware del equipo
 /*******************************************************************************************/
  init_wifi();           //Se inicia la comunicación por WIFI.
  init_lcd();           //Se inicializan las LCD.
  init_rfid();         //Se realiza una detección de la tarjeta RFID.
  interfaz_com(interfaz_ip);    //Se inicia la conexión al servidor (INTERFAZ). 
  pruebas_COM();               //Prueba de las conexiones 
  read_ads();                 //Se hace una lectura de los sensores de presión.
 /*******************************************************************************************/
}

void loop() {

      while(1){

              if (digitalRead(magnet)==1){
                          while(magnet==1){
                        digitalWrite(acceso,LOW);   

                          }
              }
              if (server==true){
          digitalWrite(acceso,!(digitalRead(acceso)));
              }
              else{
                          digitalWrite(acceso,LOW);
              }
          er++;
                if (er==5 | server==false){   //Conteo para prueba de conexión con interfaz
                    pruebas_COM();   //Prueba de las conexiones 
                             // read_ads();                 //Se hace una lectura de los sensores de presión.
                    er=0;
                           }
 
                 if (rfid_correct==true){  //En caso de realizada una correcta lectura 
                    rfid_correct = false;
                    enviar_Datos(interfaz_ip,rfid_bytes,sizeof(rfid_bytes));   //Envíar Datos     
                            }
                 //Serial.println("Habilitación de Recepción de datos desde interfaz");  

             recibe_datos();
                  //Serial.println("Deshabilitación de Recepción de datos desde interfaz");  

                  if (user_correct==true){
                        Serial.println("Puerta Abierta");
                        puerta_abierta(); //   
                        //enviar_Datos(interfaz_ip,lectura_adc_bytes,sizeof(lectura_adc_bytes));  // enviar datos           
                            }

                       else if (new_lcd_data==true){
                              Serial.println("Inicio de Escritura en LCD ");  
                               new_lcd_data= false;
                               update_lcd(lcdH,lcdL,0);
                              Serial.println("fiN de Escritura en LCD ");  
                             }
                                  
                           rfid_read();
                           delayMicroseconds(80000);
             }
}

bool init_wifi(){

  short x=0;  //Variable de control
    
  // Inicialización de la comunicación con la NVRAM y búsqueda de datos almacenados
  /*******************************************************************************/
  preferences.begin("wifi", false);
  //preferences.clear();  //Para borrar NVRAM
  String saved_ssid = preferences.getString("ssid", "");   
  String saved_password = preferences.getString("password", "");
  String servidor_ip = preferences.getString("server", "");
  /*******************************************************************************/

  //Se inicializa el WIFI y se procede a conectar en la red almacenada
  /*******************************************************************************/
  WiFi.begin(saved_ssid.c_str(), saved_password.c_str());  
  Serial.println("Conectando a la Red WIFI Guardada en NVRAM"); //Mensaje para pruebas, no es parte del DF

  //Bucle de 15 segundos para la búsqueda de la RED
    while(WiFi.status() != WL_CONNECTED && x<15) { 
          digitalWrite(conectado,HIGH);
          delayMicroseconds(500000);
          Serial.print(".");//Mensaje para pruebas, no es parte del DF
          digitalWrite(conectado,LOW);
          delayMicroseconds(500000);
           x++;
    }
  /*******************************************************************************/

    //Condicionales
  /*******************************************************************************/  
   if (WiFi.status() != WL_CONNECTED){   //En caso de que no se conecte a una red, se inicia el webserver 
          digitalWrite(conectado,LOW);
          WiFi.softAP("RED", "admin1234");     //Inicio del Punto de acceso (credenciales predeterminadas)
          Serial.println("Punto de Acceso -RED- Creado"); //Se imprime el Mensaje (PARA PRUEBAS)
          Serial.println(WiFi.softAPIP());  //Mensaje para pruebas, no es parte del DF
          Serial.println(WiFi.softAPSubnetCIDR());  //Mensaje para pruebas, no es parte del DF

      /*COSAS A RECORDAR CON RELACIÓN AL CÓDIGO DE MÁS ADELANTE
            *pagina_html.on : función de la librería webserver que define una ruta y método HTTP.
            *HTTP_GET  : Es el método que se usa para solicitar información.
            *HTTP_POST : Es el método que se usa para enviar información al servidor.
            *pagina_html.send : Función de la librería webserver que envía mensajes de confirmación. 
      */
     pagina_html.on("/", HTTP_GET, []() {
      String html = "<html>"
      "<head>"
      "<title>Configuraci&oacute;'n WIFI</title>"
      "<style>"
      "body {text-align:center;}"
      "h1 {font-size: 36px;}"
      "</style>"
      "</head>"
      "<body>"
      "<h1>Configuraci&oacute;n de Credenciales</h1>"
      "<form method='post' action='/save'>"
      "<label for='ssid'>SSID:</label>"
      "<input type='text' id='ssid' name='ssid'><br>"
      "<label for='password'>Password:</label>"
      "<input type='password' id='password' name='password'><br>"
      "<label for='Servidor'>Servidor:</label>"
      "<input type='text' id='server' name='server'><br>"
      "<input type='submit' value='Guardar'>"
      "</form>"
      "</body>"
      "</html>";
    pagina_html.send(200, "text/html", html);    
  });

   pagina_html.on("/save", HTTP_POST, []() { 
    //Se guardan los datos recibidos por el servidor HTML en variables transitorias
    String ssid =pagina_html.arg("ssid");  
    String password = pagina_html.arg("password");
    interfaz_ip = pagina_html.arg("server");
    //Se guardan los datos recibidos por el servidor HTML a la NVRAM
    preferences.putString("ssid", ssid);
    preferences.putString("password", password);
    preferences.putString("server", interfaz_ip);

    pagina_html.send(200, "text/plain", "Credenciales Salvadas, Reiniciando...");
    Serial.println(ssid + " " + password + " " + interfaz_ip); //Mensaje para pruebas, no es parte del DF
    delay(1000);
    ESP.restart();  //Se reinicia el microcontrolador
  });
    pagina_html.on("/ping",HTTP_GET, []() { 
    pagina_html.send(200, "text/plain","pong");  //Esto es para pruebas
  });
       pagina_html.begin(); //Se inicia el server
       Serial.println("Server started");     //Mensaje para pruebas, no es parte del DF

        while(1){
          pagina_html.handleClient();  //Este bucle es para recibir las solicitudes propias del servidor HTML   
        }
  }
    //preferences.end();  //Se finaliza la comunicación con la NVRAM, esto no es necesario

   if (WiFi.status() == WL_CONNECTED){  //En caso de que se realice la conexión con una red WIFI
        digitalWrite(conectado,HIGH);
       interfaz_ip=servidor_ip;     //Se guardan los datos recibidos con relación a la IP de la INterfaz
       wifi_on =true;
       Serial.print("IP DEL EQUIPO: ");       //Mensaje para pruebas, no es parte del DF
       Serial.println(WiFi.localIP());   //Mensaje para pruebas, no es parte del DF
       Serial.print("IP DE INTERFAZ: ");       //Mensaje para pruebas, no es parte del DF
       Serial.println(interfaz_ip);   //Mensaje para pruebas, no es parte del DF
       server.begin();  //Esto inicia el protocolo de comunicación con la Interfaz
       return wifi_on;
  }   
}

void init_lcd(){

            bytep=0;  //cambiar por D en diagrama de flujo
            Wire.beginTransmission(lcd_direccion);
            Wire.write(bytep);
            Wire.endTransmission();

               //Secuencia para el seteo de las LCD
              //Corrimiento de bits para asignación de valores
        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 1<<1 | 1 <<0 );  
            counter_lcd(10,1);

        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 1<<1 | 0 <<0 );
             counter_lcd(20,1);

        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 1 <<3 | 0 <<2 | 0<<1 | 0 <<0 );
              counter_lcd(10,1);

        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 0 <<0 );
            counter_lcd(10,1);

        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 1 <<3 | 1 <<2 | 0<<1 | 0 <<0 );
            counter_lcd(10,1);

        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 0 <<0 );
            counter_lcd(10,1);

        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 1 <<0 );
            counter_lcd(10,1);

        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 1 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 0 <<0 );
            Wire.beginTransmission(lcd_direccion);
            Wire.write(bytep);
            Wire.endTransmission();

            memset(lcdH,'.', sizeof(lcdH));
            memset(lcdL,'.', sizeof(lcdH));
            update_lcd(lcdH,lcdL,0);
  delay(1000);

  char mensaje1[16] = "  En Espera... ";
  char mensaje2[16] = "---------------";

  for (int i = 0; i < 10; i++) {
    lcdH[i][0] = '\0'; // Limpiar la columna antes de copiar el mensaje
    strncpy(lcdH[i], mensaje1, strlen(mensaje1));
  }

  for (int i = 0; i < 10; i++) {
    lcdL[i][0] = '\0'; // Limpiar la columna antes de copiar el mensaje
    strncpy(lcdL[i], mensaje2, strlen(mensaje2));
  }
    lcdL[0][0]='1';
    lcdL[1][0]='2';
    lcdL[2][0]='3';
    lcdL[3][0]='4';
    lcdL[4][0]='5';
    lcdL[5][0]='6';
    lcdL[6][0]='7';
    lcdL[7][0]='8';
    lcdL[8][0]='9';
    lcdL[9][0]='0';

    lcdH[0][0]='1';
    lcdH[1][0]='2';
    lcdH[2][0]='3';
    lcdH[3][0]='4';
    lcdH[4][0]='5';
    lcdH[5][0]='6';
    lcdH[6][0]='7';
    lcdH[7][0]='8';
    lcdH[8][0]='9';
    lcdH[9][0]='0';
    update_lcd(lcdH,lcdL,0);    

}

bool init_rfid(){

   // Comando de prueba para el módulo RFID-RC522
       byte command[] = {0x02, 0x00, 0x01, 0xFE, 0x03, 0xFD};

  Serial2.write(command, sizeof(command)); // Envía el comando al módulo RFID-RC522
  //delay(1000); // Espera un segundo para recibir la respuesta

  // Verifica si hay datos disponibles en el puerto serial 2
  if (Serial2.available() > 0) {
    byte respuesta[10];
    Serial2.readBytes(respuesta, 10); // Lee los datos disponibles
    if (respuesta[0] == 0x03 && respuesta[1] == 0x00 && respuesta[2] == 0x01 && respuesta[3] == 0xFE) {
      rfid_on = true;
    }
    else{
            rfid_on = false;
    } 
  }
  else {
      rfid_on = false;  
  } 
        return rfid_on;
}

byte read_ads(){

  int16_t lectura_adc[cantidad_ADS *2];   //En Esta variable se guardarán los datos de los ADC. 
  int16_t lectura_adc2[cantidad_ADS *2];
  byte lectura_adc_bytes2[2];           //En Esta variable se guardarán los datos de los ADC. 
  byte ma[2];
  int mux,i = 0;
  char f;
  ma[0]= 0x24;
  mux=0;
  byte byte_buffer[13];

  //Serial.println("INICIO LECTURA ADC");

    for (mux = 0; mux < 6; mux++){
    
              if (mux==0){
         f= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 0 <<0 );  
        }
        if (mux==1){
         f= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 0 <<1 );  
        }
        if (mux==2){
         f= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0<<2 | 1<<1 | 0 <<0 );  
        }
        if (mux==3){
         f= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0<<2 | 1<<1 | 1 <<0 );  
        }
        if (mux==4){
         f= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 1 <<2 | 0<<1 | 0 <<0 );  
        }
        if (mux==5){
         f= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 1 <<2 | 0<<1 | 1 <<0 );  
        }

    //Se selecciona el canal del multiplexor
  /*************************************************************************/
      
      Wire.beginTransmission(mux_direccion);
      Wire.write(f);   
      Wire.endTransmission();
  /*************************************************************************/
      delayMicroseconds(20000);
      //Configuración del modo a usar (diferencial y ganancia x16)

 ads.setGain(GAIN_SIXTEEN);    // Se setea la ganancia en 16 
  ads.begin(0x49); 
      delayMicroseconds(10000);



      //Se separan los bytes

        
     lectura_adc[i*2] = ads.readADC_Differential_0_1();  // Almacenar el byte más significativo
            delayMicroseconds(10000);
      lectura_adc[(i*2)+1] = ads.readADC_Differential_2_3();  // Almacenar el byte menos significativo
      if (lectura_adc[i*2]<0){
            lectura_adc[i*2] = lectura_adc[i*2] * -1;
                  }

                    if (lectura_adc[(i*2)+1]<0){
            lectura_adc[(i*2)+1] = lectura_adc[(i*2)+1] * -1;
                  }
      i++;
      
    }

      f= (0 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 1<<3 | 1 <<2 | 1<<1 | 1 <<0 );  

        Wire.beginTransmission(mux_direccion);
        Wire.write(f);   
        Wire.endTransmission();
        //delayMicroseconds(250000);
 
    
     
      //Se copia para "organizar" los datos
          
         lectura_adc2[0]=  lectura_adc[0];
         lectura_adc2[1]=  lectura_adc[1];
         lectura_adc2[2]=  lectura_adc[2];
         lectura_adc2[3]=  lectura_adc[4];
         lectura_adc2[4]=  lectura_adc[5];
         
         lectura_adc2[5]=  lectura_adc[6];
         lectura_adc2[6]=  lectura_adc[7];
         lectura_adc2[7]=  lectura_adc[8];
         lectura_adc2[8]=  lectura_adc[10];
         lectura_adc2[9]=  lectura_adc[11];

 /* for (int i = 0; i < 12; i++) {  //Se imprime
          Serial.print(lectura_adc[i]);  //Mensaje para pruebas, no es parte del DF
          Serial.print(" ");
     }*/
               Serial.println(" ");


  for (int i = 0; i < 10; i++) {  //Se imprime
          Serial.print(lectura_adc2[i]);  //Mensaje para pruebas, no es parte del DF
          Serial.print(" ");
     }
                    Serial.println(" ");

        memcpy(lcdL, lcdLl, sizeof(lcdL));
         if (pc>5){
       for (int i = 0; i < 10; i++) {
           char buffer[8];
           char buffer2[13];
           itoa(lectura_adc2[i], buffer, 10);
    
             
           //   buffer2[0]= ma[0];
               buffer2[0]= i+48;
              ma[1]= buffer2[0];
              buffer2[1]= buffer[0];
              buffer2[2]= buffer[1];
              buffer2[3]= buffer[2];
              buffer2[4]= buffer[3];
              buffer2[5]= buffer[4];
              buffer2[6]= buffer[5];
              buffer2[7]= buffer[6];
              buffer2[8]= buffer[7];
              buffer2[9]= 0;
              buffer2[10]= 0;
              buffer2[11]= 0;
            
              //lcdL[i][8]= i+48;
                            lcdL[i][14]= ' ';
              lcdL[i][15]= ' ';
            if (i==0){
               lcdL[9][10]= buffer[0];
              lcdL[9][11]= buffer[1];
              lcdL[9][12]=  buffer[2];
              lcdL[9][13]=  buffer[3];
                  }
                  else{                      
              lcdL[i-1][10]= buffer[0];
              lcdL[i-1][11]= buffer[1];
              lcdL[i-1][12]=  buffer[2];
              lcdL[i-1][13]=  buffer[3];


               }   
        char* endptr;
        long num = strtol(buffer2, &endptr, 10);
        size_t len = endptr - buffer2;
        memcpy(byte_buffer, buffer2, len);
               
      /*  enviar_Datos(interfaz_ip, ma,sizeof(byte_buffer)); // se agrega la longitud como tercer parámetro
        delayMicroseconds(10000);
        enviar_Datos(interfaz_ip, byte_buffer,sizeof(byte_buffer)); // se agrega la longitud como tercer parámetro
        delayMicroseconds(10000);
       /* enviar_Datos(interfaz_ip, ma,sizeof(byte_buffer)); // se agrega la longitud como tercer parámetro
        delayMicroseconds(20000);
        enviar_Datos(interfaz_ip, byte_buffer,sizeof(byte_buffer)); // se agrega la longitud como tercer parámetro*/
 pc=0;
  } 
 }
    update_lcd(lcdH,lcdL,1);  
        
     //   delayMicroseconds(4000);

    pc++;
 
 
    return *lectura_adc_bytes;
}

byte rfid_read(){
 /*
    byte chequeo=0;
    char rfid[12];
         for (int i=0 ; i<12 ; i++){
            rfid[i]= Serial2.read();
              chequeo+=rfid[i];   //Se van sumando todos los bits
    }
         //En caso de que la suma de los bits sea igual al bit 11, se confirma que la transmisión fue exitosa
         if (chequeo ==rfid[11]){
          rfid_correct = true;

                    memcpy(rfid_bytes,rfid,12); //Se convierten los datos char a byte
          return *rfid_bytes;      
    }
    else{
          rfid_correct = false;
    }     */  

    if (mfrc522.PICC_IsNewCardPresent()) {
        if ( mfrc522.PICC_ReadCardSerial()) {
          char rfidchar[9];
          byte rfid[4];
          byte ma[1];
          ma[0]= 0x23;
              for (byte i = 0; i < 4; i++) {
                 rfid[i] = mfrc522.uid.uidByte[i];
                  Serial.print(rfid[i], HEX);
        }
              sprintf(rfidchar, "%02X%02X%02X%02X",  rfid[0],  rfid[1], rfid[2], rfid[3]); 
              memcpy(rfid_bytes,rfidchar,16); //Se convierten los datos char a byte
              enviar_Datos(interfaz_ip,ma,sizeof(rfid));  // enviar datos
              enviar_Datos(interfaz_ip,rfid,sizeof(rfid));  // enviar datos

 }
                delayMicroseconds(500000);

 }
                return *rfid_bytes;
}

bool interfaz_com(String ip_interfaz){
    
     char ip[ip_interfaz.length() + 1];
     ip_interfaz.toCharArray(ip, ip_interfaz.length() + 1); //Se convierte la IP en un dato tipo char

        if (client.connect(ip, 80,2000)) {   //Se realiza una prueba de comunicación con la INterfaz con 2 segundos de espera
           server_on=true; 
           Serial.println("Prueba interfaz correcta");//Mensaje para pruebas, no es parte del DF

            IPAddress ipp = WiFi.localIP();
            char ipchar[16];
            byte ippp[16];
            strcpy(ipchar,ipp.toString().c_str());
      
            memcpy(ippp,ipchar,13); //Se convierten los datos char a byte        
            enviar_Datos(interfaz_ip,ippp,sizeof(ippp));  // enviar datos

          } 
                 else {
                       server_on=false;
                }
                  client.stop();   //Se cierra la comunicación
                  return server_on;
}

void pruebas_COM(){

     // detachInterrupt(digitalPinToInterrupt(16)); // Se desactiva la interrupción

      //Prueba de Conexión WIFI
  /********************************************************************************/
  if (WiFi.status() != WL_CONNECTED){
  wifi_on=false;
  init_wifi(); //Llamada a Función
    }
  /********************************************************************************/

      //Prueba de Conexión a la Interfaz
  /********************************************************************************/
    interfaz_com(interfaz_ip);
  /********************************************************************************/

    //Prueba del sensor  RFID
  /********************************************************************************/
    init_rfid();  //Llamada a Función

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

 /********************************************************************************/
  /*    if(rfid_on == true && server_on){
        //*** AQUÍ SE AGREGA LA INTERRUPCIÓN PARA LA LECTURA SERIAL
          // attachInterrupt(digitalPinToInterrupt(16),interrupcion_rfid, FALLING);
      }
      if (rfid_on == false){
       //  digitalWrite(acceso,~(acceso));
         //detachInterrupt(digitalPinToInterrupt(16)); // Se desactiva la interrupción
      }
      else{
        digitalWrite(acceso,LOW);
        rfid_on=true;
      }
      if (server_on == false){
        // digitalWrite(conectado,~(conectado));
         //detachInterrupt(digitalPinToInterrupt(16)); // Se desactiva la interrupción
      }
      else {
        digitalWrite(conectado,HIGH);
      //  server_on = true;
      }
  /********************************************************************************/

}

void puerta_abierta(){


  //detachInterrupt(digitalPinToInterrupt(16)); // Se desactiva la interrupción
      digitalWrite(opto,HIGH);   //Se abre la puerta
      digitalWrite(acceso,HIGH);
          
          while (digitalRead(magnet)!=1){  //Mientras la puerta esté abierta...
            read_ads();
            delayMicroseconds(20000);
            pc++;
           }
           user_correct = false;

        digitalWrite(opto,LOW);   
        digitalWrite(acceso,LOW);
        Serial.println("Puerta Cerrada");   // com_server();   //Envíar y recibir datos
}

void interrupcion_rfid(){
  rfid_read();
}

void recibe_datos() {

  // detachInterrupt(digitalPinToInterrupt(16)); // Se desactiva la interrupción
   client.flush();  //Se limpia el bus
   bool re = false;
   char receipt_lcd[16];
   char fila[17];
   char p = '.';                                 
   int g,h =0;
   int n =3;

        if (!client.connected()) {    //Primero se verifica si la interfaz está conectada
                 client.flush();  //Se limpia el bus
                 client = server.available(); //Se habilita el bus de recepción WIFI

                    if (client) {
                                          
                         Serial.println("Cliente conectado");//Mensaje para pruebas, no es parte del DF
                              while (client.connected()) {  
                                    if (client.available()) { //Se verifica si hay datos por extraer
                                       char id[2];  
                                        re = true;
                                        client.readBytes(id, 2);
                           
                                             if (strchr(id,'&')){ //En caso de recibir un "&", se considera un SI para el acceso
                                                 user_correct= true;
                                                 Serial.print("User correct.");//Mensaje para pruebas, no es parte del DF
                                                 client.stop();
                                                 return;
                              }


                                      int fila_id = atoi(id);  //Sino recibe el "&", se procede con la lectura de todos los datos que se reciban        
                                      Serial.print("ID: ");
                                      Serial.println(fila_id);
                                      client.readBytes(fila, 16);
                                      fila[16] = '\0';
                                      strcpy(receipt_lcd, fila);
                                      Serial.print("DATO BRUTO: ");  
                                      Serial.print(receipt_lcd);                                   
                                      Serial.print(" -------   DATO Extraido: ");  
                                        n=3;  //NUEVO
                                        g=0;  //NUEVO
                                        h=0;

                                       for (int j = 0 ; j<15 ; j++){
                                            
                                          if (receipt_lcd[j]!= p && h==0){
                                              lcdH[fila_id-1][g] = receipt_lcd[j];
                                              Serial.print(lcdH[fila_id][g]);

                                               g++;
                               }
                                            else if (receipt_lcd[j]!= p){
                                              lcdL[fila_id-1][0]= 'R';
                                              lcdL[fila_id-1][1]= 'D';
                                              lcdL[fila_id-1][2]= '$';
                                              lcdL[fila_id-1][n] = receipt_lcd[j];                 
                                              Serial.print(lcdL[fila_id][n]);                                              
                                               n++;           
                                 }
                                          else{
                                                h++;
                                                Serial.print(" ");  
                                               }
                 
                                 }
                          
                              Serial.println(" ");
                                      memcpy(lcdLl, lcdL, sizeof(lcdL));
                                      if (fila_id == 10){
                                            client.stop();   
                                            new_lcd_data= true;
                   }
                   }        
                   }  
                   }  
                         client.flush();      
                   }     
                         delayMicroseconds(500000);
                         client.stop();
}

void enviar_Datos(String ip_interfaz, byte data[],size_t len) {

 // detachInterrupt(digitalPinToInterrupt(16)); // Se desactiva la interrupción
  char ip[ip_interfaz.length() + 1];               
  ip_interfaz.toCharArray(ip, ip_interfaz.length() + 1);//Se convierte la IP en un dato tipo char

        if (client.connect(ip, 80, 1000)) { //Se realiza una prueba de conexión con la interfaz durante 1 seg.
             Serial.println("Conectado a la interfaz"); //Mensaje para pruebas, no es parte del DF
             client.write(data, 14);
             Serial.println("Envío a la interfaz");//Mensaje para pruebas, no es parte del DF
             Serial.print(len);//Mensaje para pruebas, no es parte del DF
             client.stop();
  } 
          else {
              Serial.println("Conexión fallida a la interfaz");//Mensaje para pruebas, no es parte del DF
             }
 // attachInterrupt(digitalPinToInterrupt(16), interrupcion_rfid, FALLING); //Se activa la interrupción.
}

void update_lcd(char LCDA[16][16], char LCDB[16][16],int h) {

   char lcd_print[16][16];
   //int h = 0;
          

            //Se limpian las pantallas
       /* bytep= (1 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 0 <<0 );  
            counter_lcd(10,1);
          bytep= (1 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 1<<0 );  
            counter_lcd(10,1);
 */
  for (h; h < 2; h++){   //Bucle para las filas de las pantallas

         if (h == 1){
                          //Se envía un comando para ir a la primera fila
               memcpy(lcd_print, lcdL, sizeof(lcdL));
                 bytep= (1 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 1  <<3 | 1 <<2 | 0<<1 | 0 <<0 );  
                 counter_lcd(10,1);
                bytep= (1 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 0 <<0 );  
                counter_lcd(10,1);
                Serial.println(" Escritura de Segunda fila ");  

          }
           else if (h == 0){
                         
                         memcpy(lcd_print, lcdH, sizeof(lcdH));
                         
 Serial.println(" Escritura de Primera fila ");  
                         bytep= (1 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 0<<1 | 0 <<0 );  
                         counter_lcd(10,1);
                         bytep= (1 << 7 | 0 << 6 | 0 << 5 | 0 << 4 | 0 <<3 | 0 <<2 | 1<<1 | 0<<0 );  
                         counter_lcd(10,1); 
          }
       //   if (h!=2){

       
            for (int l= 0; l < 16; l++) {              //Bucle para recorrer las 16 casillas de las LCD
               for (int g = 0; g < 2; g++) {          //Bucle para enviar los dos nibbles
                    for (int k = 0; k < 10; k++) {   //Bucle para recorrer las 10 LCD
               
                        int binario= lcd_print[k][l];
                        int j=0;
                        byte binarioM[8] ={0x48,0x48,0x48,0x48,0x48,0x48,0x48,0x48};
                  
                            while(binario>0){
                                binarioM[j]= binario % 2;
                                binario = binario/2;
                                j++;                            
                             }

                             for (int w= 0; w <= 7; w++) {
                                 if (binarioM[w] > 1){
                                     binarioM[w]=0;
                                                }                                         
                          }
                  if (g==0){
                        bytep= (0 << 7 | 0 << 6 | 0 << 5 | 1 << 4 | binarioM[7] <<3 |binarioM[6] <<2 | binarioM[5]<<1 | binarioM[4] <<0 );  
                            }
                   if (g==1){
                        bytep= (0 << 7 | 0 << 6 | 0 << 5 |1 << 4 | binarioM[3] <<3 |binarioM[2] <<2 | binarioM[1]<<1 | binarioM[0] <<0 );                
                            }
                    counter_lcd(1,2);
    }
    }
    }  

    // attachInterrupt(digitalPinToInterdfdfrupt(16), interrupcion_rfid, FALLING); //Se activa la interrupción. 
 } 
   memcpy(lcdLl, lcdL, sizeof(lcdL));
                                              memset(lcdH,' ', sizeof(lcdH));
                                              memset(lcdL,' ', sizeof(lcdL)); 
       // 

                                     memset(LCDA,' ', sizeof(lcdH));
                                     memset(LCDB,' ', sizeof(lcdH));
                                     delayMicroseconds(5000);
                                     h=0;
}
 //}

void counter_lcd(int j, int t){

      for (int i = 0; i< j; i++) {    //Bucle para repetir el proceso las veces requeridas
          bytep= (bytep | 0b01100000);
            Wire.beginTransmission(lcd_direccion);
            Wire.write(bytep);
            Wire.endTransmission();
            delay(t);
          bytep= (bytep & 0b10011111);
            Wire.beginTransmission(lcd_direccion);
            Wire.write(bytep);
            Wire.endTransmission();
            delay(t);
   }       
}