// Pin donde se conecta el bus 1-Wire
const int pinDatosDQ = 4;

// Pin donde se conecta el rele
const int relePin = 17;
boolean releActivo = false;

// Instancia a las clases OneWire y DallasTemperature
OneWire oneWireObjeto(pinDatosDQ);
DallasTemperature sensorDS18B20(&oneWireObjeto);

//Clave AES128
uint8_t key[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

//Inicialización de la terminal  
  Serial.begin(9600);
  while (!Serial);

  //Configuramos el pin del rele de salida
  pinMode(relePin, OUTPUT); 

  //Configuramos la conexión con el DS18B20
  sensorDS18B20.begin(); 

  //Configuramos la librería LoRa con los pines CS, RST, DST
  LoRa.setPins(53, 3, 2);

  //Esperamos que este activo el módulo LoRa
  if (!LoRa.begin(433E6)) {
    Serial.println("Starting LoRa failed!");
    while (1);
  }

  //Configuramos el callback que se ejecutará cuando recibamos un mensaje
  LoRa.onReceive(onReceive);

  //Activamos el modo "escucha" del LoRa.
  LoRa.receive();  

 // Cada 5 segundos enviaremos la temperatura al receptor
 if (runEvery(5000)) { 
   sendTemperatura();
 }

void sendTemperatura() {

    //Recuperamos la temperatura del sensor
    sensorDS18B20.requestTemperatures();

    //Cadena donde almacenaremos la temperatura en un array de char
    char buffn[10]= {};  

    //Convertimos la temperatura
    dtostrf(sensorDS18B20.getTempCByIndex(0),6,2,buffn); 

    //Preparamos un buffer para el mensaje: temperatura y estado de relé
    char buffer[16]= {};  
    sprintf(buffer, "%s %12s", releActivo?"On ":"Off",buffn);

    //Encriptamos el buffer con la clave definida
    aes128_enc_single(key, buffer);

    //Enviamos el mensaje
    LoRa.beginPacket();
    LoRa.print(buffer);
    LoRa.endPacket();

    //Volvemos a poner en escucha el módulo LoRa
    LoRa.receive();  
}

void onReceive(int packetSize) {

  //Leemos el mensaje recibido.
  String message = "";
  while (LoRa.available()) {
    message += (char)LoRa.read();
  }

  //Verificamos que la orden sera "RELE" para cambiar el estado.
  if(message == "RELE") {
     if(releActivo) {
       digitalWrite(relePin, LOW);   
     } else {
       digitalWrite(relePin, HIGH);
     }
     releActivo = !releActivo;
     delay(1000);

     //Notificamos al receptor el nuevo estado del relé
     sendTemperatura();
  }
}

boolean runEvery(unsigned long interval)
{
  static unsigned long previousMillis = 0;
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval)
  {
    previousMillis = currentMillis;
    return true;
  }
  return false;
}

#include <SPI.h>
#include <Wire.h> 
#include <LoRa.h>
#include <LiquidCrystal_I2C.h>
#include <AESLib.h>

//Pin analógico A0
const int buttonPin = A0;

//Clave AES128
uint8_t key[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

//Instancia de la clase LiquidCrystal_I2C 
LiquidCrystal_I2C lcd(0x27, 16, 2); 

  //Inicialización de la terminal  
  Serial.begin(9600);
  while (!Serial);

  //Configuramos la entrada analógica para el botón
  pinMode(buttonPin, OUTPUT); 
  digitalWrite(buttonPin, HIGH);

  //Inicializamos el LCD.
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("LoRa Receiver");    
 
  
  //Configuramos la librería LoRa con los pines CS, RST, DST
  LoRa.setPins(53, 3, 2);
  
  //Esperamos que este activo el módulo LoRa
  if (!LoRa.begin(433E6)) {
    Serial.println("Starting LoRa failed!");
    lcd.setCursor(0, 0);
    lcd.print("Starting LoRa failed!");   
    while (1);
  }

  //Activamos el modo "escucha" del LoRa.
  LoRa.receive();

//Se intenta parsear los mensajes recibidos por el módulo
  int packetSize = LoRa.parsePacket();
 
  //Si tenemos un nuevo mensaje
  if (packetSize) {
      
    //Preparamos el array para almacenarlo
    char message[16] = {};
   
    //Recivimos el paquete y lo almacenamos
    while (LoRa.available()) {
      for (int i = 0; i < 16; i++)  {
       // Message = Message + (char)LoRa.read();
        message[i] = (char)LoRa.read();
      }
    }
    
    //Se decodifica el mensaje
    aes128_dec_single(key, message);
    
    //Si es un mensaje correcto comenzará por la letra 'O'
    if(message[0] == 'O') {
       //Se pinta en el LCD.
       lcd.setCursor(0, 1);
       lcd.print("            ");
       lcd.setCursor(0, 1);
       lcd.print(message);
    }
    
    //Mostramos por el LCD la fuerza de la señal recibida.
    lcd.setCursor(0, 0);
    lcd.print("                  ");
    lcd.setCursor(0, 0);
    lcd.print("RSSI ");
    lcd.print(LoRa.packetRssi());   
    
  }
  //Leemos el botón por si el usuario lo ha pulsado
  int buttonState = analogRead(buttonPin);

  //Si el valor leido es menor de 100 enviamos mensaje al emisor
  if(buttonState  < 100) {

    //Informamos por LCD de la acción  
    lcd.setCursor(0, 0);
    lcd.print("Enviando !!      ");

    //Trasmitimos el comando 'RELE'
    LoRa.beginPacket();               
    LoRa.print("RELE");                 
    LoRa.endPacket();
    delay(2000);
     
    lcd.setCursor(0, 0);
    lcd.print("                  ");

    //Volvemos a poner el módulo LoRa en escucha
    LoRa.receive();      
  }