PainLessMesh_Duo.ino

int count  = 0;
int blinked = 0;

//variaveis que indicam o núcleo
static uint8_t taskCoreZero = 0;
static uint8_t taskCoreOne  = 1;

//------------( INCLUINDO DEFININDO E CONFIGURANDO BIBLIOTECAS )
#include "setting.h"
#include <painlessMesh.h>
#include <SPIFFS.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
//------------( CONFIGURANDO SSID, PASSWORD E PORT DA REDE MESH )
#define   MESH_PREFIX     "whateverYouLike"
#define   MESH_PASSWORD   "somethingSneaky"
#define   MESH_PORT       5555
//--------( CONFIGURANDO SSID, PASSWORD E NOME DO HOST DA REDE WIFI )
#define   STATION_SSID     ssid
#define   STATION_PASSWORD password
#define   HOSTNAME "HTTP_BRIDGE"
#define   LED  2                                      // GPIO number of connected LED, ON ESP-12 IS GPIO2
#define   bot  4                                      // GPIO botao, ON ESP-12 IS GPIO4
SimpleList<uint32_t> nodes;
IPAddress getlocalIP();
painlessMesh  mesh;
AsyncWebServer server(80);
IPAddress myIP(0, 0, 0, 0);
IPAddress myAPIP(0, 0, 0, 0);
//------------( (     DECLARA VARIAVEIS GLOBAIS DE SISTEMA      )
uint32_t  myID;                                       // MAC do root
String payLoad = "";                                  // String de js
String nodID = "";                                    // Identificacao do no da rede mesh
String nodMAC[16][12];                                // Matriz para guardar os MACs em HEX e parametros
uint32_t onlyMAC[16];                                 // Matriz para guardar os MACs em HEX
uint32_t numero[] = {3289255477, 2133650233, 887620719, 887631948, 2143346377, 2483971700, 2484121542} ;
String local[] = {"Root", "Sala", "Quarto1", "Quarto2", "Quarto3", "Cozinha", "Varanda"};
bool existe = 0;                                      // Controle de no na matriz
int16_t qtdeNos = -1;                                 // Nos identificados na rede -1 para que qdo ident root fica 0
bool stLED = 1;                                       // Status do LED  1 = Ligado
String master;                                        // String pa montar msg
String nodeMatrix[] = {"btnNode1", "btnNode2", "btnNode3"};

int encontrou ;
int jota ;
//----------------------------------------------------------
void listaNodes()
{
  for (uint16_t i = 1; i < 16; i++)
  {
    nodMAC[i][2] = "0";                               // Zera status de todos no's
  }
  String listNodID;
  nodes = mesh.getNodeList();
  SimpleList<uint32_t>::iterator node = nodes.begin();
  while (node != nodes.end()) {
    //Serial.println(*node);
    listNodID = separaDados(String(*node, HEX));

    node++;
    for (uint16_t i = 1; i < 16; i++) {                   // Matriz de 0 a 15
      if (listNodID == nodMAC[i][0]) {                    // Verifica se ja registrou o MAC do no
        {
          nodMAC[i][2] = "1";                             // Se registrou, informa presenca do no'
        }
        break;                                            // Sai do for
      }
    }
  }
  Serial.print("listaNodes "); Serial.println(xPortGetCoreID());
}
//--------------------------------------------------------------
String separaDados(String dataNode )
{
  dataNode.toUpperCase();                                 // Maiusculas
  String b0, b1, b2, b3 = " " ;                           // variaveis de trabalho
  b0 = dataNode.substring(0, 2);                          // Separa os bytes
  b1 = dataNode.substring(2, 4);
  b2 = dataNode.substring(4, 6);
  b3 = dataNode.substring(6, 8);
  dataNode = b0 + ": " + b1 + ": " + b2 + ": " + b3;      // Junta no formato  XX:XX:XX:XX
  Serial.print("separaDados "); Serial.println(xPortGetCoreID());
  return dataNode;
}
//--------------------------------------------------------------
void montaLocal()
  {
  WiFi.begin(ssid, password);
  WiFi.config(IPAddress(192, 168, 0, 60), IPAddress(192, 168, 0, 1), IPAddress(255, 255, 255, 0)); // Idem
  Serial.println("");                                       // Imprime
  while (WiFi.status() != WL_CONNECTED)                     // Aguarda conexão
  {
    delay(500);                                             // Delay
    Serial.print(".");                                      // Imprime . enquanto não conecta
  }
  Serial.println("");                                       // Imprime
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  Serial.print("montaLocal "); Serial.println(xPortGetCoreID());
  }
//--------------------------------------------------------------
void setup() {
  Serial.begin(115200);

  for (uint16_t i = 0; i < 16; i++)                       // Carrega vago em toda a matriz dos nos
  {
    nodMAC[i][0] = "vago";                                // Limpa a matriz
  }

  pinMode(LED, OUTPUT);
  pinMode(bot, INPUT_PULLUP);
  if (!SPIFFS.begin()) {
    Serial.println("An Error has occurred while mounting SPIFFS");
    return;
  }
  //---------------( CONFIGURANDO E INICIALIZANDO A REDE MESH )
  mesh.init( MESH_PREFIX, MESH_PASSWORD, MESH_PORT, WIFI_AP_STA, 6 );
  mesh.onReceive(&receivedCallback);
  mesh.stationManual(STATION_SSID, STATION_PASSWORD);
  mesh.setHostname(HOSTNAME);
  myAPIP = IPAddress(mesh.getAPIP());
  Serial.println("My AP IP is " + myAPIP.toString());
  myID   =  mesh.getNodeId();                                     // Obtem o ID do root
  montaPacote();
  extraiDados(myID, master);
  carregaPagina();
  Serial.print("setup "); Serial.println(xPortGetCoreID());

  //cria uma tarefa que será executada na função coreTaskZero, com prioridade 1 e execução no núcleo 0
  xTaskCreatePinnedToCore(
    coreTaskZero,   /* função que implementa a tarefa */
    "coreTaskZero", /* nome da tarefa */
    10000,      /* número de palavras a serem alocadas para uso com a pilha da tarefa */
    NULL,       /* parâmetro de entrada para a tarefa (pode ser NULL) */
    1,          /* prioridade da tarefa (0 a N) */
    NULL,       /* referência para a tarefa (pode ser NULL) */
    taskCoreZero);         /* Núcleo que executará a tarefa */

  delay(500); //tempo para a tarefa iniciar

  //cria uma tarefa que será executada na função coreTaskOne, com prioridade 2 e execução no núcleo 1
  xTaskCreatePinnedToCore(
    coreTaskOne,   /* função que implementa a tarefa */
    "coreTaskOne", /* nome da tarefa */
    10000,      /* número de palavras a serem alocadas para uso com a pilha da tarefa */
    NULL,       /* parâmetro de entrada para a tarefa (pode ser NULL) */
    0,          /* prioridade da tarefa (0 a N) */
    NULL,       /* referência para a tarefa (pode ser NULL) */
    taskCoreOne);         /* Núcleo que executará a tarefa */
}
//--------------------------------------------------------------
void montaPacote()
{
  master = "|1|";                                         // ESP model ESP8266 = 0 ESP32 = 1
  master += "1|";                                         // status ESP
  master += "1|";                                         // Bot
  master += stLED;                                        // Status LED
  master += "|";                                          // Sepaarador
  master += "1020";                                       // Valor analogico
  master += "*";                                          // End Of Msg
  Serial.print("montaPacote "); Serial.println(xPortGetCoreID());
}
//--------------------------------------------------------------
void loop() {

}
//--------------------( VOID receivedCallback RETORNA O ID E A MENSSAGEM DO NÓ ENVIADA PARA O ROOT )
void receivedCallback( const uint32_t &from, const String &msg ) {
  //  Serial.print("from  "); Serial.print(from); Serial.print("  msg  "); Serial.println(msg);
  extraiDados(from, msg);
  Serial.print("receivedCallback "); Serial.println(xPortGetCoreID());
}
//--------------------------------------------------------------
void extraiDados(uint32_t from, String msg)               // Extrai dados da msg e verifica se existe no na tabela
{
  nodID = String(from, HEX);                              // Transfor from em Strinf no formato HEX
  nodID = separaDados(nodID);
  for (uint16_t i = 0; i < 16; i++) {                     // Matriz de 0 a 15
    if (nodID == nodMAC[i][0]) {                          // Verifica se ja registrou o MAC do no
      existe = 1;                                         // Se tiver, indica
      refresh(msg, i);                                    // Refresh nos parametros
      break;                                              // Sai do for
    }
  }
  if (existe == 0) {                                      // Se nao existe
    for (uint16_t i = 0; i < 16; i++) {                   // Procura uma celula não ocupada = 0xFFFFFFFF
      if (nodMAC[i][0] == "vago")                         // Se encontrou
      {
        selectMAC(from, msg, i);                          // Chama rotina pra transformar valor em HEX
        existe = 1;                                       // Indica que existe
        qtdeNos++;                                        // Invrementa numero de nos
        break;                                            // Sai do for
      }
      if ( i >= 16)                                       // Se não tem posicao livre
        Serial.println("Buffer cheio");                   // imprime
    }
  }
  existe = 0;                                             // Desabilita existe pra permitir proxima pesquisa
  Serial.print("extraiDados "); Serial.println(xPortGetCoreID());
}
//--------------------(   FUNÇÃO QUE REQUISITA O IP MESH DO ROOT   )
IPAddress getlocalIP() {
  return IPAddress(mesh.getStationIP());
  Serial.print("listaNodes "); Serial.println(xPortGetCoreID());
}
//--------------------( VOID carregaPagina SERVE AS FOLHAS HTML JQUERY BOOTSTRAP E JAVASCRIPT PARA O CLIENT )
void carregaPagina() {
  server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {                 // SERVE O ARQUIVO index.htm
    request->send(SPIFFS, "/index.htm", "text/html");
  });
  server.on("/javascript.js", HTTP_GET, [](AsyncWebServerRequest * request) {       // SERVE O ARQUIVO javascript.js
    request->send(SPIFFS, "/javascript.js", "application/javascript.js");
  });
  server.on("/jquery-3.3.1.min.js", HTTP_GET, [](AsyncWebServerRequest * request) { // SERVE O ARQUIVO jquery-3.3.1.min.js
    request->send(SPIFFS, "/jquery-3.3.1.min.js", "application/javascript.js");
  });
  server.on("/bootstrap.min.js", HTTP_GET, [](AsyncWebServerRequest * request) {    // SERVE O ARQUIVO bootstrap.min.js
    request->send(SPIFFS, "/bootstrap.min.js", "application/javascript.js");
  });
  server.on("/bootstrap.min.css", HTTP_GET, [](AsyncWebServerRequest * request) {   // SERVE O ARQUIVO bootstrap.min.css
    request->send(SPIFFS, "/bootstrap.min.css", "text/css");
  });
  server.on("/estilo.css", HTTP_GET, [](AsyncWebServerRequest * request) {          // SERVE O ARQUIVO bootstrap.min.css
    request->send(SPIFFS, "/estilo.css", "text/css");
  });
  server.on("/lerDados", HTTP_GET, [](AsyncWebServerRequest * request) {               // SERVE O ARQUIVO teste
    listaNodes();
    payLoad = "";                                                                   // Limpa a mensagem da tela
    for ( uint16_t i = 0; i <= qtdeNos; i++) {
      for (int j = 0; j < 7; j++)
      {
        if (onlyMAC[i] == numero[j])
        {
          encontrou = 1;
          jota = j;
        }
      }
      if  (encontrou == 1)
      {
        payLoad += local[jota];
        encontrou = 0;
      }
      else
        payLoad += onlyMAC[i];
      payLoad += "|";
      payLoad += nodMAC[i][1];
      payLoad += "|";
      payLoad += nodMAC[i][2];
      payLoad += "|0|";
      payLoad += nodMAC[i][4];
      payLoad += "|";
      payLoad += nodMAC[i][5];
      if (i < qtdeNos)
        payLoad += "*";
    }
    request->send(200, "text / plain", payLoad);
  });
  server.on("/ligarLed", HTTP_GET, [](AsyncWebServerRequest * request) {            // SERVE O ARQUIVO ligarLed
    if (request->hasArg("btnRoot")) {                 // No root
      digitalWrite(LED, !digitalRead(LED));           // Inverte status do LED
      montaPacote();
      refresh(master, 0);                             // Refresh nos parametros
    }
    if (request->hasArg("btnNode1")) {                // Primeiro no
      //    if (request->hasArg(*nodeMatrix[1])) {                // Primeiro no
      buscaNode( 1);
    }
    if (request->hasArg("btnNode2")) {                // Segundo no
      buscaNode( 2);
    }
    if (request->hasArg("btnNode3")) {                // Terceiro no
      buscaNode( 3);
    }
    if (request->hasArg("btnNode4")) {                // Quarto no
      buscaNode( 4);
    }
    if (request->hasArg("btnNode5")) {                // Quinto no
      buscaNode( 5);
    }
    if (request->hasArg("btnNode6")) {                // Sexto no
      buscaNode( 6);
    }
    request->send(200, "text / plain", payLoad);
  });
  server.begin();
  Serial.print("carregaPagina "); Serial.println(xPortGetCoreID());
}
//--------------------------------------------------------------
void buscaNode(uint16_t i)
{
  String msg;                                         // String para montar a msg
  msg += myID;                                        // Adiciona o ID do root na msg
  msg += " 1";                                        // Liga/Desliga o LED
  uint32_t node = onlyMAC[i];                         // Seleciona o node da tabela selecionada pelo indece i
  mesh.sendSingle(node, msg);                         // Envia msg para o no
  Serial.print("buscaNode "); Serial.println(xPortGetCoreID());
}
//--------------------------------------------------------------
void selectMAC( uint32_t from, String msg, uint8_t i) // Seleciona e salva valores recebidos de um novo no
{
  nodMAC[i][0] = nodID;
  nodMAC[i][1] = msg.substring(1, 2);                 // Separa o valor do modelo do ESP
  if (nodMAC[i][1] == "0")                            // Se for 0 é ESP3266
    nodMAC[i][1] = "ESP8266";                         // Salva ESP8266
  else                                                // Se for 1 é ESP32
    nodMAC[i][1] =  "ESP32";                          // Salva ESP32
  nodMAC[i][2] = msg.substring(3, 4);                 // Status do no'
  nodMAC[i][4] = msg.substring(7, 8);                 // Separa o valor do status do LED
  nodMAC[i][5] = msg.substring(9, 13);                // Separa o valor analog
  nodMAC[i][5] = nodMAC[i][5].toInt();                // Remove o * do final se for mmeno que 4 digitos
  onlyMAC[i] = from;                                  // Salva MAC integral
  Serial.print("selectMAC "); Serial.println(xPortGetCoreID());
}
//--------------------------------------------------------------
void refresh(String msg, uint8_t i)                   // Atualiza os valores de parametro de um no
{
  nodMAC[i][4] = msg.substring(7, 8);                 // Separa o valor do status do LED
  nodMAC[i][5] = msg.substring(9, 13);                // Separa o valor analog
  nodMAC[i][5] = nodMAC[i][5].toInt();                // Remove o * do final se for mmeno que 4 digitos
  Serial.print("refresh "); Serial.println(xPortGetCoreID());
}
//-----------------------------------------------------------------------
//essa função ficará mudando o estado do led a cada 1 segundo
//e a cada piscada (ciclo acender e apagar) incrementará nossa variável blinked
void coreTaskZero( void * pvParameters ) {
  Serial.print("coreTaskZero "); Serial.println(xPortGetCoreID());
  while (true) {
    mesh.update();
    if (myIP != getlocalIP()) {
      montaLocal();
      myIP = WiFi.localIP();
      Serial.println("My WiFi IP is " + myIP.toString());
    }
    if (digitalRead(bot) == LOW)                            // Se botao esta pressionado
    {
      delay(30);                                            // Debouncing
      if (digitalRead(bot) == LOW)                          // Se botao continua pressionado
      {
        digitalWrite(LED, !digitalRead(LED));               // Inverte status LED
      }
    }
    if (digitalRead(LED) == HIGH)
    {
      stLED = 1;
    }
    else
      stLED = 0;
    delay(200);
  }
}
//-----------------------------------------------------------------------
//essa função será responsável apenas por atualizar as informações no
//display a cada 100ms
void coreTaskOne( void * pvParameters ) {
  Serial.print("coreTaskOne "); Serial.println(xPortGetCoreID());
  while (true) {
    delay(200);
  }
}