MeshServerV10.ino

//=============================( INCLUINDO DEFININDO E CONFIGURANDO BIBLIOTECAS )=============================
#define Debug
#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 );
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
//=============================(   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);

  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.onChangedConnections(&changedConnectionCallback);
  mesh.setHostname(HOSTNAME);
  myAPIP = IPAddress(mesh.getAPIP());

  Serial.println("My AP IP is " + myAPIP.toString());

  uint32_t  myID =  mesh.getNodeId();
//  Serial.println(myID);

  String msg = "|1|";       // ESP model ESP8266 = 0 ESP32 = 1
  msg += "1|";              // status ESP
  msg += "1|";              // Bot
  msg += "0";               // Status LED
  msg += "|";               // Sepaarador
  msg += "1020";    // Valor analogico
  msg += "*";               // EOM

  qtdeNos++;

  extraiDados(myID, msg);

  carregaPagina();
}
//=============================(      VOID LOOP ROTINA PRINCIPAL DO SISTEMA     )=============================
void loop() {
  mesh.update();
  if (myIP != getlocalIP()) {
    myIP = getlocalIP();
    Serial.println("My IP is " + myIP.toString());
  }
}
//===============( 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)
{
  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
      }
      else
        Serial.print("Buffer cheio");
    }
  }
  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");
  });

  //--------------------(  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 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")) {
    }
    if (request->hasArg("btnNode1")) {
      String msg = request->arg("btnNode1");
      msg += mesh.getNodeId();
      msg += " 1";
      uint32_t node = nodMAC[1][11].toInt();
      mesh.sendSingle(node, msg);
    }
    if (request->hasArg("btnNode2")) {
      String msg = request->arg("btnNode2");
      msg += mesh.getNodeId();
      msg += " 1";
      uint32_t node = nodMAC[2][11].toInt();
      mesh.sendSingle(node, msg);
    }

    request->send(200, "text / plain", payLoad);
  });
  server.begin();
}
//------------------------------------------------------------------
void selectMAC( uint32_t from, String msg, uint8_t i)
{
  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";
  else                                                // Se for 1 é ESP32
    nodMAC[i][1] =  "ESP32";
  nodMAC[i][11] = String(from);
  listaMatris();
}
//------------------------------------------------------------------
void refresh(String msg, uint8_t i)
{
  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();
}
//------------------------------------------------------------------
void changedConnectionCallback() {
  Serial.println("Houve aleracao");
}
//------------------------------------------------------------------
void listaMatris()
{
#ifdef Debug
  for (int i = 0; i < 16; i++) {                      // Matriz de 0 a 15
    if ((nodMAC[i][0]) == "vago") {
      Serial.println(" ");
      //break;
    }
    for (int j = 0; j < 12; j++) {                    // Elemento de 0 a 11
      Serial.print(nodMAC[i][j]);                     // Imprime
    }

    Serial.println(" ");
  }
#endif
}