MeshServerV 11

//=============================( INCLUINDO DEFININDO E CONFIGURANDO BIBLIOTECAS )=============================
//#define Debug
#define   LED  2                                      // GPIO number of connected LED, ON ESP-12 IS GPIO2
#define   bot  4                                      // GPIO botao, ON ESP-12 IS GPIO4

#include "setting.h"
#include "IPAddress.h"
#include "painlessMesh.h"

#ifdef ESP8266
#include "Hash.h"
#include <ESPAsyncTCP.h>
#else
#include "SPIFFS.h"
#include <AsyncTCP.h>
#endif
#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"

void receivedCallback( const uint32_t &from, const String &msg );

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      )=============================
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
bool existe = 0;                                      // Controle de no na matriz
int qtdeNos = 0;                                      // Nos identificados na rede
bool stLED = 1;                                       // Status do LED  1 = Ligado
//----------------------------------------------------------
void listaNodes()
{
nodes = mesh.getNodeList();
  SimpleList<uint32_t>::iterator node = nodes.begin();
  while (node != nodes.end()) {
    Serial.printf(" %u", *node);
    node++;
  }
  Serial.println(" ");
}
//=============================(   VOID SETUP CONFIGURANDO SOFTWARE E HARDWARE  )=============================
void setup() {
  for (int i = 0; i < 16; i++)                        // Carrega vago em toda a matriz dos nos
  {
    nodMAC[i][0] = "vago";
  }
  Serial.begin(115200);
  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());

  uint32_t  myID =  mesh.getNodeId();
  String 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 += "*";                                      // EOM
  qtdeNos++;
  extraiDados(myID, master);

  carregaPagina();

  /*
    mesh.onNewConnection([](size_t nodeId) {
      Serial.printf("New %u\n", nodeId);
    });

    mesh.onDroppedConnection([](size_t nodeId) {
      Serial.printf("Drop %u\n", nodeId);
    });
  */
}
//=============================(      VOID LOOP ROTINA PRINCIPAL DO SISTEMA     )=============================
void loop() {
  mesh.update();
  if (myIP != getlocalIP()) {
    myIP = getlocalIP();
    Serial.println("My 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;
}
//===============( VOID receivedCallback RETORNA O ID E A MENSSAGEM DO NÓ ENVIADA PARA O ROOT )==============
void receivedCallback( const uint32_t &from, const String &msg ) {
  extraiDados(from, msg);
}
//------------------------------------------------------------------
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.toUpperCase();                                // Maiusculas
  String b0, b1, b2, b3 = " " ;                       // variaveis de trabalho
  b0 = nodID.substring(0, 2);                         // Separa os bytes
  b1 = nodID.substring(2, 4);
  b2 = nodID.substring(4, 6);
  b3 = nodID.substring(6, 8);
  nodID = b0 + ": " + b1 + ": " + b2 + ": " + b3;     // Junta no formato  XX:XX:XX:XX

  for (int 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 (int 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
}
//===============================(   FUNÇÃO QUE REQUISITA O IP MESH DO ROOT   )==============================
IPAddress getlocalIP() {
  return IPAddress(mesh.getStationIP());
}
//===========( VOID carregaPagina SERVE AS FOLHAS HTML JQUERY BOOTSTRAP E JAVASCRIPT PARA O CLIENT )==========
void carregaPagina() {
  //--------------------(   SERVE O ARQUIVO index.htm    )--------------------//
  server.on("/htm", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, "/index.htm", "text/html");
        listaNodes();
  });

  //--------------------(  SERVE O ARQUIVO javascript.js )--------------------//
  server.on("/javascript.js", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, "/javascript.js", "application/javascript.js");
  });

  //------------------( SERVE O ARQUIVO jquery-3.3.1.min.js )-----------------//
  server.on("/jquery-3.3.1.min.js", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, "/jquery-3.3.1.min.js", "application/javascript.js");
  });

  //------------------(   SERVE O ARQUIVO bootstrap.min.js  )-----------------//
  server.on("/bootstrap.min.js", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, "/bootstrap.min.js", "application/javascript.js");
  });

  //-----------------(   SERVE O ARQUIVO bootstrap.min.css  )-----------------//
  server.on("/bootstrap.min.css", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, "/bootstrap.min.css", "text/css");
  });

  //-----------------(   SERVE O ARQUIVO bootstrap.min.css  )-----------------//
  server.on("/estilo.css", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send(SPIFFS, "/estilo.css", "text/css");
  });

  //---------------------(      SERVE O ARQUIVO teste      )------------------//
  server.on("/teste", HTTP_GET, [](AsyncWebServerRequest * request) {
    payLoad = "";                                     // Limpa a mensagem da tela
    for ( int i = 0; i <= qtdeNos; i++) {
      payLoad += nodMAC[i][0];
      payLoad += "|";
      payLoad += nodMAC[i][1];
      payLoad += "|1|0|";
      payLoad += nodMAC[i][4];
      payLoad += "|";
      payLoad += nodMAC[i][5];
      if (i < qtdeNos)
        payLoad += "*";
    }
    request->send(200, "text / plain", payLoad);
  });
  //--------------------(      SERVE O ARQUIVO ligarLed      )----------------//
  server.on("/ligarLed", HTTP_GET, [](AsyncWebServerRequest * request) {
    if (request->hasArg("btnRoot")) {                 // No root
      digitalWrite(LED, !digitalRead(LED));           // Inverte status do LED
      String 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 += "*";                                  // EOM
      refresh(master, 0);                             // Refresh nos parametros
    }
    if (request->hasArg("btnNode1")) {                // Primeiro no
      String msg = request->arg("btnNode1");
      msg += mesh.getNodeId();
      msg += " 1";
      uint32_t node = nodMAC[1][11].toInt();          // Identifica MAC do no
      mesh.sendSingle(node, msg);                     // Envia msg para o no
    }
    if (request->hasArg("btnNode2")) {                // Segundo no
      String msg = request->arg("btnNode2");
      msg += mesh.getNodeId();
      msg += " 1";
      uint32_t node = nodMAC[2][11].toInt();          // Identifica MAC do no
      mesh.sendSingle(node, msg);                     // Envia msg para o no
    }

    request->send(200, "text / plain", payLoad);
  });
  server.begin();
}
//------------------------------------------------------------------
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][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
  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][11] = String(from);                       // Salva MAC integral
  listaMatris();                                      // Lista para Debug
}
//------------------------------------------------------------------
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
  listaMatris();                                      // Lista para Debug
}
//------------------------------------------------------------------
void listaMatris()                                    // Lista matriz de nos
{
#ifdef Debug
  for (int i = 0; i < 16; i++) {                      // Matriz de 0 a 15
    if ((nodMAC[i][0]) == "vago") {                   // Testa s está vago
      Serial.println(" ");                            // Imprime
      break;                                          // Se for vago sai do for
    }
    for (int j = 0; j < 12; j++) {                    // Elemento de 0 a 11
      Serial.print(nodMAC[i][j]);                     // Imprime
    }
    Serial.println(" ");                              // Imprime
  }
#endif
}