/* Gateway LoRa
  Lora/Wifi/MQTT/Home-Assistant
  Envia información por red Lora/Gateway WiFi
  hacia un broker MQTT y gestionar datos en Home-Assistant
  edelros@espol.edu.ec
  http://blog.espol.edu.ec/edelros/
  
  Referencia: Aaron.Lee www.heltec.cn
  https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series
*/
#include "heltec.h"
#include <WiFi.h>
#include <PubSubClient.h>

// DISPOSITIVO LORA Banda ISM en Región 915Mhz
#define BAND  915E6 //433E6,868E6,915E6
// ranges from 6-12,default 7 see API docs
byte spread_factor = 8;

// LoRa Mensaje a enviar por direcciones
String paqueteEnv = "";
byte dir_local   = 0xC1; // Concentrador 1
byte dir_destino = 0xD1; // Dispositivo 1
byte msjContador = 0; // identificador de mensaje
// tiempo entre lecturas
long t_anterior = 0;
int  t_intervalo = 4000;

// LoRa Mensaje Recibido
byte dir_envio = 0xC1; // Concentrador 1
int dir_remite = 0xD0; // Inicia Remitente
String paqueteRcb = "";
byte   paqrcbID = 0;
byte   paqrcbEstado = 0;
  // 0:vacio, 1: nuevo, 2:incompleto
  // 3:otro destinatario, 4:Broadcast

 // Mensajes por Puerto Serial
volatile boolean serial_msj = true;

// WIFI: conexión a Router
char* ssid = "giotirni20";
char* password = "Anera2020@";

// MQTT: Servidor
char* MQTT_IP = "192.168.10.50";
uint16_t MQTT_puerto = 1883;
char* MQTT_usuario = "usuarioprueba";
char* MQTT_contrasena = "usuarioclave";

// MQTT: Dispositivo Sensor
char* MQTT_ID = "LoraGatewayC1";
char MQTT_TOPIC_T[50] = "invernadero/loraD1/temperatura";
char MQTT_TOPIC_H[50] = "invernadero/loraD1/humedad";
char MQTT_TOPIC_V[50] = "invernadero/loraD1/voltaje";
char MQTT_SensorEstado[10] = "OFF";
volatile boolean mqtt_desconectado = true;
// MQTT: Dispositivo Actuador
char* MQTT_COMMAND = "invernadero/loraD1/cambia";
char MQTT_ActuadorEstado[10] = "OFF";
volatile boolean actuador_estado = false;
volatile boolean actuador_bandera = false;
char temperatura[10]  = "00.00";
char humedad[10] = "00.00";
char voltaje[10] = "00.00";

// Clientes WiFi y MQTT
WiFiClient wificlient;
PubSubClient mqttclient(wificlient);

void setup(){
  Heltec.begin(false /*DisplayEnable Enable*/,
    true /*Heltec.Heltec.Heltec.LoRa Disable*/,
    serial_msj /*Serial Enable*/,
    true /*PABOOST Enable*/,
    BAND /*long BAND*/);
  // ranges from 6-12,default 7 see API docs
  LoRa.setSpreadingFactor(spread_factor);
  
  //LoRa.onReceive(cbk);
  LoRa.receive();
  
  // conexión WIFI y MQTT
  inicia_wifi();
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt();
    }
}

void loop(){
  // parametros de recepción
  int rssi_lora = 0;
  int snr_lora = 0;
  
  // Revisa mensajes LoRa entrantes
  int msjRcbLoRa = LoRa.parsePacket();
  if (msjRcbLoRa !=0){
    
    recibirlora(msjRcbLoRa);
    rssi_lora = LoRa.packetRssi();
    snr_lora = LoRa.packetSnr();
       
    if (serial_msj==true){
      Serial.println("remite,msjID,mensaje,estado,Rssi,Snr");
      Serial.print(String(dir_remite, HEX)); Serial.print(",");
      Serial.print(paqrcbID); Serial.print(",");
      Serial.print(paqueteRcb); Serial.print(",");
      Serial.print(paqrcbEstado); Serial.print(",");
      Serial.print(rssi_lora); Serial.print(",");
      Serial.println(snr_lora);
    }
    yield(); // procesa wifi
    
    // LED parpadea Rebibido Lora
    digitalWrite(LED, HIGH); delay(50);
    digitalWrite(LED, LOW); delay(50);
    digitalWrite(LED, HIGH); delay(50);
    digitalWrite(LED, LOW);
    yield(); // procesa wifi
    delay(100);
  }

  // Procesa a MQTT mensaje completo
  if (msjRcbLoRa !=0 && paqrcbEstado == 1){
    // Separa parámetros
    String t = paqueteRcb.substring(1,6);
    String h = paqueteRcb.substring(8,10);
    String v = paqueteRcb.substring(12);
    
    // procesa tópico MQTT
    
    // añade dispositivo
    String topico = "invernadero/lora";
    String remite = String(dir_remite, HEX);
    remite.toUpperCase();
    topico = topico + remite;
    
    // procesa topico
    String topicot = topico + "/temperatura";
    String topicoh = topico + "/humedad";
    String topicov = topico + "/voltaje";
    topicot.toCharArray(MQTT_TOPIC_T,topicot.length()+1);
    topicoh.toCharArray(MQTT_TOPIC_H,topicoh.length()+1);
    topicov.toCharArray(MQTT_TOPIC_V,topicov.length()+1);

    t.toCharArray(temperatura,t.length()+1);
    h.toCharArray(humedad,h.length()+1);
    v.toCharArray(voltaje,v.length()+1);
    Serial.println(topicov);

    
   publica_estado();
  }
  yield(); // procesa wifi
  delay(20);

  // reenviar a dispositivo
  if (actuador_bandera == true){
    msjContador = msjContador +1;
    enviarlora(dir_destino, dir_local, 
               msjContador, paqueteEnv);
    actuador_bandera = false;
  }
  yield(); // procesa wifi
  delay(20);
  
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
  }else{
    if (mqttclient.connected()==false){
      mqtt_desconectado = true;
      inicia_mqtt(); // reintento
    }
    if (mqttclient.connected()==true){
      if (mqtt_desconectado==true){
        publica_estado();
        mqtt_desconectado=false;
      }
      mqttclient.loop();
    }
  }
  yield(); // procesa wifi
}


void enviarlora(byte destino, byte remite,
                byte paqueteID, String paquete){
  // espera que el radio esté listo
  // para enviar un paquete
  while(LoRa.beginPacket() == 0){
    if (serial_msj==true){
      Serial.println("Esperando radio disponible...");
    }
    yield(); // procesa wifi
    delay(100);
  }
  // envio del mensaje LoRa
  LoRa.beginPacket();
  LoRa.write(destino);
  LoRa.write(remite);
  LoRa.write(paqueteID);
  LoRa.write(paquete.length());
  LoRa.print(paquete);
  LoRa.endPacket();
}

void recibirlora(int tamano){
  if (tamano == 0){ 
    paqrcbEstado = 0; //vacio
    return;
  }
    
  // lectura de paquete
  paqueteRcb = "";
  dir_envio = LoRa.read();
  dir_remite  = LoRa.read();
  paqrcbID = LoRa.read();
  byte paqrcbTamano = LoRa.read();
  while(LoRa.available()){
    paqueteRcb += (char)LoRa.read();
  }
  
  if (paqrcbTamano != paqueteRcb.length()){
    paqrcbEstado = 2; // Tamaño incompleto
    return;
  }
  if (dir_envio != dir_local){
    paqrcbEstado = 3; // otro destino
    return;
  }
  if (dir_envio == 0xFF) {
    paqrcbEstado = 4; // Broadcast
    return;
  }
  paqrcbEstado = 1;  // mensaje Nuevo
}

void inicia_mqtt(void){
  int intentosmqtt = 5;
  int cuentamqtt = 0;
  
  if (serial_msj){
    Serial.print(" MQTT Conectando a ");
    Serial.println(MQTT_IP);
    }

  mqttclient.setServer(MQTT_IP, MQTT_puerto);
  mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena);
  mqttclient.setCallback(recibirmqtt);
  
  while (!mqttclient.connected() && (cuentamqtt<=intentosmqtt)){
    if (serial_msj){
      Serial.print(".");
    }
    cuentamqtt = cuentamqtt + 1;
    // LED Monitor parpadeo MQTT
    digitalWrite(LED, HIGH); delay(200);
    digitalWrite(LED, LOW); delay(200);
  }
  if (mqttclient.connected()){
      publica_estado();
  }
  if (serial_msj){
    //Fin de "...."
    Serial.println();
    Serial.print(" MQTT Conectado: ");
    Serial.print(mqttclient.connected());
    Serial.print("\t MQTT Estado: ");
    Serial.println(mqttclient.state());
  }
}

void publica_estado() { 

  if (mqttclient.connected()==true){
    mqttclient.publish(MQTT_TOPIC_T,temperatura,true);
    mqttclient.publish(MQTT_TOPIC_H,humedad,true);
    mqttclient.publish(MQTT_TOPIC_V,voltaje,true);
    mqttclient.subscribe(MQTT_COMMAND);
  }else{
    mqtt_desconectado = true;
  }
}

// llega mensaje MQTT, callback mqtt
void recibirmqtt(char* p_topic, byte* p_payload,
                  unsigned int p_length) {
  Serial.println("un mensaje mqtt");
  Serial.println(p_topic);
  // convierte a texto
  String payload;
  for (uint8_t i = 0; i < p_length; i++) {
    payload.concat((char)p_payload[i]);
    }
  // String dispositivo = p_topic[16] + String(p_topic[17]);
  char dispositivo[3] = "D0";
  dispositivo[1]=p_topic[17];
  dir_destino = (int) strtol(dispositivo,NULL,16);
  paqueteEnv = payload;
  actuador_bandera = true;

  if (mqttclient.connected()==true){
    mqttclient.subscribe(MQTT_COMMAND);
  }else{
    mqtt_desconectado = true;
  }
}

void inicia_wifi(void) {
  int intentoswifi = 10;
  int cuentawifi = 0;
  
  if (serial_msj){
    Serial.print(" WiFi Conectando a ");
    Serial.println(ssid);
    }
  
  WiFi.disconnect(true);
  delay(1000);
  WiFi.mode(WIFI_STA);
  WiFi.setAutoConnect(true);
  WiFi.begin(ssid,password);
  delay(100);
  
  while(WiFi.status() != WL_CONNECTED && 
             cuentawifi < intentoswifi){
    if (serial_msj){
      Serial.print(".");
      }
    cuentawifi = cuentawifi + 1;
    // Parpadeo de Monitor Wifi
    digitalWrite(LED, HIGH);delay(300);
    digitalWrite(LED, LOW);delay(200);
  }
  if (serial_msj){
    // mensaje a serial
    Serial.println();
    if (WiFi.status() == WL_CONNECTED){
      Serial.print(" Estado: ");
      Serial.println(WiFi.status());
      Serial.print(" MAC: ");
      Serial.println(WiFi.macAddress());
      Serial.print(" IP: ");
      Serial.println(WiFi.localIP());
      Serial.print(" RSSI: ");
      Serial.println(WiFi.RSSI());
      Serial.println();
    }
    if (WiFi.status() != WL_CONNECTED){
        WiFi.printDiag(Serial);
        Serial.println();
    }
  }
}

/*
  Dispositivo Sensor Temperatura y Humedad con DHT11
  Broker: MQTT/Home-Assistant
  Red ruta: LoRa/WiFi/Ethernet
  edelros@espol.edu.ec
  http://blog.espol.edu.ec/edelros/
  Referencia: Ejemplos de Aaron.Lee www.heltec.cn
*/
#include "heltec.h"
#include "DHT.h"

// Sensor de Temperatura&Humedad
#define DHTPIN 13
#define DHTTYPE DHT11 
DHT dht(DHTPIN, DHTTYPE);
String temperatura = "";
String humedad = ""; 

// Sensor de Bateria
# define BattPIN 36
String battNivel;

//Banda LoRa 915Mhz - ISM en Región 
#define BAND  915E6 // 433E6,868E6,915E6
// ranges from 6-12,default 7 see API docs
byte spread_factor = 8;

// Mensaje a enviar por direcciones
byte dir_local   = 0xD1; // Dispositivo  1
byte dir_destino = 0xC1; // Concentrador 1
// identificador de mensaje
byte msjContador = 0;
// tiempo entre lecturas
long t_anterior = 0;
int  t_intervalo = 5000;

// Mensaje Recibido
byte dir_envio = 0xC1; // Concentrador 1
int dir_remite = 0xD0; // Inicia Remitente
String paqueteRcb = "";
byte   paqrcbvID = 0;
byte   paqrcbEstado = 0;
  // 0:vacio, 1: nuevo, 2:incompleto
  // 3:otro destinatario, 4:Broadcast

 // Mensajes por Puerto Serial
volatile boolean serial_msj = true;

void setup(){
  Heltec.begin(false /*DisplayEnable Enable*/,
    true /*Heltec.Heltec.Heltec.LoRa Disable*/,
    serial_msj /*Serial Enable*/,
    true /*PABOOST Enable*/,
    BAND /*long BAND*/);
    
  // ranges from 6-12,default 7 see API docs
  LoRa.setSpreadingFactor(spread_factor);
  //LoRa.onReceive(cbk);
  LoRa.receive();

  //inicializa sensores
  pinMode(DHTPIN, INPUT);
  dht.begin();
  pinMode(BattPIN, INPUT);
  }

void loop(){
  // Enviar mensajes entre intervalos
  long t_ahora = millis();
  long t_transcurrido = t_ahora - t_anterior;

  // parametros de recepción
  int rssi_lora = 0;
  int snr_lora = 0;
  
  if (t_transcurrido >= t_intervalo){
    sensorLeeDHT(); //actualiza estado del sensor
    sensorBateria(); // actualiza estado de bateria
    
    // Construye paquete a enviar
    String paqueteEnv = "";
    paqueteEnv = paqueteEnv + "t" + temperatura;
    paqueteEnv = paqueteEnv + "|";
    paqueteEnv = paqueteEnv + "h" + humedad;
    paqueteEnv = paqueteEnv + "|";
    paqueteEnv = paqueteEnv + "v" + battNivel;
    
    enviarlora(dir_destino, dir_local,
               msjContador, paqueteEnv);
    
    msjContador = msjContador + 1;
    
    // parametros de recepción
    rssi_lora = LoRa.packetRssi();
    snr_lora = LoRa.packetSnr();
    yield();
    
    // mensaje a serial
    if (serial_msj==true){
      Serial.print(String(dir_destino,HEX));
      Serial.print(",");
      Serial.print(String(dir_local,HEX));
      Serial.print(",");
      Serial.print(msjContador);Serial.print(",");
      Serial.print(paqueteEnv.length());Serial.print(",");
      Serial.print(paqueteEnv);Serial.print(",");
      Serial.print(rssi_lora);Serial.print(",");
      Serial.println(snr_lora);
    }
    
    t_anterior = millis();
    t_intervalo = 3000 + random(2000);
    
    // LED parpadea envio lora
    digitalWrite(LED, HIGH); delay(100);
    digitalWrite(LED, LOW);  delay(100);
    yield(); // procesa wifi
  }

  // Revisar mensajes LoRa entrantes
  int msjRcbLoRa = LoRa.parsePacket();
  if (msjRcbLoRa !=0){
    recibirlora(msjRcbLoRa);
    rssi_lora = LoRa.packetRssi();
    snr_lora = LoRa.packetSnr();
    
    if (serial_msj==true){
      if (paqrcbEstado == 1){
        Serial.println("Mensaje: " + paqueteRcb);
        Serial.println("RSSI: " + String(rssi_lora));
        Serial.println("Snr: " + String(snr_lora));
        Serial.println();
      }else{
        Serial.print("Paquete recibido Estado: ");
        Serial.println(paqrcbEstado);
      }
    }
    yield(); // procesa wifi
    
    // LED parpadea Recibido Lora
    digitalWrite(LED, HIGH); delay(50);
    digitalWrite(LED, LOW); delay(50);
    digitalWrite(LED, HIGH); delay(50);
    digitalWrite(LED, LOW);
  }
  delay(100);
  yield(); // procesa wifi
}

void enviarlora(byte destino, byte remite,
                byte paqueteID, String paquete){
  // espera que el radio esté listo
  // para enviar un paquete
  while(LoRa.beginPacket() == 0){
    if (serial_msj==true){
      Serial.println("Esperando radio disponible...");
    }
    yield(); // procesa wifi
    delay(100);
  }
  // envio del mensaje LoRa
  LoRa.beginPacket();
  LoRa.write(destino);
  LoRa.write(remite);
  LoRa.write(paqueteID);
  LoRa.write(paquete.length());
  LoRa.print(paquete);
  LoRa.endPacket();
}

void recibirlora(int tamano){
  if (tamano == 0){ 
    paqrcbEstado = 0; //vacio
    return;
    }
  // lectura de paquete
  paqueteRcb = "";
  dir_envio = LoRa.read();
  dir_remite  = LoRa.read();
  paqrcbvID = LoRa.read();
  byte paqrcbTamano = LoRa.read();
  while(LoRa.available()){
    paqueteRcb += (char)LoRa.read();
  }
  if (paqrcbTamano != paqueteRcb.length()){
    paqrcbEstado = 2; // Tamaño incompleto
    return;
  }
  if (dir_envio != dir_local){
    paqrcbEstado = 3; // otro destino
    return;
  }
  if (dir_envio == 0xFF) {
    paqrcbEstado = 4; // Broadcast
    return;
  }
  paqrcbEstado = 1;  // mensaje Nuevo
}

// Sensor lecturas
void sensorLeeDHT(){
  humedad = String(int(dht.readHumidity())).c_str();
  temperatura = String(dht.readTemperature()).c_str();
}

void sensorBateria(){
  int lectura = analogRead(BattPIN);
  // convierte a equivalente en voltios
  float voltaje = (float(lectura)/4096.0)*4.2*3.0/2.0;
  battNivel = String(voltaje).c_str();
}