RuiViana

PainLessMesh_Duo.ino

Feb 18th, 2019
257
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. int count  = 0;
  2. int blinked = 0;
  3.  
  4. //variaveis que indicam o núcleo
  5. static uint8_t taskCoreZero = 0;
  6. static uint8_t taskCoreOne  = 1;
  7.  
  8. //------------( INCLUINDO DEFININDO E CONFIGURANDO BIBLIOTECAS )
  9. #include "setting.h"
  10. #include <painlessMesh.h>
  11. #include <SPIFFS.h>
  12. #include <AsyncTCP.h>
  13. #include <ESPAsyncWebServer.h>
  14. //------------( CONFIGURANDO SSID, PASSWORD E PORT DA REDE MESH )
  15. #define   MESH_PREFIX     "whateverYouLike"
  16. #define   MESH_PASSWORD   "somethingSneaky"
  17. #define   MESH_PORT       5555
  18. //--------( CONFIGURANDO SSID, PASSWORD E NOME DO HOST DA REDE WIFI )
  19. #define   STATION_SSID     ssid
  20. #define   STATION_PASSWORD password
  21. #define   HOSTNAME "HTTP_BRIDGE"
  22. #define   LED  2                                      // GPIO number of connected LED, ON ESP-12 IS GPIO2
  23. #define   bot  4                                      // GPIO botao, ON ESP-12 IS GPIO4
  24. SimpleList<uint32_t> nodes;
  25. IPAddress getlocalIP();
  26. painlessMesh  mesh;
  27. AsyncWebServer server(80);
  28. IPAddress myIP(0, 0, 0, 0);
  29. IPAddress myAPIP(0, 0, 0, 0);
  30. //------------( (     DECLARA VARIAVEIS GLOBAIS DE SISTEMA      )
  31. uint32_t  myID;                                       // MAC do root
  32. String payLoad = "";                                  // String de js
  33. String nodID = "";                                    // Identificacao do no da rede mesh
  34. String nodMAC[16][12];                                // Matriz para guardar os MACs em HEX e parametros
  35. uint32_t onlyMAC[16];                                 // Matriz para guardar os MACs em HEX
  36. uint32_t numero[] = {3289255477, 2133650233, 887620719, 887631948, 2143346377, 2483971700, 2484121542} ;
  37. String local[] = {"Root", "Sala", "Quarto1", "Quarto2", "Quarto3", "Cozinha", "Varanda"};
  38. bool existe = 0;                                      // Controle de no na matriz
  39. int16_t qtdeNos = -1;                                 // Nos identificados na rede -1 para que qdo ident root fica 0
  40. bool stLED = 1;                                       // Status do LED  1 = Ligado
  41. String master;                                        // String pa montar msg
  42. String nodeMatrix[] = {"btnNode1", "btnNode2", "btnNode3"};
  43.  
  44. int encontrou ;
  45. int jota ;
  46. //----------------------------------------------------------
  47. void listaNodes()
  48. {
  49.   for (uint16_t i = 1; i < 16; i++)
  50.   {
  51.     nodMAC[i][2] = "0";                               // Zera status de todos no's
  52.   }
  53.   String listNodID;
  54.   nodes = mesh.getNodeList();
  55.   SimpleList<uint32_t>::iterator node = nodes.begin();
  56.   while (node != nodes.end()) {
  57.     //Serial.println(*node);
  58.     listNodID = separaDados(String(*node, HEX));
  59.  
  60.     node++;
  61.     for (uint16_t i = 1; i < 16; i++) {                   // Matriz de 0 a 15
  62.       if (listNodID == nodMAC[i][0]) {                    // Verifica se ja registrou o MAC do no
  63.         {
  64.           nodMAC[i][2] = "1";                             // Se registrou, informa presenca do no'
  65.         }
  66.         break;                                            // Sai do for
  67.       }
  68.     }
  69.   }
  70.   Serial.print("listaNodes "); Serial.println(xPortGetCoreID());
  71. }
  72. //--------------------------------------------------------------
  73. String separaDados(String dataNode )
  74. {
  75.   dataNode.toUpperCase();                                 // Maiusculas
  76.   String b0, b1, b2, b3 = " " ;                           // variaveis de trabalho
  77.   b0 = dataNode.substring(0, 2);                          // Separa os bytes
  78.   b1 = dataNode.substring(2, 4);
  79.   b2 = dataNode.substring(4, 6);
  80.   b3 = dataNode.substring(6, 8);
  81.   dataNode = b0 + ": " + b1 + ": " + b2 + ": " + b3;      // Junta no formato  XX:XX:XX:XX
  82.   Serial.print("separaDados "); Serial.println(xPortGetCoreID());
  83.   return dataNode;
  84. }
  85. //--------------------------------------------------------------
  86. void montaLocal()
  87.   {
  88.   WiFi.begin(ssid, password);
  89.   WiFi.config(IPAddress(192, 168, 0, 60), IPAddress(192, 168, 0, 1), IPAddress(255, 255, 255, 0)); // Idem
  90.   Serial.println("");                                       // Imprime
  91.   while (WiFi.status() != WL_CONNECTED)                     // Aguarda conexão
  92.   {
  93.     delay(500);                                             // Delay
  94.     Serial.print(".");                                      // Imprime . enquanto não conecta
  95.   }
  96.   Serial.println("");                                       // Imprime
  97.   Serial.print("Connected to ");
  98.   Serial.println(ssid);
  99.   Serial.print("IP address: ");
  100.   Serial.println(WiFi.localIP());
  101.   Serial.print("montaLocal "); Serial.println(xPortGetCoreID());
  102.   }
  103. //--------------------------------------------------------------
  104. void setup() {
  105.   Serial.begin(115200);
  106.  
  107.   for (uint16_t i = 0; i < 16; i++)                       // Carrega vago em toda a matriz dos nos
  108.   {
  109.     nodMAC[i][0] = "vago";                                // Limpa a matriz
  110.   }
  111.  
  112.   pinMode(LED, OUTPUT);
  113.   pinMode(bot, INPUT_PULLUP);
  114.   if (!SPIFFS.begin()) {
  115.     Serial.println("An Error has occurred while mounting SPIFFS");
  116.     return;
  117.   }
  118.   //---------------( CONFIGURANDO E INICIALIZANDO A REDE MESH )
  119.   mesh.init( MESH_PREFIX, MESH_PASSWORD, MESH_PORT, WIFI_AP_STA, 6 );
  120.   mesh.onReceive(&receivedCallback);
  121.   mesh.stationManual(STATION_SSID, STATION_PASSWORD);
  122.   mesh.setHostname(HOSTNAME);
  123.   myAPIP = IPAddress(mesh.getAPIP());
  124.   Serial.println("My AP IP is " + myAPIP.toString());
  125.   myID   =  mesh.getNodeId();                                     // Obtem o ID do root
  126.   montaPacote();
  127.   extraiDados(myID, master);
  128.   carregaPagina();
  129.   Serial.print("setup "); Serial.println(xPortGetCoreID());
  130.  
  131.   //cria uma tarefa que será executada na função coreTaskZero, com prioridade 1 e execução no núcleo 0
  132.   xTaskCreatePinnedToCore(
  133.     coreTaskZero,   /* função que implementa a tarefa */
  134.     "coreTaskZero", /* nome da tarefa */
  135.     10000,      /* número de palavras a serem alocadas para uso com a pilha da tarefa */
  136.     NULL,       /* parâmetro de entrada para a tarefa (pode ser NULL) */
  137.     1,          /* prioridade da tarefa (0 a N) */
  138.     NULL,       /* referência para a tarefa (pode ser NULL) */
  139.     taskCoreZero);         /* Núcleo que executará a tarefa */
  140.  
  141.   delay(500); //tempo para a tarefa iniciar
  142.  
  143.   //cria uma tarefa que será executada na função coreTaskOne, com prioridade 2 e execução no núcleo 1
  144.   xTaskCreatePinnedToCore(
  145.     coreTaskOne,   /* função que implementa a tarefa */
  146.     "coreTaskOne", /* nome da tarefa */
  147.     10000,      /* número de palavras a serem alocadas para uso com a pilha da tarefa */
  148.     NULL,       /* parâmetro de entrada para a tarefa (pode ser NULL) */
  149.     0,          /* prioridade da tarefa (0 a N) */
  150.     NULL,       /* referência para a tarefa (pode ser NULL) */
  151.     taskCoreOne);         /* Núcleo que executará a tarefa */
  152. }
  153. //--------------------------------------------------------------
  154. void montaPacote()
  155. {
  156.   master = "|1|";                                         // ESP model ESP8266 = 0 ESP32 = 1
  157.   master += "1|";                                         // status ESP
  158.   master += "1|";                                         // Bot
  159.   master += stLED;                                        // Status LED
  160.   master += "|";                                          // Sepaarador
  161.   master += "1020";                                       // Valor analogico
  162.   master += "*";                                          // End Of Msg
  163.   Serial.print("montaPacote "); Serial.println(xPortGetCoreID());
  164. }
  165. //--------------------------------------------------------------
  166. void loop() {
  167.  
  168. }
  169. //--------------------( VOID receivedCallback RETORNA O ID E A MENSSAGEM DO NÓ ENVIADA PARA O ROOT )
  170. void receivedCallback( const uint32_t &from, const String &msg ) {
  171.   //  Serial.print("from  "); Serial.print(from); Serial.print("  msg  "); Serial.println(msg);
  172.   extraiDados(from, msg);
  173.   Serial.print("receivedCallback "); Serial.println(xPortGetCoreID());
  174. }
  175. //--------------------------------------------------------------
  176. void extraiDados(uint32_t from, String msg)               // Extrai dados da msg e verifica se existe no na tabela
  177. {
  178.   nodID = String(from, HEX);                              // Transfor from em Strinf no formato HEX
  179.   nodID = separaDados(nodID);
  180.   for (uint16_t i = 0; i < 16; i++) {                     // Matriz de 0 a 15
  181.     if (nodID == nodMAC[i][0]) {                          // Verifica se ja registrou o MAC do no
  182.       existe = 1;                                         // Se tiver, indica
  183.       refresh(msg, i);                                    // Refresh nos parametros
  184.       break;                                              // Sai do for
  185.     }
  186.   }
  187.   if (existe == 0) {                                      // Se nao existe
  188.     for (uint16_t i = 0; i < 16; i++) {                   // Procura uma celula não ocupada = 0xFFFFFFFF
  189.       if (nodMAC[i][0] == "vago")                         // Se encontrou
  190.       {
  191.         selectMAC(from, msg, i);                          // Chama rotina pra transformar valor em HEX
  192.         existe = 1;                                       // Indica que existe
  193.         qtdeNos++;                                        // Invrementa numero de nos
  194.         break;                                            // Sai do for
  195.       }
  196.       if ( i >= 16)                                       // Se não tem posicao livre
  197.         Serial.println("Buffer cheio");                   // imprime
  198.     }
  199.   }
  200.   existe = 0;                                             // Desabilita existe pra permitir proxima pesquisa
  201.   Serial.print("extraiDados "); Serial.println(xPortGetCoreID());
  202. }
  203. //--------------------(   FUNÇÃO QUE REQUISITA O IP MESH DO ROOT   )
  204. IPAddress getlocalIP() {
  205.   return IPAddress(mesh.getStationIP());
  206.   Serial.print("listaNodes "); Serial.println(xPortGetCoreID());
  207. }
  208. //--------------------( VOID carregaPagina SERVE AS FOLHAS HTML JQUERY BOOTSTRAP E JAVASCRIPT PARA O CLIENT )
  209. void carregaPagina() {
  210.   server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {                 // SERVE O ARQUIVO index.htm
  211.     request->send(SPIFFS, "/index.htm", "text/html");
  212.   });
  213.   server.on("/javascript.js", HTTP_GET, [](AsyncWebServerRequest * request) {       // SERVE O ARQUIVO javascript.js
  214.     request->send(SPIFFS, "/javascript.js", "application/javascript.js");
  215.   });
  216.   server.on("/jquery-3.3.1.min.js", HTTP_GET, [](AsyncWebServerRequest * request) { // SERVE O ARQUIVO jquery-3.3.1.min.js
  217.     request->send(SPIFFS, "/jquery-3.3.1.min.js", "application/javascript.js");
  218.   });
  219.   server.on("/bootstrap.min.js", HTTP_GET, [](AsyncWebServerRequest * request) {    // SERVE O ARQUIVO bootstrap.min.js
  220.     request->send(SPIFFS, "/bootstrap.min.js", "application/javascript.js");
  221.   });
  222.   server.on("/bootstrap.min.css", HTTP_GET, [](AsyncWebServerRequest * request) {   // SERVE O ARQUIVO bootstrap.min.css
  223.     request->send(SPIFFS, "/bootstrap.min.css", "text/css");
  224.   });
  225.   server.on("/estilo.css", HTTP_GET, [](AsyncWebServerRequest * request) {          // SERVE O ARQUIVO bootstrap.min.css
  226.     request->send(SPIFFS, "/estilo.css", "text/css");
  227.   });
  228.   server.on("/lerDados", HTTP_GET, [](AsyncWebServerRequest * request) {               // SERVE O ARQUIVO teste
  229.     listaNodes();
  230.     payLoad = "";                                                                   // Limpa a mensagem da tela
  231.     for ( uint16_t i = 0; i <= qtdeNos; i++) {
  232.       for (int j = 0; j < 7; j++)
  233.       {
  234.         if (onlyMAC[i] == numero[j])
  235.         {
  236.           encontrou = 1;
  237.           jota = j;
  238.         }
  239.       }
  240.       if  (encontrou == 1)
  241.       {
  242.         payLoad += local[jota];
  243.         encontrou = 0;
  244.       }
  245.       else
  246.         payLoad += onlyMAC[i];
  247.       payLoad += "|";
  248.       payLoad += nodMAC[i][1];
  249.       payLoad += "|";
  250.       payLoad += nodMAC[i][2];
  251.       payLoad += "|0|";
  252.       payLoad += nodMAC[i][4];
  253.       payLoad += "|";
  254.       payLoad += nodMAC[i][5];
  255.       if (i < qtdeNos)
  256.         payLoad += "*";
  257.     }
  258.     request->send(200, "text / plain", payLoad);
  259.   });
  260.   server.on("/ligarLed", HTTP_GET, [](AsyncWebServerRequest * request) {            // SERVE O ARQUIVO ligarLed
  261.     if (request->hasArg("btnRoot")) {                 // No root
  262.       digitalWrite(LED, !digitalRead(LED));           // Inverte status do LED
  263.       montaPacote();
  264.       refresh(master, 0);                             // Refresh nos parametros
  265.     }
  266.     if (request->hasArg("btnNode1")) {                // Primeiro no
  267.       //    if (request->hasArg(*nodeMatrix[1])) {                // Primeiro no
  268.       buscaNode( 1);
  269.     }
  270.     if (request->hasArg("btnNode2")) {                // Segundo no
  271.       buscaNode( 2);
  272.     }
  273.     if (request->hasArg("btnNode3")) {                // Terceiro no
  274.       buscaNode( 3);
  275.     }
  276.     if (request->hasArg("btnNode4")) {                // Quarto no
  277.       buscaNode( 4);
  278.     }
  279.     if (request->hasArg("btnNode5")) {                // Quinto no
  280.       buscaNode( 5);
  281.     }
  282.     if (request->hasArg("btnNode6")) {                // Sexto no
  283.       buscaNode( 6);
  284.     }
  285.     request->send(200, "text / plain", payLoad);
  286.   });
  287.   server.begin();
  288.   Serial.print("carregaPagina "); Serial.println(xPortGetCoreID());
  289. }
  290. //--------------------------------------------------------------
  291. void buscaNode(uint16_t i)
  292. {
  293.   String msg;                                         // String para montar a msg
  294.   msg += myID;                                        // Adiciona o ID do root na msg
  295.   msg += " 1";                                        // Liga/Desliga o LED
  296.   uint32_t node = onlyMAC[i];                         // Seleciona o node da tabela selecionada pelo indece i
  297.   mesh.sendSingle(node, msg);                         // Envia msg para o no
  298.   Serial.print("buscaNode "); Serial.println(xPortGetCoreID());
  299. }
  300. //--------------------------------------------------------------
  301. void selectMAC( uint32_t from, String msg, uint8_t i) // Seleciona e salva valores recebidos de um novo no
  302. {
  303.   nodMAC[i][0] = nodID;
  304.   nodMAC[i][1] = msg.substring(1, 2);                 // Separa o valor do modelo do ESP
  305.   if (nodMAC[i][1] == "0")                            // Se for 0 é ESP3266
  306.     nodMAC[i][1] = "ESP8266";                         // Salva ESP8266
  307.   else                                                // Se for 1 é ESP32
  308.     nodMAC[i][1] =  "ESP32";                          // Salva ESP32
  309.   nodMAC[i][2] = msg.substring(3, 4);                 // Status do no'
  310.   nodMAC[i][4] = msg.substring(7, 8);                 // Separa o valor do status do LED
  311.   nodMAC[i][5] = msg.substring(9, 13);                // Separa o valor analog
  312.   nodMAC[i][5] = nodMAC[i][5].toInt();                // Remove o * do final se for mmeno que 4 digitos
  313.   onlyMAC[i] = from;                                  // Salva MAC integral
  314.   Serial.print("selectMAC "); Serial.println(xPortGetCoreID());
  315. }
  316. //--------------------------------------------------------------
  317. void refresh(String msg, uint8_t i)                   // Atualiza os valores de parametro de um no
  318. {
  319.   nodMAC[i][4] = msg.substring(7, 8);                 // Separa o valor do status do LED
  320.   nodMAC[i][5] = msg.substring(9, 13);                // Separa o valor analog
  321.   nodMAC[i][5] = nodMAC[i][5].toInt();                // Remove o * do final se for mmeno que 4 digitos
  322.   Serial.print("refresh "); Serial.println(xPortGetCoreID());
  323. }
  324. //-----------------------------------------------------------------------
  325. //essa função ficará mudando o estado do led a cada 1 segundo
  326. //e a cada piscada (ciclo acender e apagar) incrementará nossa variável blinked
  327. void coreTaskZero( void * pvParameters ) {
  328.   Serial.print("coreTaskZero "); Serial.println(xPortGetCoreID());
  329.   while (true) {
  330.     mesh.update();
  331.     if (myIP != getlocalIP()) {
  332.       montaLocal();
  333.       myIP = WiFi.localIP();
  334.       Serial.println("My WiFi IP is " + myIP.toString());
  335.     }
  336.     if (digitalRead(bot) == LOW)                            // Se botao esta pressionado
  337.     {
  338.       delay(30);                                            // Debouncing
  339.       if (digitalRead(bot) == LOW)                          // Se botao continua pressionado
  340.       {
  341.         digitalWrite(LED, !digitalRead(LED));               // Inverte status LED
  342.       }
  343.     }
  344.     if (digitalRead(LED) == HIGH)
  345.     {
  346.       stLED = 1;
  347.     }
  348.     else
  349.       stLED = 0;
  350.     delay(200);
  351.   }
  352. }
  353. //-----------------------------------------------------------------------
  354. //essa função será responsável apenas por atualizar as informações no
  355. //display a cada 100ms
  356. void coreTaskOne( void * pvParameters ) {
  357.   Serial.print("coreTaskOne "); Serial.println(xPortGetCoreID());
  358.   while (true) {
  359.     delay(200);
  360.   }
  361. }
RAW Paste Data