9758

#include <stdio.h>

#include <WiFi.h>

#include <MQTT.h>

#include <SPI.h>

#include "DallasTemperature.h"

#include "EmonLib.h"

#include <PubSubClient.h>

#include <time.h>

#include <ArduinoJson.h>

#include "ESPDateTime.h"

#include <esp_task_wdt.h> //Biblioteca do watchdog

//#define MDASH_APP_NAME "BLE_31364"

//#include <mDash.h>

#include <BLEDevice.h>

#include <BLEUtils.h>

#include <BLEScan.h>

#include <BLEAdvertisedDevice.h>

void BLE();

void connect2();

void HoraData1();

void HoraData2();

void Temperaturas();

void conectarEnviar();

void Correntes();

void Tensoes();

void DHCP();

//***********Define o nome da rede, senha para conexão e os endereços para conexão********************

const char* rede = "SmartVac Telemetria";

const char* senha = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; procurar

const char* SERVIDOR = "web.smartvac.app"; 

int PORTA = 1883;

 

//***************************************Define os itens do MQTT **************************************

WiFiClient Client;

PubSubClient MQTT(Client);

//***************Definição dos pinos para os sensores de temperatura, corrente e tensão****************

#define ONE_WIRE_BUS_PINA 14 // Temperatura

#define ONE_WIRE_BUS_PINB 36 // Temperatura

#define PIN_CURR_R 34 // Corrente R

#define PIN_CURR_S 36 // Corrente S

#define PIN_CURR_T 39 // Corrente T

#define PIN_VOLT_R 35 // Tensão R

#define PIN_VOLT_S 32 // Tensão S

#define PIN_VOLT_T 33 // Tensão T

//#define DEVICE_PASSWORD "oh099QByIVRdERWq4CRijnA"

//******************************Variaveis Globais******************************************************

 

float TempIns;

float TempRet;

float TempSuc;

float TempDes;

float TempExt;

float TempExt2;

float BLERet;

float BLESuc;

float BLEIns;

float BLELinha;

float BLEExt;

float BLEX;

float BLEY;

float BLEZ;

float Bat_ins;

float Bat_ret;

float Bat_linha;

float Bat_suc;

float Bat_ext;

uint16_t voltage;

int16_t accX;

int16_t accY;

int16_t accZ;

std::map<std::string, float> macTemperatures;

time_t timer;

time_t timeStemp;

int diferenca=0;

int difOitoHoras=0;

//***************************Abre a instância OneWire***************************************

OneWire oneWireA(ONE_WIRE_BUS_PINA);

OneWire oneWireB(ONE_WIRE_BUS_PINB);

//*****************Passagem de dados do one wire para o Dallas******************************

DallasTemperature sensorsA(&oneWireA);

DallasTemperature sensorsB(&oneWireB);

// Declaração das variaveis para medição de corrente e tensão

EnergyMonitor emon1,emon2,emon3,emon4,emon5,emon6;

double Irms1,Irms2, Irms3;

double Vrms4, Vrms5, Vrms6;

//****************************Calibração***************************************************

#define VOLT_CAL1 263.38 //VALOR DE CALIBRAÇÃO (DEVE SER AJUSTADO EM PARALELO COM UM MULTÍMETRO)

#define VOLT_CAL2 0000 //VALOR DE CALIBRAÇÃO (DEVE SER AJUSTADO EM PARALELO COM UM MULTÍMETRO)

#define VOLT_CAL3 0000 //VALOR DE CALIBRAÇÃO (DEVE SER AJUSTADO EM PARALELO COM UM MULTÍMETRO)

#define CURR_CAL1 17.88 //17.7VALOR DE CALIBRAÇÃO (DEVE SER AJUSTADO EM PARALELO COM UM MULTÍMETRO)

#define CURR_CAL2 00000 //VALOR DE CALIBRAÇÃO (DEVE SER AJUSTADO EM PARALELO COM UM MULTÍMETRO)

#define CURR_CAL3 0000 //VALOR DE CALIBRAÇÃO (DEVE SER AJUSTADO EM PARALELO COM UM MULTÍMETRO)

//*****************Declaração endereço sensores de temperatura******************************

DeviceAddress Probe01 = { 0x28, 0x6F, 0x2A, 0x95, 0xF0, 0x01, 0x3C, 0x88 }; //Insuflamento

DeviceAddress Probe02 = { 0x28, 0xAD, 0xD3, 0x56, 0xB5, 0x01, 0x3C, 0x99 }; //Retorno

DeviceAddress Probe03 = { 0x28, 0x7D, 0x6D, 0x95, 0xF0, 0x01, 0x3C, 0x05 }; //Sucção 

DeviceAddress Probe04 = { 0x28, 0xC1, 0x30, 0x95, 0xF0, 0x01, 0x3C, 0x06 }; //Descarga

DeviceAddress Probe05 = { 0x28, 0x9C, 0x44, 0x56, 0xB5, 0x01, 0x3C, 0xA5 }; //Externa

DeviceAddress Probe06 = { 0x28, 0xC9, 0x27, 0x95, 0xF0, 0x01, 0x3C, 0x8A }; //Externa Reserva (entrada do condensador) 

//*****************Setup do hardware********************************************************

BLEScan* pBLEScan;

/*----------------------------------------------------------------------------------------------------------------

// Lista de sensores BLE. SEMPRE SEGUIR A ORDEM: Insuflamento, Retorno, Sucção, Linha de Líquido/Descarga, Externa.

--------------------------------------------------------------------------------------------------------------------*/

std::string macAddresses[] = {

 "bc:57:29:0e:2e:c1", //Insuflamento

 "bc:57:29:0e:19:9d", //Retorno

 "bc:57:29:0e:25:e9", // Sucção

 "bc:57:29:0e:26:10", // Linha De Líquido/ Descarga

 "bc:57:29:0e:26:2b" //Externa

};

// Keep track of the current MAC address index we are looking for

int currentMacIndex = 0;

const int numMacAddresses = sizeof(macAddresses) / sizeof(macAddresses[0]);

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {

 void onResult(BLEAdvertisedDevice advertisedDevice) {

 std::string strServiceData = advertisedDevice.getServiceData();

 std::string mac = advertisedDevice.getAddress().toString();

 

 

 // Only proceed if the MAC address matches the current one we are looking for

 if(mac == macAddresses[currentMacIndex]){

 uint8_t* payload = (uint8_t*)strServiceData.c_str();

 int len = strServiceData.length();

 Serial.print("Received payload from ");

 Serial.print(mac.c_str());

 Serial.print(": ");

 for(int i = 0; i < len; i++){

 if(payload[i] < 16) Serial.print("0"); // If less than 16, prepend with '0' to maintain 2 hex digits

 Serial.print(payload[i], HEX);

 }

 Serial.println();

 int offset = 2; // Starting offset after frame type and version tag

 uint8_t sensorMask = payload[offset++];

 if(sensorMask & 0x01) { // Voltage

 uint16_t voltage = (payload[offset] << 8) | payload[offset + 1];

 offset += 2;

 Serial.print("Voltage: ");

 Serial.print(voltage);

 Serial.println(" mV");

 if (mac == macAddresses[0]) { //Insuflamento

 

 Bat_ins = voltage;

 }

 else if (mac == macAddresses[1]) { //Retorno

 

 Bat_ret = voltage;

 }

 else if (mac == macAddresses[2]) { //Sucção

 

 Bat_suc = voltage;

 }

 else if (mac == macAddresses[3]) { //Linha de liquido

 

 Bat_linha = voltage;

 }

 else if (mac == macAddresses[4]) { //Externa

 

 Bat_ext = voltage;

 }

 }

 if(sensorMask & 0x02) { // Temperature

 uint16_t tempRaw = (payload[offset] << 8) | payload[offset + 1];

 float temp = tempRaw / 256.0;

 offset += 2;

 Serial.print("Temperature: ");

 Serial.print(temp);

 Serial.println(" °C");

 if (mac == macAddresses[0]) { //Insuflamento

 // ArraySensores[0] = temp;

 BLEIns = temp;

 }

 else if (mac == macAddresses[1]) { //Retorno

 

 BLERet = temp;

 }

 else if (mac == macAddresses[2]) { //Sucção

 

 BLESuc = temp;

 }

 else if (mac == macAddresses[3]) { //Linha de liquido

 

 BLELinha = temp;

 }

 else if (mac == macAddresses[4]) { //Externa

 

 BLEExt = temp;

 }

 }

 if(sensorMask & 0x08) { // Acceleration

 int16_t accX = (payload[offset] << 8) | payload[offset + 1];

 offset += 2;

 int16_t accY = (payload[offset] << 8) | payload[offset + 1];

 offset += 2;

 int16_t accZ = (payload[offset] << 8) | payload[offset + 1];

 offset += 2;

 Serial.print("Acceleration - X: ");

 Serial.print(accX);

 Serial.println(" mg");

 Serial.print("Y: ");

 Serial.print(accY);

 Serial.println(" mg");

 Serial.print("Z: ");

 Serial.print(accZ);

 Serial.println(" mg");

 if (mac == macAddresses[3]) // Se for o sensor de sucção, lê as vibrações

 {

 

 BLEX = accX;

 BLEY = accY;

 BLEZ = accZ;

 

 }

 }

 

 Serial.println("--------------------"); // Separator for readability

 

 // Move to the next MAC address in the list

 currentMacIndex = (currentMacIndex + 1) % numMacAddresses;

 }

 }

 

};

void setup() {

 // Serial para leitura dos dados

 Serial.begin(115200);

 // Inicia o Wifi

 WiFi.mode(WIFI_STA);

 WiFi.begin(rede, senha);

 //Inicia o password do MDash

 //mDashBegin(DEVICE_PASSWORD);

 // Estabelece o DHCP para conexão com ip dinâmico

 DHCP();

 

 //Inicia sensores

 sensorsA.begin();

 sensorsB.begin(); 

 // Seta a resolução do sensor, menor mais rápido

 sensorsA.setResolution(Probe01, 12);

 sensorsA.setResolution(Probe02, 12);

 sensorsB.setResolution(Probe03, 12);

 sensorsB.setResolution(Probe04, 12);

 sensorsA.setResolution(Probe05, 12);

 sensorsB.setResolution(Probe06, 12);

 // Define os pinos e resolução do sensor de corrente 

 emon1.current(PIN_CURR_R, CURR_CAL1); // Current: input pin, calibration. Cur Const= Ratio/BurdenR. 1800/62 = 29.

 emon2.current(PIN_CURR_S, CURR_CAL2); // Current: input pin, calibration. Cur Const= Ratio/BurdenR. 1800/62 = 29.

 emon3.current(PIN_CURR_T, CURR_CAL3); // Current: input pin, calibration. Cur Const= Ratio/BurdenR. 1800/62 = 29.

 

 // Definição do pino para tensão

 emon4.voltage(PIN_VOLT_R, VOLT_CAL1, 1.7); //PASSA PARA A FUNÇÃO OS PARÂMETROS (PINO ANALÓGIO / VALOR DE CALIBRAÇÃO / MUDANÇA DE FASE) 

 emon5.voltage(PIN_VOLT_S, VOLT_CAL2, 1.7); //PASSA PARA A FUNÇÃO OS PARÂMETROS (PINO ANALÓGIO / VALOR DE CALIBRAÇÃO / MUDANÇA DE FASE) 

 emon6.voltage(PIN_VOLT_T, VOLT_CAL3, 1.7); //PASSA PARA A FUNÇÃO OS PARÂMETROS (PINO ANALÓGIO / VALOR DE CALIBRAÇÃO / MUDANÇA DE FASE) 

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

 //Indica para o objeto "MQTT" em que servidor e em que porta iremos nos conectar

 

 MQTT.setServer(SERVIDOR,PORTA);

 MQTT.setCallback(mqtt_callback);

 connect2();

 // Inicia o timer

 HoraData1();

 //Watchdog

 esp_task_wdt_init(10800, true);

 esp_task_wdt_add(NULL);

 

 //BLE

 BLEDevice::init("");

 pBLEScan = BLEDevice::getScan();

 pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());

 pBLEScan->setActiveScan(true);

 pBLEScan->setInterval(100);

 pBLEScan->setWindow(99);

 }

//*****************Função loop***********************************************************

 

void loop() {

 conectarEnviar();

 

 }

//*****************Função do timer********************************************************

 

void HoraData1()

{

 const char tenn[]="CST-3";

 DateTime.setTimeZone(tenn);

 DateTime.setServer("ntp02.oal.ul.pt");

 DateTime.begin(); 

 int timer = DateTime.getTime();

 

 timeval tv;//Cria a estrutura temporaria para funcao abaixo.

 tv.tv_sec = timer;//Atribui minha data atual.

 settimeofday(&tv, NULL);//Atualiza a data e hora

 

 //String hora = String(String(dia) + String("/") + String(mes) + String("/") + String(ano) + String(" ") + String(hora) + String(":") + String(minuto) + String(":") + String(segundo));

}

//*****************Função do timer ****************************************************************************

void HoraData2()

{

 struct tm data;

 time_t tt = time(NULL);//Obtem o tempo atual em segundos. Utilize isso sempre que precisar obter o tempo atual

 //data = *gmtime(&tt);//Converte o tempo atual e atribui na estrutura

 diferenca=tt-timeStemp;//faz a conta para verificar se a diferença é de 2 segundos para os envios

 difOitoHoras=tt-timer; //faz a conta para verificar se a diferença é de 28800 segundos para os envios

 timeStemp=tt;

 

}

//*****************Função para publicar em formato JSON********************************************************

void Publish() {

 

JsonDocument doc1;

// StaticJsonDocument<300> doc;

doc1["t"] = timeStemp;

doc1["s91372"] = Irms1; 

//doc1["s91345"] = Irms2; 

//doc1["s91346"] = Irms3; 

doc1["s91371"] = Vrms4; 

//doc1["s91342"] = Vrms5; 

//doc1["s91343"] = Vrms6;

doc1["s91373"] = BLEX;

String STD1;

JsonDocument doc2;

doc2["t"] = timeStemp;

doc2["s91367"] = BLEIns;

doc2["s91368"] = BLERet;

doc2["s91369"] = BLESuc;

doc2["s91370"] = BLELinha; 

doc2["s91380"] = BLEExt;

doc2["s91374"] = BLEY;

doc2["s91375"] = BLEZ;

String STD2;

JsonDocument doc3;

doc3["t"] = timeStemp;

doc3["s91376"] = Bat_ins;

doc3["s91377c"] = Bat_ret;

doc3["s91378"] = Bat_suc;

doc3["s91379"] = Bat_linha;

//doc3["bat_ext"] = Bat_ext;

String STD3;

serializeJson(doc1, STD1); 

serializeJson(doc2, STD2); 

serializeJson(doc3, STD3);

Serial.println (STD1);

Serial.println (STD2);

Serial.println (STD3);

//*****************MQTT.publish aceita apenas char, as próximas linhas convertem a string em char*****************

 int tamanho = STD1.length() + 1; //Define o tamanho da String

 char mensa1[tamanho]; //Cria um array de char com o tamanho da String

 STD1.toCharArray(mensa1, tamanho); //Converte a String para char e atribui os valores ao array

 

 int tamanho2 = STD2.length() + 1; //Define o tamanho da String

 char mensa2[tamanho2]; //Cria um array de char com o tamanho da String

 STD2.toCharArray(mensa2, tamanho2); //Converte a String para char e atribui os valores ao array

 

 int tamanho3 = STD3.length() + 1; //Define o tamanho da String

 char mensa3[tamanho3]; //Cria um array de char com o tamanho da String

 STD3.toCharArray(mensa3, tamanho3); //Converte a String para char e atribui os valores ao array

 

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

 MQTT.publish("v4/matr0541",mensa1); // Envio de dados para determinado lugar do tópico

 delay (1000);

 MQTT.publish("v4/matr0541",mensa2); // Envio de dados para determinado lugar do tópico

 delay (1000);

 MQTT.publish("v4/matr0541",mensa3); // Envio de dados para determinado lugar do tópico

 delay (1000);

 Serial.println("Enviou");

 delay(60000);

 }

//*****************Função de conexão no MQTT**********************************************************************

void conectarEnviar() {

 

 MQTT.loop();

 if (WiFi.status() == WL_CONNECTED && MQTT.connected()) {

 

 Serial.println("------------------");

 Serial.println("Wifi conectado e servidor conectados");

 Serial.println("------------------");

 // Calcula a ultima atualização horária e roda as leituras

 if(difOitoHoras > 28600)

 {

 

 HoraData1();

 Tensoes();

 Temperaturas();

 Correntes();

 BLE();

 Publish();

 difOitoHoras=0;

 

 }

 else

 {

 

 HoraData2();

 if(diferenca>2)

 {

 

 Tensoes();

 Temperaturas();

 Correntes();

 BLE();

 Publish();

 

 }

 }

 

 } 

 else if(WiFi.status() != WL_CONNECTED || !MQTT.connected())

 { 

 Serial.println("------------------");

 Serial.println("Wifi ou servidor desconectado");

 Serial.println("------------------");

 

 DHCP();

 connect2();

 

 }

 }

//*****************Função de leitura das temperaturas********************************************************

void Temperaturas() {

 

 sensorsA.requestTemperatures();

 sensorsB.requestTemperatures();

 // Serial.println("######TEMPERATURAS######");

 TempIns = (sensorsA.getTempC(Probe01));

 //Serial.print("Insuflamento: ");

 //Serial.print(TempIns);

 //Serial.println("°C");

 

 TempRet = (sensorsA.getTempC(Probe02));

 //Serial.print("Retorno: ");

 //Serial.print(TempRet);

 //Serial.println("°C");

 TempSuc = (sensorsB.getTempC(Probe03));

 //Serial.print("Sucção: ");

 //Serial.print(TempSuc);

 //Serial.println("°C");

 

 TempDes = (sensorsB.getTempC(Probe04));

 //Serial.print("Descarga: ");

 //Serial.print(TempDes);

 //Serial.println("°C");

 

 TempExt = (sensorsA.getTempC(Probe05));

 //Serial.print("Externa: ");

 //Serial.print(TempExt);

 //Serial.println("°C");

 

 TempExt2 = (sensorsB.getTempC(Probe06));

 //Serial.print("Retorno Condensador: ");

 //Serial.print(TempExt2);

 //Serial.println("°C");

} 

//*****************Função de leitura das correntes********************************************************

void Correntes() {

 

 Irms1 = emon1.calcIrms(1996);//Para 50Hz 1480 e para 60Hz 1996

 Irms2 = emon2.calcIrms(1996);//Para 50Hz 1480 e para 60Hz 1996

 Irms3 = emon3.calcIrms(1996);//Para 50Hz 1480 e para 60Hz 1996

 

}

//*****************Função de leitura das tensões**********************************************************

void Tensoes() 

{

 

emon4.calcVI(17,1000); //FUNÇÃO DE CÁLCULO (17 SEMICICLOS, TEMPO LIMITE PARA FAZER A MEDIÇÃO)

 Vrms4 = emon4.Vrms; //VARIÁVEL RECEBE O VALOR DE TENSÃO RMS OBTIDO

 emon5.calcVI(17,1000); //FUNÇÃO DE CÁLCULO (17 SEMICICLOS, TEMPO LIMITE PARA FAZER A MEDIÇÃO)

 Vrms5 = emon5.Vrms; //VARIÁVEL RECEBE O VALOR DE TENSÃO RMS OBTIDO

 emon6.calcVI(17,1000); //FUNÇÃO DE CÁLCULO (17 SEMICICLOS, TEMPO LIMITE PARA FAZER A MEDIÇÃO)

 Vrms6 = emon6.Vrms; //VARIÁVEL RECEBE O VALOR DE TENSÃO RMS OBTIDO 

}

//*********************Função de leitura BLE*************************************************************

void BLE() {

 // Início da varredura BLE

 BLEScanResults foundDevices = pBLEScan->start(5, false);

 // Limpa os resultados da varredura BLE

 pBLEScan->clearResults();

}

 

//*****************Função de login e conexão MQTT********************************************************

void connect2() {

int cont=0;

 

 while (!MQTT.connect("9758", "matr4", "canudos92sc")) 

 {

 Serial.println("* Tentando se conectar ao Broker MQTT: ");

 if (MQTT.connect("9758", "matr4", "canudos92sc")) 

 {

 Serial.println("Conectado com sucesso ao broker MQTT!");

 MQTT.subscribe("/v4/matr0541"); 

 } 

 else

 {

 Serial.println("Falha ao reconectar no broker.");

 Serial.println("Havera nova tentativa de conexao em 1s");

 delay(1000);

 

 cont++;

 if(WiFi.status() != WL_CONNECTED && cont<10)

 {

 DHCP();

 }

 else

 {

 cont=0;

 Serial.println("Teste");

 }

 }

 }

}

//*****************Função de callback do servidor********************************************************

void messageReceived(String &topic, String &payload) {

 Serial.println("incoming: " + topic + " - " + payload); // Lê o que o servidor envia

 MQTT.setCallback(mqtt_callback);

}

void mqtt_callback(char* topic, byte* payload, unsigned int length) 

{

 String msg;

 

 //obtem a string do payload recebido

 for(int i = 0; i < length; i++) 

 {

 char c = (char)payload[i];

 msg += c;

 }

 Serial.print("[MQTT] Mensagem recebida: ");

 Serial.println(msg); 

}

//*****************Função do DHCP IP Dinâmico********************************************************

void DHCP()

{

 

 if(WiFi.status() != WL_CONNECTED) {

 Serial.println("Reconectando no wifi...");

 WiFi.disconnect();

 WiFi.reconnect();

 delay(500);

 }

 else if(WiFi.status() == WL_CONNECTED)

 {

 return;

 }

}

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