//************************************************************
//Programa Baseado no exemplo dado do PainLessMesh
// 1. Envia via e recebe mensagens para todos os nodes a cada 1 e 5 segundos
// 2. Cria e traduz a informação contida na mensagem (de quem e para quem, estado das entras e saídas, comandos)
// 3. Operação de comunicação, pelo Core 1, e de operação, pelo Core 0
// 4. Watchdog Timer
// 5. Monitora estado das entradas; Lê mensagem mestre; Cria mensagem e envia; Decisão desliga ou não 
// 6. Caso acionado, liga led vermelho e envia informação para o mestre
// 7. Acionar ou desligar saídas com base na mensagem do mestre
// 8. No caso de ser o mestre. Exibir informações em tela. Exibir informações audíveis
// 9. Mestre não hiberna ou desliga. Sempre monitora os nodes.
// 10. Imprimi testes e status das baterias e sistema do nodos. Armazena informação na memória não volátil
//************************************************************
#include "painlessMesh.h"  //rede mesh
#include <esp_task_wdt.h>  //watchdog timer
#include "WiFi.h"  //teste da rede
#include "Adafruit_Thermal.h"  //impressora térmica
#include "adalogo.h"      //impressora térmica  //arquivo colocado na pasta do programa
#include "adaqrcode.h"   //impressora térmica   //arquivo colocado na pasta do programa
#include "DFRobotDFPlayerMini.h"  //Tocador de áudio
#include "EEPROM.h"  // para salvar na EEPROM - Simulada gerada da flash

#define   MESH_PREFIX     "MeshNodes"
#define   MESH_PASSWORD   "777"
#define   MESH_PORT       5555
#define   FPSerial      Serial2              //Tocador áudio  // Original "Serial1"
#define   NumeroDispositivos 255
#define   InformacaoDispositivos 17

Scheduler userScheduler; // to control your personal task
painlessMesh  mesh;

Adafruit_Thermal printer(&Serial2);  //SERIAL 2  // Or Serial2, Serial3, etc. Para uso da impressora térmica

DFRobotDFPlayerMini myDFPlayer;   //Tocador de áudio
void printDetail(uint8_t type, int value);
  
//dWin hmi(DGUS_SERIAL, 3, 1, DGUS_BAUD); //IHM SERIAL 0

// Variáveis para criação da mensagem
String dispositivo[NumeroDispositivos][InformacaoDispositivos] = {};
String mensagem="0"; // Base da mensagem
String recebida="0"; // Base da mensagem recebida
String posicao="0"; // Base para pesquida dos dados dentro da mensagem
String dado2;  // Usado para carregar o endereço MAC no mestre
int dispositivosCadastrados=0;
int id=999; // endereço do remetente. Será armazenada na memória flash
int novoid=999; //
int enderecoEEPROM=0;  // 0 = endereço da EEPROM interna, para armazenar o "id" do dispositivo
int remetente=0;  // identificação dos nodes
int destinatario=0;  // identificação dos nodes; 0 é o id do mestre
int idRemetente=0;
int tipo=7;
int cont=0; // contagem das vírgulas
int local=0; //local da mensagem a ser lido o dado
int dado=0; // informação retirada da mensagem 
// Fim 
int RSSI=0;  //Received Signal Strength Indicator
int menorRSSI=0; //Menor RSSI
int maiorRSSI=0; //Maior RSSI
String MAC=(WiFi.macAddress());
float dado5;
//dados do cliente e dispositivos
int dia, mes, ano;
int contData=0;
String data;
String cliente, cidade, cnpj, endereco, dataRelatorio, Xi, dataRelatorio1, dataRelatorio2, dataRelatorio3;
String tipoDispositivo, marcaDispositivo, modeloDispositivo, localizacaoDispositivo, estadoFuncionamento;
String situacaoBateria, situacaoPlacaControle, situacaoSinal;
int sinalMenor, sinalMaior;
//Entrada digital ordem: 14,22,36,23,19,18,21,15,39  // 36, 15 e 39 precisam de resistor de pull-up externos
const byte AcionadorSensorAtuado=14; //Pino 14 Acionador manual, sensor ou teste atuado, In1
const byte In2=22;  //Pino 22, In2
const byte In3=36; //
const byte In4=23; //
const byte In5=19; //
const byte In6=18; //
const byte In7=21; //
const byte In8=15; //
const byte In9=39; //
//Saída digital ordem: 02,12,32,33,05,11,06,07,08)
const byte Alarme=2; //Alarme Out1
const byte LedVermelho=12; // Out2
const byte Desliga=32; // A = Desliga o circuito principal da placa A (microcontrolador) Out3
const byte LedVerdeOn=33; // E = Deixa o led verde piscando Out4
const byte LedVerdeOn2=5; // F = Deixa o led verde aceso direto Out5
const byte Out6=11;  //
const byte Out7=6;  //
const byte Out8=7;  //
const byte Out9=8;  //
//Entradas analógicas ordem: 13,27,4,0
int TensaoPilhas=13; // AnIn1
int TensaoPlacaControle=27; // AnIn2
int TensaoBateriaExterna=4; // AnIn3
int AnIn4=0; // AnIn4
int AnIn5=2; // AnIn5
int AnIn6=15; // AnIn6
//Saídas analógicas ordem: 25,26
int AnOu1=25; 
int AnOu2=26;
//Variáveis condicionamento analógico
int PorcentagemPilhas=0;
int cont2=0; // tirar médiia das leituras analógicas
int leitura; // recebe valor das leituras analógicas
long int somaLeitura=0;
int mediaLeitura=0;
int leituraTensaoPilhas=0;
int leituraTensaoPlacaControle=0;
float leituraTensaoPilhasVolts=0;
float leituraTensaoPlacaControleVolts=0;
float leituraTensaoBateriaExternaVolts=0;
float TensaoPlacaControleVolts=0;
float TensaoBateriaExternaVolts=0;
const int ValorAltoPilhas=5000; // 3V-->16,8V Calibrar
const int ValorBaixoPilhas=2000; // 0,5V-->11,2V Calibrar
const int ValorAltoPlacaControle=5000; // 3V-->16,8V Calibrar
const int ValorBaixoPlacaControle=2500; // 0,5V-->11,2V Calibrar
int leituraTensaoPilhasPorcentagem=0;
int leituraTensaoPlacaControlePorcentagem=0;
int flag1=1;
//Fim
int tempo1=0; //temporização pra checar a rede
int tempo2=0; //temporização para checar o tocador de áudio

unsigned long previousMillis = 0; // Millis
// User stub
void sendMessage() ; // Prototype so PlatformIO doesn't complain

Task taskSendMessage( TASK_SECOND * 2 , TASK_FOREVER, &sendMessage );

void sendMessage() {
  MontagemMensagem();    // Montagem da mensagem
  String msg = mensagem; //attribui para a variável utilizada pela biblioteca painlessmesh
  esp_task_wdt_reset();
  msg += mesh.getNodeId();
  mesh.sendBroadcast( msg );
  taskSendMessage.setInterval( random( TASK_SECOND * 2, TASK_SECOND * 5 ));
}

// Needed for painless library
void receivedCallback( uint32_t from, String &msg ) {
  Serial.printf("startHere: Received from %u msg=%s\n", from, msg.c_str());
  recebida = msg.c_str(); //salva pra a variável recebida
}

void newConnectionCallback(uint32_t nodeId) {
    Serial.printf("--> startHere: New Connection, nodeId = %u\n", nodeId);
}

void changedConnectionCallback() {
  Serial.printf("Changed connections\n");
}

void nodeTimeAdjustedCallback(int32_t offset) {
    Serial.printf("Adjusted time %u. Offset = %d\n", mesh.getNodeTime(),offset);
}

void setup() {
  //Habilita o watchdog configurando o timeout para 5 segundos
  esp_task_wdt_init(5, true);
  esp_task_wdt_add(NULL);

  recuperarParametrosEEPROM(); 

  //Configuração do tocador de áudio
    #if (defined ESP32)
    FPSerial.begin(9600, SERIAL_8N1, /*rx =*/10, /*tx =*/9); //SERIAL 1 //tx=D3=10-->rx ; rx=D2=9-->tx 
  #else
    FPSerial.begin(9600);
  #endif

    Serial.begin(115200);

    Serial.println();
    Serial.println(F("DFRobot DFPlayer Mini Demo"));
    Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));
    
   // if (!myDFPlayer.begin(FPSerial, /*isACK = */true, /*doReset = */true)) {  //Use serial to communicate with mp3.
    //  Serial.println(F("Unable to begin:"));
    //  Serial.println(F("1.Please recheck the connection!"));
    //  Serial.println(F("2.Please insert the SD card!"));
    //  while(true);
    //}
   //
    Serial.println(F("DFPlayer Mini online."));
    
    myDFPlayer.setTimeOut(500); //Set serial communictaion time out 500ms
    
    //----Set volume----
    myDFPlayer.volume(10);  //Set volume value (0~30).
    myDFPlayer.volumeUp(); //Volume Up
    myDFPlayer.volumeDown(); //Volume Down
    
    //----Set different EQ----
    myDFPlayer.EQ(DFPLAYER_EQ_NORMAL);
  //  myDFPlayer.EQ(DFPLAYER_EQ_POP);
  //  myDFPlayer.EQ(DFPLAYER_EQ_ROCK);
  //  myDFPlayer.EQ(DFPLAYER_EQ_JAZZ);
  //  myDFPlayer.EQ(DFPLAYER_EQ_CLASSIC);
  //  myDFPlayer.EQ(DFPLAYER_EQ_BASS);
    
    //----Set device we use SD as default----
  //  myDFPlayer.outputDevice(DFPLAYER_DEVICE_U_DISK);
    myDFPlayer.outputDevice(DFPLAYER_DEVICE_SD);
  //  myDFPlayer.outputDevice(DFPLAYER_DEVICE_AUX);
  //  myDFPlayer.outputDevice(DFPLAYER_DEVICE_SLEEP);
  //  myDFPlayer.outputDevice(DFPLAYER_DEVICE_FLASH);
    
    //----Mp3 control----
  //  myDFPlayer.sleep();     //sleep
  //  myDFPlayer.reset();     //Reset the module
  //  myDFPlayer.enableDAC();  //Enable On-chip DAC
  //  myDFPlayer.disableDAC();  //Disable On-chip DAC
  //  myDFPlayer.outputSetting(true, 15); //output setting, enable the output and set the gain to 15
  //myDFPlayer.playFolder(15, 4);  //play specific mp3 in SD:/15/004.mp3; Folder Name(1~99); File Name(1~255)

  //Configuração das saídas digitais
  pinMode(Alarme, OUTPUT); // Pino digital é saida 
  pinMode(LedVermelho, OUTPUT); // 
  pinMode(Desliga, OUTPUT); // 
  pinMode(LedVerdeOn, OUTPUT); //
  pinMode(LedVerdeOn2, OUTPUT); // 
  pinMode(Out6, OUTPUT); // 
  pinMode(Out7, OUTPUT); // 
  pinMode(Out8, OUTPUT); // 
  pinMode(Out9, OUTPUT); // 
  //Configuração das entradas digitais
  pinMode(AcionadorSensorAtuado, INPUT_PULLUP); // Pino digital é entrada
  attachInterrupt(digitalPinToInterrupt(AcionadorSensorAtuado), AcaoSensorAtuado, LOW);
  pinMode(In2, INPUT_PULLUP); // Pino digital é entrada  
  pinMode(In3, INPUT_PULLUP); // Pino digital é entrada  
  pinMode(In4, INPUT_PULLUP); // Pino digital é entrada  
  pinMode(In5, INPUT_PULLUP); // Pino digital é entrada  
  pinMode(In6, INPUT_PULLUP); // Pino digital é entrada  
  pinMode(In7, INPUT_PULLUP); // Pino digital é entrada  
  pinMode(In8, INPUT_PULLUP); // Pino digital é entrada  
  pinMode(In9, INPUT_PULLUP); // Pino digital é entrada  

  // configurações do A/D
  analogReadResolution ( 12 ); // resolução de 12 bits
  //
  TaskHandle_t loop2;
  //
  Serial.begin(115200);
  esp_task_wdt_reset();
  xTaskCreatePinnedToCore(Taskloop2, "loop2", 10000, NULL, 1, NULL, 0);//Cria a tarefa "Taskloop2()" com prioridade 1, atribuída ao core 0
  delay(500);  //tempo para estabilização 
//mesh.setDebugMsgTypes( ERROR | MESH_STATUS | CONNECTION | SYNC | COMMUNICATION | GENERAL | MSG_TYPES | REMOTE ); // all types on
  mesh.setDebugMsgTypes( ERROR | STARTUP );  // set before init() so that you can see startup messages

  mesh.init( MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT );
  mesh.onReceive(&receivedCallback);
  mesh.onNewConnection(&newConnectionCallback);
  mesh.onChangedConnections(&changedConnectionCallback);
  mesh.onNodeTimeAdjusted(&nodeTimeAdjustedCallback);

  userScheduler.addTask( taskSendMessage );
  taskSendMessage.enable();

  // NOTE: SOME PRINTERS NEED 9600 BAUD instead of 19200, check test page.
  //mySerial.begin(19200);  // Initialize SoftwareSerial
  Serial2.begin(19200); // Use this instead if using hardware serial  //Obs: Original: "Serial2.begin(19200);"
  printer.begin();        // Init printer (same regardless of serial type)
  //
}

//**Núcleo 1
void loop() {  //Relativo à comunicação com a rede mesh
  Serial.printf("\nsetup() em core: %d\n", xPortGetCoreID());//Mostra no monitor em qual core o setup() foi chamado
  esp_task_wdt_reset();
    //******
  if (tempo1 == 1) {
    // WiFi.scanNetworks will return the number of networks found.
    Serial.println("Escaneamento da Rede");
    int n = WiFi.scanNetworks();
    Serial.println("Escaneamento Feito");
    if (n == 0) {
        Serial.println("Nenhuma rede encontrada");
          digitalWrite(LedVerdeOn2, LOW); // Deixa o led verde aceso direto ou apagado direto
          delay(10);  //Necessário ajustar o tempo
          digitalWrite(LedVerdeOn2, HIGH); // Deixa o led verde aceso direto ou apagado direto
    } else {
        Serial.print(n);
        Serial.println(" rede encontrada");
        
          digitalWrite(LedVerdeOn, LOW); // Deixa o led verde aceso direto ou apagado direto
          delay(10);
          digitalWrite(LedVerdeOn, HIGH); // Deixa o led verde aceso direto ou apagado direto
            Serial.println("Nr | SSID                             | RSSI | CH | Encryption");
        for (int i = 0; i < n; ++i) {
            // Print SSID and RSSI for each network found
            Serial.printf("%2d",i + 1);
            Serial.print(" | ");
            Serial.printf("%-32.32s", WiFi.SSID(i).c_str());
            Serial.print(" | ");
            Serial.printf("%4d", WiFi.RSSI(i));
            RSSI=WiFi.RSSI(i);
            //Exibe o menor sinal e o maior sinal RSSI
            if (RSSI<=menorRSSI) { menorRSSI=RSSI; }
            if (RSSI>=maiorRSSI) { maiorRSSI=RSSI; }
            Serial.print(" | ");
            Serial.printf("%2d", WiFi.channel(i));
            Serial.print(" | ");
            switch (WiFi.encryptionType(i))
            {
            case WIFI_AUTH_OPEN:
                Serial.print("open");
                break;
            case WIFI_AUTH_WEP:
                Serial.print("WEP");
                break;
            case WIFI_AUTH_WPA_PSK:
                Serial.print("WPA");
                break;
            case WIFI_AUTH_WPA2_PSK:
                Serial.print("WPA2");
                break;
            case WIFI_AUTH_WPA_WPA2_PSK:
                Serial.print("WPA+WPA2");
                break;
            case WIFI_AUTH_WPA2_ENTERPRISE:
                Serial.print("WPA2-EAP");
                break;
            case WIFI_AUTH_WPA3_PSK:
                Serial.print("WPA3");
                break;
            case WIFI_AUTH_WPA2_WPA3_PSK:
                Serial.print("WPA2+WPA3");
                break;
            case WIFI_AUTH_WAPI_PSK:
                Serial.print("WAPI");
                break;
            default:
                Serial.print("Desconhecido");
            }
            Serial.println();
                // Delete the scan result to free memory for code below.
    WiFi.scanDelete();
        // Wait a bit before scanning again.
        }
      }
      tempo1=0;
    }
    //Tempo de 2s = tempo1 e tempo2
    unsigned long currentMillis = millis();
    if (currentMillis - previousMillis >= 2000) {
      tempo1=1;
      tempo2=1;
    previousMillis = currentMillis;}
    //Fim
  digitalWrite(LedVerdeOn2, LOW); // pulso para baixo concluído
  //
  Serial.printf("\nForça do sinal: %2d dBm ", RSSI);
  int RSSI2;
  RSSI2=RSSI*(-1);
  if (RSSI2<30) {Serial.println(F("Excelente"));}
  else if (RSSI2<55) {Serial.println(F("Muito bom"));}
  else if (RSSI2<67) {Serial.println(F("Bastante bom"));}
  else if (RSSI2<70) {Serial.println(F("Bom"));}
  else if (RSSI2<80) {Serial.println(F("Não é bom"));}
  else if (RSSI2<90) {Serial.println(F("Extremamente fraco"));} 
  else  {Serial.println(F("Inutilizável"));}
  //Checa o tocador de áudio
  if (tempo2==1) {
  if (myDFPlayer.available()) {
    printDetail(myDFPlayer.readType(), myDFPlayer.read()); //Print the detail message from DFPlayer to handle different errors and states.
    tempo2=0;
  }}

  mesh.update(); // it will run the user scheduler as well
}

// Montagem da mensagem
void MontagemMensagem (){
  mensagem = id; //id do remetente. Endereço do Mestre (0). Começo da montagem do mensagem
  mensagem = mensagem + 'X' + destinatario;  //Destinatário. "255" envia para todos executarem
  mensagem = mensagem + 'Y' + tipo; // 0=Acionamento do alarme geral; 1=Acionamento; 2=Desligamento; 3=Informação; 4=Não Desligar; 5=Habilitar Desligar
                              //6=Mensagem lida; 7=Alterar endereço (Endereço 999 é de fábrica). 
  mensagem = mensagem + 'A' + digitalRead(14);   // Sensor atuado read the input pino 7 = IN1
  mensagem = mensagem + 'B' + digitalRead(22) + 'C' + digitalRead(36) + 'D' + digitalRead(23) + 'E' + digitalRead(19);
  mensagem = mensagem + 'F' + digitalRead(18) + 'G' + digitalRead(21) + 'H' + Alarme + 'I' + LedVermelho;
  mensagem = mensagem + 'J' + Out6 + 'L' + Out7 + 'M' + Out8 + 'N' + Out9;
  mensagem = mensagem + 'O' + String(leituraTensaoPilhasVolts,3) + 'P' + String(leituraTensaoPlacaControleVolts,3) + 'Q' + String(leituraTensaoBateriaExternaVolts,3);
  mensagem = mensagem + 'R' + AnIn4 + 'S' + AnIn5 + 'T' + AnIn6 + 'U' + AnOu1 + 'V' + AnOu2 + 'X' + RSSI + 'Z' + novoid + 'a' + menorRSSI + 'b' + maiorRSSI; 
  mensagem = mensagem + 'c' + leituraTensaoPilhasPorcentagem + 'd' + leituraTensaoPlacaControlePorcentagem + ':' + MAC;
  Serial.print("\n");
  Serial.println(mensagem);
}

// Desmontagem da mensagem
void DesmontagemMensagem (){  //variáveis: "local"- onde na mensagem; "dado" conteúdo nesse local
  //recebida=mensagem;  //comentar
  remetente = recebida.toInt(); //endereço do remetente
  if ( posicao == ":'"){  // endereço MAC
    local=1;
    cont = recebida.indexOf(":", local);
    dado2 = recebida.substring(cont+1);  //Lembrar que a variável de retorno é "dado2";
  }
  //Entradas e saídas digitais
  else if ( posicao == "A" || posicao == "B" || posicao == "C" || posicao == "D" || posicao == "E" || posicao == "F" || posicao == "G" || posicao == "H" || 
            posicao == "I" || posicao == "J" || posicao == "L" || posicao == "M" || posicao == "N" || posicao == "Z" || posicao == "X" || posicao == "Y" || 
            posicao == "a" || posicao == "b" || posicao == "c" || posicao == "d") { 
    local=1;
    cont = recebida.indexOf(posicao, local);
    dado = recebida.substring(cont+1).toInt();
    }
  else {  //valores analógicos de entrada e saída
  local=1;
  cont = recebida.indexOf(posicao, local);
  dado5 = recebida.substring(cont+1,cont+6).toFloat();
  }
}  //Fim

// Subrotina para desligar tudo instantaneamente
  void AcaoSensorAtuado (){
    digitalWrite(LedVermelho, HIGH); // O pino é acionado
    digitalWrite(Alarme, LOW); // O pino é acionado
    tipo=0;  //acionamento das sirenes e led vermelho
    destinatario=255;  //comando executado por todos
    if (data!=dataRelatorio1 && data!=dataRelatorio2 && data!=dataRelatorio3) { contData=contData+1;}
    if (contData>3) { contData=0; }
    MontagemMensagem();
}

//Indicação de falhas
void printDetail(uint8_t type, int value){
  switch (type) {
    case TimeOut:
      Serial.println(F("Time Out!"));
      break;
    case WrongStack:
      Serial.println(F("Stack Wrong!"));
      break;
    case DFPlayerCardInserted:
      Serial.println(F("Card Inserted!"));
      break;
    case DFPlayerCardRemoved:
      Serial.println(F("Card Removed!"));
      break;
    case DFPlayerCardOnline:
      Serial.println(F("Card Online!"));
      break;
    case DFPlayerUSBInserted:
      Serial.println("USB Inserted!");
      break;
    case DFPlayerUSBRemoved:
      Serial.println("USB Removed!");
      break;
    case DFPlayerPlayFinished:
      Serial.print(F("Number:"));
      Serial.print(value);
      Serial.println(F(" Play Finished!"));
      break;
    case DFPlayerError:
      Serial.print(F("DFPlayerError:"));
      switch (value) {
        case Busy:
          Serial.println(F("Card not found"));
          break;
        case Sleeping:
          Serial.println(F("Sleeping"));
          break;
        case SerialWrongStack:
          Serial.println(F("Get Wrong Stack"));
          break;
        case CheckSumNotMatch:
          Serial.println(F("Check Sum Not Match"));
          break;
        case FileIndexOut:
          Serial.println(F("File Index Out of Bound"));
          break;
        case FileMismatch:
          Serial.println(F("Cannot Find File"));
          break;
        case Advertise:
          Serial.println(F("In Advertise"));
          break;
        default:
          break;
      }
      break;
    default:
      break;
  }
  
}

// Event Occurs when response comes from HMI
void onHMIEvent(String address, int lastByte, String messege, String response){  
  Serial.println("OnEvent : [ A : " + address + " | D : "+ String(lastByte, HEX)+ " | M : "+messege+" | R : "+response+ " ]"); 
  if (address == "1002"){
  // Take your custom action call
  }
}

//**Núcleo 0
void Taskloop2( void * pvParameters ) {  //Relativo as atividades do processo - Núcleo 0

  for (;;){

      esp_task_wdt_reset();
      int i; //usado para mapear dispostivos
      //gerando data do relatório e data dos acionamentos (3 datas diferentes), "contData" fica no void AcaoSensorAtuado ()
      data = dia + '/' + mes + '/' + ano;
      dataRelatorio=data;
      if (contData==1) { dataRelatorio1=data; }
      if (contData==2) { dataRelatorio2=data; }
      if (contData==3) { dataRelatorio3=data; } 
      //Fim
      //Tratativas sobre acionamento as saídas de acordo com a mensagem recebida
      posicao="X"; //verificar o destinatário
      DesmontagemMensagem();
      destinatario=dado; //informação recuperada da mensagem
      //Checar tipo da informação
      posicao="Y"; //tipo da informação
      DesmontagemMensagem();
      if (tipo==0 && destinatario==255) {  // 0-acionamento do alarme geral, idRemetente=255 - Acionamento em todos os nodes
        digitalWrite(LedVermelho, HIGH); // O pino Led Vermelho
        digitalWrite(Alarme, LOW); // O pino da sirene acionado
        //registra a data dos acionamentos/testes
        if (data=dataRelatorio1)
        dataRelatorio1=data;
      }
      if (tipo==2 && destinatario==255) {  // 2-Desliga saídas, idRemetente=255 - Acionamento em todos os nodes
        digitalWrite(LedVermelho, LOW); // O pino Led Vermelho
        digitalWrite(Alarme, HIGH); // O pino da sirene acionado
      }
      if (tipo==6 && destinatario==0) {  // 6-Mensagem recebida, idRemetente=0 - Mestre
        digitalWrite(LedVerdeOn, LOW); // Deixa o led verde piscando e o religamento programado
        delay(100);
        digitalWrite(LedVerdeOn, HIGH); // pulso para baixo concluído
        digitalWrite(Desliga, LOW); // Desliga a placa do microcontrolador para economizar energia - Precisa 2N7000
        delay(2000);
      }

      //MONTAR LÓGICA PARA ALTERAR ENDEREÇO DE DISPOSITIVOS NOVOS OU CONFLITANTES
      posicao= ":"; //puxa o endereço MAC
      DesmontagemMensagem();
      String MACremetente;
      MACremetente=dado2;
      posicao= "A";
      DesmontagemMensagem();
      if (dado==1) { void AcionadorSensorAtuado();}
      //i = remetente.toInt()  // Transforma "rementente" tipo "char" para "int"
      if (remetente == 999 || remetente == 0)
      {
        tipo=7;
        novoid=101; // IMPORTANTE: mudar quando a programação da IHM estiver pronto
        MontagemMensagem (); //OBS: FAZER LÓGICA PARA ENVIAR MENSAGEM COM novoid APÓS SELEÇÃO NA IHM
      }
      else {
        i=remetente;
        Xi=dispositivo[i][0];
        int Xi2;
        Xi2=Xi.toInt();
        //i=dispositivo.toInt;
        if (i == Xi2) { //verifica se a identificação do dispositivo (remetente) já existe
          Serial.println(F("Remetente cadastrado"));}
           //enviar notificação pela IHM para fazer identificação e cadastro
          else { 
            //enviar notificação pela IHM para fazer identificação e cadastro
            dispositivo[i][0]=remetente;
          }
        }
      //Fim
      //Gerar a matriz de cadastro dos dispositivos na SRAM
      esp_task_wdt_reset();
      for (i = 0; i < NumeroDispositivos; i++) {
        //Serial.println("NOVO DISPOSITIVO");
        dispositivo[i][0]=remetente;
        if (dispositivo[i][0]!=0) {dispositivosCadastrados ++;}
          for (int n =0 ; n < InformacaoDispositivos; n++) {
          //Serial.println(dispositivo[i][n]);
          if (n==1) { dispositivo[i][n]=tipoDispositivo; }
          else if (n==2) { dispositivo[i][n]=marcaDispositivo; }
          else if (n==3) { dispositivo[i][n]=modeloDispositivo; }         
          else if (n==4) { dispositivo[i][n]=localizacaoDispositivo; }
          else if (n==5) { dispositivo[i][n]=dataRelatorio; }
          else if (n==6) { dispositivo[i][n]=estadoFuncionamento; }
          else if (n==7) { dispositivo[i][n]=dataRelatorio1; }
          else if (n==8) { dispositivo[i][n]=dataRelatorio2; }
          else if (n==9) { dispositivo[i][n]=dataRelatorio3; }
          else if (n==10) { posicao="O"; DesmontagemMensagem(); dispositivo[i][n]=dado5; }
          else if (n==11) { posicao="P"; DesmontagemMensagem(); dispositivo[i][n]=dado5; }
          else if (n==12) { posicao="Q"; DesmontagemMensagem(); dispositivo[i][n]=dado5; }
          else if (n==13) { posicao="a"; DesmontagemMensagem(); dispositivo[i][n]=dado5; }
          else if (n==14) { posicao="b"; DesmontagemMensagem(); dispositivo[i][n]=dado5; }
          else if (n==15) { posicao="c"; DesmontagemMensagem(); dispositivo[i][n]=dado5; }
          else if (n==16) { posicao="d"; DesmontagemMensagem(); dispositivo[i][n]=dado5; }
          if (dispositivo[i][0]==0) {Serial.println("Nenhum dispositivo cadastrado");}
        }
      }
      //Fim checar tipo da informação mais prioritárias
      //Fim tratativa de acionamento
      //Leitura da tensão das baterias
      do {
          int leitura = analogRead(TensaoPilhas); // Faz a leitura do sensor
          somaLeitura = somaLeitura+leitura;
          cont2++;
          delay(1);
      } while (cont2<=19);
      cont2=0;
      leituraTensaoPilhas=somaLeitura/20; // Tira a média a cada vinte leituras da umidade
      leituraTensaoPilhasVolts = (float)leituraTensaoPilhas/1000.0;
      leituraTensaoPilhasPorcentagem = map(leituraTensaoPilhas, ValorBaixoPilhas, ValorAltoPilhas, 0 , 100);
      //Fim
      somaLeitura=0;
      //Leitura da tensão da placa de controle
      do {
          int leitura = analogRead(TensaoPlacaControle); // Faz a leitura do sensor
          somaLeitura = somaLeitura+leitura;
          cont2++;
          delay(1);
      } while (cont2<=19);
      cont2=0;
      leituraTensaoPlacaControle=somaLeitura/20; // Tira a média a cada vinte leituras da umidade
      leituraTensaoPlacaControleVolts = (float)leituraTensaoPlacaControle/1000.0;
      leituraTensaoPlacaControlePorcentagem = map(leituraTensaoPlacaControle, ValorBaixoPlacaControle, ValorAltoPlacaControle, 0 , 100);
      somaLeitura=0;
      //Fim
      //Checa se há falha na alimentação e salva os parâmetros dos dispositivos na memória flash
      if(leituraTensaoPilhasVolts <= 11 && flag1 ==1) { salvarParametrosEEPROM(); }
      //Fim
      //Dados da CPU e memória
      Serial.println(ESP.getFreeHeap());  //retorna tamanho da memória livre SRAM
      Serial.println(ESP.getCpuFreqMHz()); //
      Serial.println(ESP.getSketchSize());  //tamanho do esboço atual
      Serial.println(ESP.getFreeSketchSpace()); //Retorna o espaço de esboço livre
      Serial.println(ESP.getFlashChipSize());  //tamanho flash
      Serial.println(ESP.getFlashChipSpeed()); //Hz
      //
      MontagemMensagem();
      }
vTaskDelete(NULL); // esta função dentro do loop()
}

      //Salva parâmetros antes da falha na alimentação
      void salvarParametrosEEPROM () {
        esp_task_wdt_reset();
        enderecoEEPROM=0;
        flag1=0;
        Xi.remove(0);  //apaga o conteúdo da mensagem Xi
      //Lê dispositivos cadastrados e salva na memória flase      
      for (int i =0; i< NumeroDispositivos; i++) {
        Xi=dispositivo[i][0]; EEPROM.writeString(enderecoEEPROM, Xi); enderecoEEPROM += Xi.length()+1;
        if (dispositivo[i][0]!=0) {dispositivosCadastrados ++;}
        for (int n = 0; n < 9; n++) {
          Xi=dispositivo[i][n]; EEPROM.writeString(enderecoEEPROM, Xi); enderecoEEPROM += Xi.length()+1;
            //if (dispositivo[i][0]==0) {Serial.println("Nenhum dispositivo cadastrado");}
        }
      }
      Serial.println(F("Matriz de dispositivos salvos na memória flash\n"));
      Serial.printf("Num total de %d\n", dispositivosCadastrados);

      EEPROM.writeInt(enderecoEEPROM, contData);            
      enderecoEEPROM += sizeof(int);
      }

      //Recupera parâmetros antes da falha na alimentação
      void recuperarParametrosEEPROM () {
        esp_task_wdt_reset();
        enderecoEEPROM=0;
        flag1=0;
        Xi.remove(0);  //apaga o conteúdo da mensagem Xi
      //Lê dispositivos cadastrados e salva na memória flase      
      for (int i =0; i< NumeroDispositivos; i++) {
        dispositivo[i][0]=Serial.println(EEPROM.readString(enderecoEEPROM)); enderecoEEPROM += Xi.length()+1;
        if (dispositivo[i][0]!=0) {dispositivosCadastrados ++;}
        for (int n = 0; n < 9; n++) {
          dispositivo[i][n]=Serial.println(EEPROM.readString(enderecoEEPROM)); enderecoEEPROM += Xi.length()+1;
            //if (dispositivo[i][0]==0) {Serial.println("Nenhum dispositivo cadastrado");}
        }
      }
      Serial.println(F("Matriz de dispositivos recuperados da memória flash\n"));
      Serial.printf("Num total de %d\n", dispositivosCadastrados);

      contData = (EEPROM.readInt(enderecoEEPROM));  //usado na organização das datas de registros dos acionamentos
      }

    //Informações da CPU
    void InforamacaoCPU () {

    //
    }