Como Utilizar o Sensor Ultra-Sônico HC-SR04 com ESP8266 D1 Mini!

Como Utilizar o Sensor Ultrassônico HC-SR04 com ESP8266 Wemos D1 Mini!

Olá a todos!

No Post de hoje, aprenderemos como utilizar o Sensor Ultra-sônico HC-SR04, utilizando um Módulo ESP8266, mostraremos como efetuar as ligações do módulo sensor no módulo ESP8266, e explicaremos o desenvolver da programação do código na IDE Arduino.

O módulo HC-SR04 já é bastante bem conhecido de todos nós que nos aventuramos nesse mudo das automações. Esse módulo se tornou bastante popular na utilização de medição de distâncias, para trenas eletrônicas, ou sensores de ré para carros, ou mesmos em pequenos robôs, para que ele desvie de obstáculos em sua frente.

Como o Módulo Sensor HC-SR04 Funciona?

O sensor ultrassônico HC-SR04, usa o som para determinar a distância entre o sensor e o objeto mais próximo em seu caminho. Como os sensores ultrassônicos fazem isso?

O sensor envia uma onda sonora em uma frequência acima da audição humana. Em seguida, ele recebe essa onda sonora rebatida de um objeto em sua frente. O sensor calcula o tempo de envio da onda sonora e tempo de retorno, como ilustrado na Figura 2 abaixo. 

Fig. 2 - Emissão e recepção de som sensor utra-sônico HC-SR04

Através do tempo que se leva para o som chegar ao objeto e voltar para o sensor receptor, podemos encontrar a distância percorrida, utilizando a Equação abaixo.

• Equação:  d = v × t
  

Devemos considerar que existem outras intempéries no caminho do som como, temperatura, umidade, pressão, orientação do objeto, tipo de superfície do objeto, etc. que podem alterar o resultado das medições e a equação apresentada acima é uma equação básica para entendermos, não é o foco do nosso Post. 

Diagrama de Conexões!

As conexões do circuito são bastantes simples, temos no sensor ultra-Sônico com 4 pinos, sendo todos eles com marcação na própria placa, então não tem como se confundir, com o sensor virado de frente para você, como dispostos na Figura 3 abaixo, temos a sequência: +VCC, Trigger, Echo, GND.

Caso queira mais informações sobre esse Sensor, podes clicar na Figura 3, e serás aberto uma nova aba do seu navegador com a descrição completa do sensor.

Fig. 3 - Pinout Sensor Ultra-Sônico HC-SR04

A alimentação do sensor será ligada ao 5V do Wemos D1 Mini, esse pino recebe a entrada 5V USB através de um diodo, com isso temos a tensão da porta USB 5V menos a queda de tensão do diodo que é de ~0,6V, resultando aproximadamente uma tensão de 4, 4V no pino 5V do Wemos.

Fizemos o diagrama de conexão do módulo HC-SR04 e o Wemos D1 Mini ESP8266, que é bastante simples, e está disposto na Figura 4 abaixo.  

Fig. 4 - Diagrama de Conexão Sensor Ultrassônico HC-SR04 com ESP8266 Wemos D1 Mini!

Na Sketch abaixo, você pode conferir o Código completo do projeto Como Utilizar o Sensor Ultrassônico HC-SR04 com ESP8266 Wemos D1 Mini! na IDE Arduino!

Finalizamos aqui o nosso pequeno projeto exemplo, na Figura 5 abaixo, temos o mesmo funcionando perfeitamente, sendo lido a distância entre uma caixa e o sensor, no código, foi feito para ser lido a distância tanto em centímetro como também em polegadas, mas, não é obrigado utilizar os dois tipos de medições.

Fig. 5 - Funcionamento Sensor Ultrassônico HC-SR04 com ESP8266 Wemos D1 Mini!

Como Ler Valores Analógicos ADC Usando NodeMCU ESP8266 - IDE Arduíno

Olá a Todos!

No post de hoje, faremos um guia rápido sobre leitura analógica no pino A0 do ESP8266, utilizaremos um potenciômetro para variar o range analógico 0 à 1023, e enviaremos esses dados para ser visualizado no Serial Monitor.

Converteremos o valor analógico com a função map(), e converteremos para um range de 0 a 255, para ser usado na saída D2, e controlaremos a intensidade do LED.

Esse tipo de circuito servirá para qualquer tipo de módulo; ESP8266, ESP32, Arduino, etc. já que o código é escrito na IDE Arduino, e só precisaremos mudar a pinagem do módulo que usaremos no código.

Resolução ADC ESP8266

A GPIO analógica do ESP8266 tem uma resolução de 10 bits, o que significa que você irá obter valores que variam entre 0 à 1023.

É importante saber também que a faixa de tensão de entrada do pino ADC do ESP8266 é de 0 à 1V, isso para os módulos puros, como os; ESP-07, ESP-12E, ESP-05, etc. como mostrado na Figura 2 Abaixo. 

Fig. 2 - Módulos ESP-12E, ESP-07, ESP-05

No entanto, a maioria das placas de desenvolvimento ESP8266 como os NodeMCU, Wemos, D1 Mini, etc. veem com um divisor de tensão interno. Isso nos permite a utilização de sinais com a faixa de tensão de entrada de 0 à 3.3V, o que nos facilita a utilização do potenciômetro ligado a alimentação de 3.3V direto do Módulo ESP com mais praticidade. 

O que precisaremos para montar esse circuito?

O que faremos?

Utilizaremos um potenciômetro para gerar uma tensão de 0 à 5V, simulando um sinal analógico, ligaremos na porta analógica A0 do NodeMCU, faremos a leitura dos valores analógicos provindos do potenciômetro, controlaremos o LED com valores de 0 à 255, e imprimiremos no Serial Monitor.

Para controlar a intensidade de luminosidade do LED, utilizaremos um potenciômetro de 5K ou 10K, conectado a porta A0 do módulo ESP8266.

Os materiais que utilizaremos!

Os componentes que utilizaremos são três: O hardware principal que é o NodeMCU ESP8266, um LED para podermos variar o seu brilho, e o Potenciômetro que utilizaremos para controlar o brilho do LED.

Fig. 3 - Como Ler Valores Analógicos no ESP8266 NodeMCU ADC IDE Arduíno

Diagrama de Ligação!

Na Figura 4 abaixo, temos o diagrama esquemático do circuito que utilizaremos. As conexões são bastante simples, a ligação dos pinos do potenciômetro ao NodeMCU são feitas da seguinte forma:

1. Pino Esquerdo - Fio Vermelho - Ligado ao Pino 3V3
2. Pino Central - Fio Verde - Ligado a Porta Analógica A0
3. Pino Direito - Fio Preto - Ligado ao GND

O LED é ligado diretamente na GPIO D2 do NodeMCU, não estou utilizando nenhum resistor em série com o LED, diferente do mostrado no diagrama da Figura 4 abaixo, pois não ha necessidade de se utilizar nenhum resistor para o LED branco.

Mas, é recomendado o uso do resistor de 100 ohms, se você for fazer uso contínuo do LED na GPIO, por períodos muito grandes, se não usar o resistor, o LED gradualmente “cerca de um ano” vai perdendo o seu brilho.

Fig. 4 - Como Ler Valores Analógicos no ESP8266 NodeMCU ADC IDE Arduíno

Na Figura 5 abaixo, temos a ligação real que fizemos, como podemos observar o resistor não foi utilizado, já que a saída da GPIO é de 3.3V máximo.

Fig. 5 - Controlando Brilho do LED com Potenciômetro Porta Analógicos no ESP8266 NodeMCU ADC IDE Arduíno

O Código Explicado!

O código é bastante simples, incrementamos um LED, só para realizarmos a demonstração, não sendo exatamente necessário para o funcionamento.

 

Nas linhas 9, 10, iniciamos com duas constantes, que serão as constantes associadas aos pinos de entrada do potenciômetro e o de saída para o LED, esses são a constante "potentiometer" associada a porta A0, e a constante "Led" associada a porta D2.

Nas linhas 12, 13, são também duas constantes "potValue" e a constante "pwmOutput", essas não são associadas a pino algum, são constantes de armazenamento, a primeira irá armazenar os valores advindos da leitura do potenciômetro, e a segunda será valores convertidos pela função map() para controlar o brilho do LED.

Na linha 15, temos o Void Setup(), temos a inicialização do Serial Monitor. 

Na linha 17, temos a função Serial.begin(9600), onde o valor dentro da função determina a velocidade de comunicação serial, que no caso está em 9600 bits por segundo.

Na linha 20, temos o Void Loop(), e é aqui onde todos os parâmetros dentro da função loop, ficará rodando sem parar.

Na linha 22, já dentro do loop, encontramos a função analogRead(); que ler o valor do potenciômetro e a variável potValue recebe esses dados.

Na linha 24, temos a função map(), que converte o valor analógico de 0 à 1023 recebido do potenciômetro através da variável potValue, e converte parao range entre 0 à 255, que é o valor de range do PWM.

Na linha 26, a função analogWrite(), ativa o LED conforme o que recebeu do potenciômetro sendo convertido para a variável pwmOutput. 

Nas linhas 29, 30, 31 e 32, são as linhas que imprimem as informações digitadas e coletadas das variáveis potValue e pwmOutput.

Na linha 36, temos a famosa função delay(), que estipula um tempo de 2 milissegundos, para o loop continuar a refazer todas as leituras.

Sensor de Tensão AC 110/220V para Arduíno, ESP32, ESP8266, PIC, etc.

Olá a Todos!!!

No post de hoje, iremos montar um simples, sensor que monitora se ha tensão na entrada do mesmo, sendo um ótimo circuito para se fazer uma automação por falta de energia, ou para quem tem um gerador e não sabe se a tensão está no gerador ou na rede energética, ou qualquer outra aplicação que você necessitar. O circuito utiliza componentes discretos, o que nos facilita bastante para montarmos o nosso. 

Como funciona o Circuito

O funcionamento do circuito é bastante simples, quando aplicamos uma tensão na entrada do módulo sensor, a tensão trafega através do resistor R1, que é um resistor que serve para limitar a corrente no fotodiodo, que acenderá, e fará com que o Fototransistor que é sensível a luz, se polarize, fazendo com que a tensão aplicada no coletor, trafegue para a saída través do emissor do Fototransistor, esse tensão será uma tensão pulsada de acordo com a frequência da tensão de sua rede, no nosso caso é 60hz, por esse motivo, temos um capacitor que serve como filtro para que quando a tensão estiver em 0V o capacitor mantém essa tensão, deixando ao máximo a saída o mais linear possível, como em uma fonte de alimentação.

O circuito

Fig. 2 - Circuito Esquemático do Sensor de Tensão AC 110/220V para Microcontroladores

Lista de Material

• U1 ----------------- Optoacoplador 4N25
• R1 ----------------- Resistor 1/8w 220K 
• C1 ----------------- Capacitor eletrolítico 100uF - 16V 
• RP1---------------- Potenciômetro 10KΩ
• P1------------------ Conector tipo terminal parafusado 5mm 2 Pinos
• P2 ----------------- Conector tipo terminal parafusado 5mm 3 Pinos
• Outros ------------ Fios, Soldas, bateria, placa de circuit impresso, etc.
  
  

PCI - Arquivos para baixar

Estamos dispondo para Transferência os materiais necessários para quem deseja montar com a PCI - Placa de Circuito Impresso, os arquivos em PNG, PDF e arquivos GERBER para quem deseja enviar para impressão.

Fig. 3 - PCI Sensor de Tensão AC 110/220V para Microcontroladores

Transferir:

Link Direto: Arquivos PNG, PDF, GERBER

Pessoal, o trabalho é grande, escrever, montar, testar, elaborar a PCI, armazenar para baixar, tudo isso dá muito trabalho, e não cobramos nada por isso!

Então nos ajude a divulgar nosso trabalho, compartilha nas redes sociais, Facebook, Instagram, nos grupos de WhatsApp, uma simples atitude sua, faz com que cresçamos juntos e melhoremos o nosso trabalho!

E por hoje é só, espero que tenham gostado!

Qualquer dúvida, digita nos comentários que logos estaremos respondendo.
Se inscreva no nosso Blog! Clique aqui - FVM Learning!
Forte abraço.

Deus vos Abençoe
Shalom!

Fig. 1 - PCB - Módulo Relé para dispositivos digitais

Olá a Todos!!!

Os Módulos Relés

Os Relés

Fig. 2 - Relé 5V ,10 Amperes, HJR-3FF-S-Z 5 Pinos

O Circuito

Módulo com isolamento Total:

Fig. 3 - Circuito Módulo Relé com Isolamento Total

Nesta configuração o circuito controlador, Arduino, ESPs, PICs, CPUs etc., não tem contato algum com o circuito da carga, que tem uma fonte independente para a ativação do Relé, e o Relé isola a carga do circuito de controle.

Lista de Materiais Módulo isolamento Total:

Módulo com isolamento Parcial:

Fig. 4 - Módulo Relé isolamento parcial

Lista de Materiais Módulo isolamento Parcial:

• TR1 ------------- Transistor NPN de uso geral 2N3904, BC548, etc.
• OA -------------- Opto-Acoplador PC817
• D1 --------------- Diodo 1N4148, 1N4001, 1N4002... 4007, etc.
• LED1 ----------- Led de uso geral 3mm vermelho
• R1 --------------- Resistor 1K (morron, preto, vermelho)
• RL --------------- Relé de 5 Pinos HJR-3FF-S-Z, JQC-3FF-S-Z, etc. 
• J1 ---------------- Conector Barra Macho 3 Pinos
• J2 ---------------- Borne Conector Kre 3 Vias
• Diversos -------- Placa Circuito Impresso, estanho, fios, etc.
  
  

Módulo simples:

Fig. 5 - Módulo Relé Simples

PCI - Arquivos para Baixar

Para cada modelo que você precise montar, e em cada pasta estamos dispondo os devidos arquivos em PDF e arquivos GERBER para quem deseja enviar para impressão.

Fig. 6 - Módulo Relé Acionamento digital PCB 3D

Transferência:

Link Direto: Arquivos PDF, GERBER

Pessoal, o trabalho é grande, escrever, montar, testar, elaborar a PCI, armazenar para baixar, tudo isso dá muito trabalho, e não cobramos nada por isso!

Então nos ajude a divulgar nosso trabalho, compartilha nas redes sociais, Facebook, Instagram, nos grupos de WhatsApp, uma simples atitude sua, faz com que cresçamos juntos e melhoremos o nosso trabalho!

E por hoje é só, espero que tenham gostado!

Qualquer dúvida, digita nos comentários que logos estaremos respondendo.
Se inscreva no nosso Blog! Clique aqui - FVM Learning!
Forte abraço.

Deus vos Abençoe
Shalom!

Fig 1 - PCI - Controle de potência de carga 110/220Vac. Controlado por: ESPs Arduíno ou PICs

Olá a Todos!

Hoje em dia, todos estamos envolvidos com circuitos de automação, disparo remoto, controle de cargas remotamente, etc., e sempre utilizamos o velho e conhecido Relê, seja ele Relê de contato, utilizando bobinas com contatos de fechamento metálico, ou com os mais avançados “caros” Relê de Estado Sólidos. 

Mas para controlar uma carga de potência em 220V, com níveis de controle diferentes com o seu microcontrolador isolado da rede de energia, podemos dizer que não é tão simples de encontrar um módulo para dimerização e controle de carga controlado por Microcontroladores com um custo baixo. 

Foi pensando nisso que apresentamos esse pequeno circuito que pode controlar eficientemente a; luminosidade de uma lâmpada incandescente, velocidade de um motor elétrico, temperatura de uma estufa, secador de cabelos ou qualquer outro eletrodoméstico elétrico que possa ser controlado através de um Dimmer. 

Todo esse controle se dar ao uso de um microcontrolador que pode ser um ESP8266, ESP32, Arduino, PIC ou qualquer outro Microcontrolador que você estiver utilizando, que controla o módulo de potência baseado em um TRIAC. 

Funcionamento do Circuito

O TRIAC é acionado através de um DIAC que conduz a partir de uma tensão de 28V, ele é quem controla o ângulo de condução do TRIAC, disparando-o em diversos pontos do sinal senoidal da rede de energia, sendo assim possível aplicar potências diferentes na carga controlada.

Para controlar o disparo do TRIAC, é usado um circuito RC, de maneira que a modificação dessa resistência, dispara o TRIAC em pontos de semi-ciclos de energia da rede.

Para conseguirmos modificarmos a resistência controlando por um Microcontrolador, implementamos um divisor somador com 3 resistores diferentes conectados através de um opto-acoplador.

Através desse conjunto de resistores que formamos o Req pelo qual podemos controlar o circuito RC de retardo onde Req configurado no máximo valor. 

O tempo de carga de C1 até o disparo do DIAC é maior, pela qual ocorre um tempo maior do semi-ciclo da energia da rede, fazendo com que a carga tenha uma menor potência.

Já com Req na posição mínimo a carga de C1 é rápida e o disparo do DIAC ocorre no início do semi-ciclo, tornando a potência da carga no máximo, sendo assim, podemos controlar a potência máxima e mínima na carga. 

E vale salientar que quando utilizamos esse circuito para controlar motores, ele corta uma parte do semi-ciclo, mantendo a tensão em 220V, o que significa que o torque de um motor se mantém mesmo sendo controlado em baixa velocidade, o que o assemelha ao motor DC controlado por PWM.

O Circuito

Na Figura 2, temos o diagrama esquemático do circuito de Controle de potência de carga 110/220Vac. Controlado por: ESP8266, ESP32, Arduíno ou PICs com TRIAC TIC246, utilizamos 3 portas digitais do Arduino, D9, D10, D11.

Para controlar o circuito de potência, foi utilizado resistores em série para controle de corrente no entre a saída digital do Arduino (5V), e o Opto-acoplador, que utiliza um LED Infra-vermelho interiormente, e sabemos que se aplicarmos uma tensão de 5V direto no LED, ele irá queimar. 

Fig. 2 - Controle de potência de carga 110/220Vac. Controlado por: ESPs Arduinos ou PICs

As séries de Opto-acopladores MOCs são dispositivos de driver TRIAC isolados opticamente. Esses dispositivos contêm um diodo emissor de infravermelho GaAs e um comutador bilateral de silício ativado por luz, que funciona como um TRIAC.

Eles são projetados para interface entre controles eletrônicos e TRIACs de potência para controlar cargas resistivas e indutivas para operações de 115 ou 220 VCA.

E é através desse fechamento que conseguimos diminuir a resistência que colocamos em seus terminais, e baixamos a queda de tensão que ocorre através dessa resistência e assim, aumentamos a carga em C1, e o disparo do DIAC ocorre no início do semi-ciclo, aumentando a potência da carga.

O Opto-acoplador que utilizamos foi um MOC3021. Ele pode estar substituindo por:  MOC3020, MOC3021, MOC3022, MOC3023, OPI3020, OPI3021, OPI3022, OPI3023, MCP3020, MCP3021, MCP3022, GE3020, GE3021, GE3022, GE3023, todos são compatíveis.

Tabela dos Resistores em Série

Por utilizarmos 3 resistores em série/ponte, conseguimos 8 combinações de resistências diferentes, e na Figura 3 temos a tabela para verdade para seguirmos e podermos programar as combinações sequenciadas nas portas do Arduino.

Fig 3 - Tabela Verdade Controle de potência de carga 110/220Vac. Controlado por: ESPs Arduino ou PICs

A Potência do Circuito

A potência total da carga que podemos colocar em nosso circuito, só dependerá unicamente do tipo de TRIAC que você utilizará, em nossa montagem, fizemos com o TIC246, por ser um TRIAC que suporta até 16 Amperes, que seguindo a lei de ohms, temos que:

A potência “P” é igual à tensão “V” multiplicado pela corrente “I”:

Ou seja, uma carga muitíssimo grande, se falamos de carga residencial, no entanto, existem diversos tipos de TRIACs para ser utilizados, deixamos alguns dos mais conhecidos e fácil de se encontrar no mercado para você poder utilizar conforme o seu projeto: 

Olá a Todos!

O que precisaremos!

//=================================================================================================//
// MASTER                                                                                          //
// Controlling LEDs with Two ESP8266 Uses ESP-NOW Protocol                                         //
// Edited and Adapted by: Engineer Jemerson Marques, On: 22.12.2019 - FVM Learning website         //
// Available at: https://www.fvml.com.br and on Youtube channel                                    //
// https://www.youtube.com/c/FVMLearning - I hope you have fun - Good luck                         //
//-------------------------------------------------------------------------------------------------//

#include <ESP8266WiFi.h>
extern "C" {
#include <espnow.h>
}
// This is the slave MAC Address which receives the data
 uint8_t mac[] = {0x5C, 0xCF, 0x7F, 0x4C, 0x82, 0x5C}; //AP MAC SLAVE'S ADDRESS

  #define WIFI_CHANNEL 4
  int prevstate_1 = LOW;
  int prevstate_2 = LOW;

// Data structure, must be the same for the slave

struct __attribute__((packed))DataStruct {
  char text[32];
};
    DataStruct button_1;
    DataStruct button_2;

//=====================================================================================================
void setup() {
  pinMode(D1, INPUT_PULLUP);
  pinMode(D4, INPUT_PULLUP);
  pinMode(D2, OUTPUT);
  pinMode(D3, OUTPUT);

  Serial.begin(115200); Serial.println();
  Serial.println("Starting EspnowController.ino");
  WiFi.mode(WIFI_STA); // Station mode for esp-now controller
  WiFi.disconnect();
  Serial.printf("This mac: %s, ", WiFi.macAddress().c_str());
  Serial.printf("slave mac: %02x%02x%02x%02x%02x%02x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
  Serial.printf(", channel: %i\n", WIFI_CHANNEL);
  if (esp_now_init() != 0)
  {
    Serial.println("*** ESP_Now initialization failed");
  }
  esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);
  esp_now_add_peer(mac, ESP_NOW_ROLE_SLAVE, WIFI_CHANNEL, NULL, 0);
  strcpy(button_1.text, "Button 01 pressed");
  strcpy(button_2.text, "Button 02 pressed");
  Serial.println("Setup finished");
}

//======================================================================================================

void loop() {
  sendData();
}

//======================================================================================================
void sendData() {

  int currentstate_1 = digitalRead(D4);
  if (prevstate_1 != currentstate_1) {
    if (currentstate_1 == LOW) {
      uint8_t bs[sizeof(button_1)];
      memcpy(bs, &button_1, sizeof(button_1));
      esp_now_send(mac, bs, sizeof(button_1));
      Serial.println(button_1.text);
      digitalWrite(D2, !digitalRead(D2));
    }
  } prevstate_1 = currentstate_1;

  int currentstate_2 = digitalRead(D1);
  if (prevstate_2 != currentstate_2) {
    if (currentstate_2 == LOW) {
      uint8_t bs[sizeof(button_2)];
      memcpy(bs, &button_2, sizeof(button_2));
      esp_now_send(mac, bs, sizeof(button_2));
      Serial.println(button_2.text);
      digitalWrite(D3, !digitalRead(D3));
    }
  } prevstate_2 = currentstate_2;
}

//========================================== www.fvml.com.br ===========================================

//=================================================================================================//
// SLAVE                                                                                          //
// Controlling LEDs with Two ESP8266 Uses ESP-NOW Protocol                                         //
// Edited and Adapted by: Engineer Jemerson Marques, On: 22.12.2019 - FVM Learning website         //
// Available at: https://www.fvml.com.br and on Youtube channel                                    //
// https://www.youtube.com/c/FVMLearning - I hope you have fun - Good luck                         //
//-------------------------------------------------------------------------------------------------//

#include <ESP8266WiFi.h>
extern "C" {
#include <espnow.h>#include <user_interface.h>
}
 uint8_t mac[] = {0x5C, 0xCF, 0x7F, 0x4C, 0x82, 0x5C}; //AP MAC SLAVE'S ADDRESS

//=====================================================================================================
  int Led1 = D0;
  int Led2 = D1;

void initVariant() {
  WiFi.mode(WIFI_AP);
  wifi_set_macaddr(SOFTAP_IF, &mac[0]);
}

//=====================================================================================================

#define WIFI_CHANNEL 4
// Must match the controller structstruct __attribute__((packed))DataStruct {
  char text[32];
unsigned int time;};

DataStruct receivedData;
//=====================================================================================================
void setup() {
  Serial.begin(115200); Serial.println();
  Serial.println("Starting EspnowSlave.ino");  Serial.print("This node AP mac: "); Serial.println(WiFi.softAPmacAddress());  Serial.print("This node STA mac: "); Serial.println(WiFi.macAddress());  pinMode(Led1, OUTPUT);
  pinMode(Led2, OUTPUT);

  if (esp_now_init() != 0){
    Serial.println("*** ESP_Now init failed");    while (true) {};
  }
  esp_now_set_self_role(ESP_NOW_ROLE_SLAVE);
  esp_now_register_recv_cb(receiveCallBackFunction);
  Serial.println("End of setup - waiting for messages");}

//======================================================================================================

void loop() {
}

//======================================================================================================
void receiveCallBackFunction(uint8_t *senderMac, uint8_t *incomingData, uint8_t len) {
  memcpy(&receivedData, incomingData, sizeof(receivedData));

  String DataCompare = String(receivedData.text);

  if(DataCompare == "Button 01 pressed"){
  digitalWrite(Led1, !digitalRead(Led1));
  Serial.println(" Message = " + DataCompare);
 }
  if(DataCompare == "Button 02 pressed"){
  digitalWrite(Led2, !digitalRead(Led2));
  Serial.println(" Message = " + DataCompare);
   
  }
}

//========================================== www.fvml.com.br ===========================================

Logo abaixo temos um link com os arquivos dos códigos do Circuito Controle como do Circuito Receiver. 

Recomendamos você baixar e não copiar no código acima, pois pode vir com algum erro de acentuação ou qualquer outra coisa, então disponibilizamos o link para baixar.

Clique no Link Abaixo Para Descarregar os arquivos:

>>> Arquivos para Baixar! <<<

 

Você pode também está acompanhando esse post em nosso canal do YouTube, é uma forma de você acompanhar o funcionamento do mesmo.

Pessoal, o trabalho é grande, escrever, montar, testar, elaborar a PCI, armazenar para baixar, tudo isso dá muito trabalho, e nada cobramos por isso!

Então nos ajude a divulgar nosso trabalho, compartilha nas redes sociais, Facebook, Instagram, nos grupos de WhatsApp, uma simples atitude sua, faz com que cresçamos juntos e melhoremos o nosso trabalho!

E por hoje é só, espero que tenham gostado!

Qualquer dúvida, digita nos comentários que logos estaremos respondendo.

Se inscreva no nosso Blog! Clique Aqui — FVM Learning!

Forte abraço.

Deus vos Abençoe

Shalom!