FVM Learning

Nosso maior compromisso é compartilhar conhecimentos, somos simples mas não simplórios, astuto mas não pacóvio, nos posicionamos empenhados em mostrar o caminho para desmistificação do opróbrio em legítima defesa do conhecimento compartilhado. Eng. Jemerson Marques.
Mostrando postagens com marcador Embarcados. Mostrar todas as postagens
Mostrando postagens com marcador Embarcados. Mostrar todas as postagens

domingo, 8 de dezembro de 2019

Piscando LEDs sem delay() utilizando Função millis() - Blink LEDs Without Delay

Piscando LEDs sem delay() utilizando Função millis() - Blink LEDs Without Delay

Olá a Todos!!!

Fazer LEDs piscar em alguns tipos de embarcados como os: Arduínos, os ESP8266, ou os ESP32 é bastante simples para qualquer um com conhecimento básico fazer, no entanto, temos um grande problema quando utilizamos a função delay(), que é a função básica para fazer um led Piscar, devido a essa função pausar o andamento do processamento de um microcontrolador, fazendo com que o tempo de delay mantenha os Embarcados tecnicamente parados a espera daquele tempo determinado acabar.
No post de hoje, iremos mostrar como programar os: Arduínos, os ESP8266, ou os ESP32 para piscar 1, 2, 3, 4... ou quanto de LEDs você quiser colocar, sem a utilização da função delay(), iremos utilizar a função mills(), que contará o tempo sem pausar as atividades e processamento dos microcontroladores, e através dessa básica noção é que poderemos não só fazer os LEDs piscarem, mas muitas das vezes precisamos executar uma atividade, por exemplo piscar um LED, ao mesmo tempo que precisamos fazer a leitura de algum sensor, ou pressionar um botão, ao mesmo tempo de duas atividade remanescentes, e nos embarcados, muitas vezes terminamos por utilizar a função delay, pausando nossa sketch e prejudicando o funcionamento de nosso programa, como a leitura errada do sensor ou o não funcionamento do pressionar o botão para acionar outras atividades.

Funcionamento da função Delay();

A função Delay(), pausa o programa por uma quantidade especificada de tempo (em milissegundos). Cada segundo equivale a 1000 milissegundos, e sua sintaxe é: delay(ms), cujo o parâmetro ms é o número de milissegundos para pausar o programa, e não retorna nada. 

Funcionamento da função Millis();

A unção Millis(), retorna o número de milissegundos passados desde que o embarcado começou a executar o programa. Esse número irá sofrer overflow (chegar ao maior número possível e então voltar pra zero), após aproximadamente 50 dias. sua sintaxe é: time = millis(), não tendo nenhum parâmetro e, retorna o número de milissegundos passados desde que o programa iniciou (unsigned long).

Ao compararmos as funções Delay e a função Millis, podemos visualizar claramente o modo de trabalho de cada um e o porque não devemos utilizar a função delay com projetos mais elaborados, não estamos falando de um pequeno código que sirva apenas para piscar um LED sem muito controle e leitura de sensores simultâneo e etc., estamos falando de programas que necessitam fazer leituras simultâneas, piscar LEDs e variar um PWM tendo que ficar lendo um botão para ver se foi pressionando ou não, isso é necessário realmente utilizar a função millis, pois com o delay fica impossível um código desses funcionar de forma estabilizada.

Nos nossos testes utilizamos o NodeMCU ESP8266, mas a mesma Sketch servirá tanto para o NodeMCU como para o Arduíno, como sugerido na Figura 2 abaixo, a diferença em utilizar o NodeMCU e o Arduíno, é que o NodeMCU não é necessário a utilização de resistores limitadores de corrente em série com os LEDs, devido a GPIO ou seja, a saída do NodeMCU em nível alto ser de 3.3V, que é o valor próximo de alimentação dos LEDs, e no Arduíno, a saída é de 5V, necessitando assim os resistores de limitação, e será também necessário setar a definições do número da GPIO do Arduíno pelo qual está conectado cada LED.
Fig. 2 - Esquemático de ligação dos Leds no Arduíno

A sketch do Código

A Sketch completa do código está disposto logo abaixo para poder baixar, é bem simples de entender e tem uma eficácia muito boa.

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

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

Se inscreva no nosso Blog!!! Click Aqui FVM Learning!!!

Forte abraço.

Deus vos Abençoe

Shalom

terça-feira, 26 de novembro de 2019

O que é Protocolo MQTT e como Funciona? Principais Aplicações

O que é Protocolo MQTT e como Funciona? Principais Aplicações

Olá a Todos!!!

No post de hoje, iremos entender o que é o protocolo MQTT (Message Queuing Telemetry Transport), de que forma ele funciona, e quais são suas principais aplicações no mundo IoT.

O que é MQTT?

Fig 1 - O que é Protocolo MQTT e como Funciona?
MQTT é um protocolo de mensagens publish/subscribe, projetado para o transporte de telemetria em enfileiramento de mensagens simples e leve, com baixa largura de banda, e protocolo de conectividade  machine-to-machine (M2M) ou "máquina para máquina", que funciona no topo do protocolo TCP / IP
Ele foi projetado para conexões remotos onde um "pequeno tamanho de código" é necessário ou a largura de banda da rede é limitada.
Ao utilizar o protocolo MQTT, você pode enviar comandos para controlar portas de saídas, ler e publicar dados de sensores, controlar remotamente esses dispositivos e muito mais. Você pode estabelecer comunicação entre vários dispositivos.

Quem projetou o MQTT?

O MQTT foi projetado pelo Dr. Andy Stanford-Clark, da IBM, e Arlen Nipper, da Arcom (atual Eurotech), em 1999, para fazer a conexão dos sistemas de telemetria de oleoduto por satélite.
Embora tenha começado como um protocolo proprietário, foi liberado Royalty livre em 2010 e tornou-se um padrão OASIS em 2014.

Quais os Padrões do MQTT?

Existem as versões V5.0 e V3.1.1 que agora são padrões OASIS (V3.1.1 também foi ratificado pela ISO).
Como o MQTT está relacionado ao protocolo SCADA e ao MQIsdp?
O “protocolo SCADA” e o “MQ Integrator SCADA Device Protocol” (MQIsdp) são nomes antigos do que agora é conhecido como MQ Telemetry Transport (MQTT). O protocolo também é conhecido como “WebSphere MQTT” (WMQTT), embora esse nome também não seja mais utilizado.

O MQTT utiliza alguma portas padrão?

Certamente sim. A porta padrão utilizada pelo MQTT TCP / IP 1883 que é uma porta reservada com o IANA para uso com o MQTT. A porta TCP / IP 8883 também está registrada, para usar o MQTT sobre SSL.

O MQTT tem suporte para segurança?

Podemos passar um nome de usuário e senha com um pacote MQTT na V3.1 do protocolo. A criptografia através da rede pode ser tratada com SSL, independentemente do protocolo MQTT em si (vale a pena notar que o SSL não é o mais leve dos protocolos e adiciona uma sobrecarga de rede significativa). Segurança adicional pode ser adicionada por um aplicativo que criptografa dados que envia e recebe, mas isso não é algo embutido no protocolo, a fim de mantê-lo simples e leve.

Quais são as vantagens do MQTT?

O protocolo MQTT permite que seu sistema SCADA acesse dados da IoT. O MQTT traz muitos benefícios poderosos para o seu processo:
  • Distribua informações com mais eficiência
  • Aumentar a escalabilidade
  • Reduza drasticamente o consumo de largura de banda da rede
  • Reduza as taxas de atualização para segundos
  • Muito adequado para sensoriamento remoto e controle
  • Maximizar a largura de banda disponível
  • Sobrecarga extremamente leve
  • Muito seguro com segurança baseada em permissão
  • Usado pela indústria de petróleo e gás, Amazon, Facebook e outras grandes empresas
  • Economiza tempo de desenvolvimento
  • O protocolo de publicação / assinatura coleta mais dados com menos largura de banda em comparação com os protocolos de pesquisa.

Como o MQTT Funciona

MQTT é um protocolo de publicação / assinatura que permite que dispositivos de borda de rede publiquem em um broker. Os clientes se conectam a esse broker, que medeia a comunicação entre os dois dispositivos. Cada dispositivo pode se inscrever ou se registrar em tópicos específicos. Quando outro cliente publica uma mensagem em um tópico inscrito, o broker encaminha a mensagem para qualquer cliente que se inscreveu.
MQTT é bidirecional e mantém o reconhecimento da sessão com estado. Se um dispositivo de borda de rede perder a conectividade, todos os clientes inscritos serão notificados com o recurso "Última Vontade e Testamento" do servidor MQTT, para que qualquer cliente autorizado no sistema possa publicar um novo valor de volta no limite de borda dispositivo de rede, mantendo a conectividade bidirecional.
A leveza e eficiência do MQTT possibilitam aumentar significativamente a quantidade de dados que estão sendo monitorados ou controlados. Antes da invenção do MQTT, aproximadamente 80% dos dados eram deixados em locais remotos, embora várias linhas de negócios pudessem ter usado esses dados para tomar decisões mais inteligentes. Agora, o MQTT torna possível coletar, transmitir e analisar mais dados sendo coletados.
Diferentemente do modelo usual de consulta / resposta de muitos protocolos, que tendem a saturar desnecessariamente as conexões de dados com dados inalteráveis, o modelo de publicação / assinatura do MQTT maximiza a largura de banda disponível.

Principais Aplicações

O protocolo MQTT, foi a princípio um protocolo utilizado para realizar conexões dos sistemas de telemetria de oleoduto por satélite, como já mencionado nos tópicos acima, mas que atualmente se expandiu e largos passos na história dos sistemas de automação, devido ao seu protocolo de mensagens publish/subscribe, projetado para o transporte de telemetria em enfileiramento de mensagens simples e leve, com baixa largura de banda, protocolo de conectividade M2M que funciona no topo do protocolo TCP / IP, ele é bastante utilizado em conexões remotos e com poucas linhas de código para fazê-lo funcionar. Com esse protocolo, podemos enviar comandos para controlar portas GPIO de uma central de controle, como os ESP8266, ESP32, Arduínos entre outros, já bastante difundidos aqui em nosso Blog, podendo ler e publicar dados de sensores, controlar remotamente esses dispositivos e muito mais. Você pode estabelecer comunicação entre vários outros dispositivos, tais como integração entre Assistentes virtuais, como o Echo Dot Alexa, Google Home entre outros.

Documentação MQTT em Inglês

Especificações de Protocolo

O MQTT v3.1.1 é um padrão ISO e OASIS mais antigo. A especificação está disponível no site da OASIS em Inglês na página Web em HTML ou em PDF.

O MQTT v5.0 é um padrão OASIS. A especificação está disponível no site da OASIS em Inglês na página Web em HTML ou em PDF.

Para referência com versão anterior do MQTT v3.1 está disponível Aqui.

O MQTT-SN v1.2, conhecido como MQTT-S, está disponível Aqui. O MQTT para redes de sensores é destinado a dispositivos incorporados em redes não TCP / IP, como o Zigbee.
O MQTT-SN é um protocolo de mensagens de publicação / assinatura para redes sem fio de sensores (WSN), com o objetivo de estender o protocolo MQTT além do alcance da infraestrutura TCP / IP para soluções de sensores e atuadores.

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

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

Se inscreva no nosso Blog!!! Click Aqui - FVM Learning

Forte abraço.

Deus vos Abençoe

Shalom


sexta-feira, 18 de outubro de 2019

Como utilizar o Botão Flash do NodeMCU ESP8266

Como utilizar o Botão Flash do NodeMCU ESP8266 

Olá a Todos!!!


Fig. 1 - Utilizando Botão Flash com NodeMCU
Muitas vezes precisamos fazer testes, programando o NodeMCU quando a ótima ideia daquele projeto que veio de repente em nossas mentes, porém o trabalho que temos em estar colocando o NodeMCU em uma Protoboard, conectando os rabichos para as conexões com a chave tipo botão, ligar os rabichos para conectar o Led, e tudo para testar uma ideia que vem na cabeça, e muitas vezes deixamos para depois, daí, terminamos por esquecer aquela boa e repentina ideia que nos sobreveio... :( 

No Post de hoje, iremos aprender a fazer uma simples código no programa do NodeMCU ESP8266 utilizando a IDE Arduíno para podermos utilizar o botão que tem embarcado na placa do NodeMCU como mostrado na figura 1 acima.
Pois imagine você que para fazer um simples teste com um botão e um Led, precisaríamos de 4 rabichos uma protoboard um Led e uma chave, um pequeno teste necessitaria de 8 componentes, como mostrado na figura 2 abaixo.
Fig. 2 -  Utilizando o Botão Flash do NodeMCU ESP8266














A princípio o que precisamos saber é em qual porta está definida o botão Flash do NodeMCU, como fazemos com o led embarcado no módulo NodeMCU.
Seguindo o datasheet do próprio NodeMCU, vemos que a Botão Flash está conectado a GPIO0.
De posse desse conhecimento, podemos definir na sketch do programa a definição da porta D3, que é associado a GPIO0.
Como podemos ver no exemplo do código abaixo, definimos o BUTTON na porta D3, e da mesma forma, setamos o Led do próprio módulo NodeMCU, e chamamos de LedBoard, você pode utilizar qualquer tipo de nome para ele.

//------------------------------------------------------------------------------------
// Defining I/O Pins
//------------------------------------------------------------------------------------
#define       LedBoard   2                             // WIFI Module LED
#define       BUTTON     D3                            // NodeMCU Button


Logo abaixo temos o código completo, que é bastante simples só para seguirmos de exemplo, você pode acrescentar, alterar e utilizar em seu projeto sem problemas algum.


//==================================================================================//
// How to use NodeMCU ESP8266 Flash Button                                          //
// Created by: Engineer Jemerson Marques, On: 18.10.2019 - FVM Learning website     //
// Available at: https://www.fvml.com.br                                            //
//----------------------------------------------------------------------------------//

//------------------------------------------------------------------------------------
// Defining I/O Pins
//------------------------------------------------------------------------------------
#define       LedBoard   2                             // WIFI Module LED
#define       BUTTON     D3                            // NodeMCU Button

//====================================================================================
void setup() {
  Serial.begin(115200);                                // only for debug
  Serial.println("");                                  // only for debug
  pinMode(LedBoard, OUTPUT);                           // Initiate the Onboard Led Output
  pinMode(BUTTON, INPUT_PULLUP);                       // Initiate the ESP Pin: INPUT_PULLUP - Its mean that you no need put a resistor
  digitalWrite(LedBoard, HIGH);                        // Initiate the Onboard Off
  Serial.println("ESP Inicializado com sucesso");      // only for debug
}

void loop() {                 
  if(digitalRead(BUTTON) == LOW){
    digitalWrite(LedBoard, !digitalRead(LedBoard));
    delay(300);
    Serial.println("Botão Pressionado");
  }
}


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

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

Se inscreva no nosso Blog!!! Click aqui - FVM Learning!!!

Forte abraço.

Deus vos Abençoe

Shalom


domingo, 22 de setembro de 2019

Comunicação entre 2 ESPs8266 Ponto a Ponto - Peer-to-Peer - Sem Roteador

Comunicação entre 2 ESPs8266 Ponto a Ponto - Peer-to-Peer - Sem Roteador

Olá a Todos!!!

Baseado em um outro post que fizemos a comunicação direta Ponto a Ponto entre dois ESPs com a utilização de um roteador, que você também pode conferir nesse post do link abaixo:

Comunicação e Controle entre Dois ESPs8266 Ponto a Ponto - Peer-to-Peer

O que faremos hoje, é fazer essa mesma comunicação, no entanto não iremos fazer a utilização de um Roteador para executar essa comunicação, um dos ESPs irá ser uma AP Access Point no modo STA Station, quer será o Servidor e receberá a conexão do Client, que se conectará ao Station e irá comandar a Carga "LED" do Servidor, e o Servidor irá também comandar a Carga do Client, ou seja ambos acionarão as cargas um do outro independente de qualquer conexão, será uma conexão direta, Ponto a Ponto, Peer to Peer,  entre os dois ESP.

Fig. 1 - Comunicação entre 2 ESPs8266 Ponto a Ponto - Peer-to-Peer - Sem Roteador

FUNCIONAMENTO

A princípio o funcionamento básico da comunicação entre os dois ESPs, criamos um ESP como um AP "Ponto de Acesso" no modo Station, que será o Servidor, e outro ESP como uma  STA "Estação"que será o nosso Client. Em seguida, eles estabelecerão uma comunicação direta pois o nosso AP, fornece um IP Fixo para o Client STA se conectar.
Utilizamos o LED e o Botão Flash embarcado no próprio NodeMCU, isso ajuda a realizarmos testes sem ter que fazer alguma conexão com dispositivos externos, utilizamos os parâmetros de definição para setarmos essas portas tanto do LED embarcado, chamado no código de LedBoard, quanto o botão Flash, chamado de BUTTON,  como podemos ver abaixo.
#define       LedBoard  2                    // WIFI Module LED
#define       BUTTON    0                    // NodeMCU Flash-Button

Logo após no Void Setup, definimos os Pinos com a função pinMode para o led com OUTPUT e o botão definimos com a função INPUT_PULLUP, isso faz com que o ESP8266 utilize o resistor de Pull Up interno do próprio Microcontrolador, como podemos visualizarmos no código abaixo.
  pinMode(LedBoard, OUTPUT);
  pinMode(BUTTON, INPUT_PULLUP);

Sendo assim, o Cliente envia um comando através da chave "Flash-Button" para o Servidor, e quando o Servidor receber esse comando através da própria conexão Wi-Fi que ele fornece, ele ligará a carga definida, "que utilizamos o LED embarcado como exemplo". Da mesma forma, o Servidor envia um comando para o Cliente, e quando o Cliente receber esse comando, ele ligará a carga definida no LED Embarcado, como definido no código.

Para podermos dar prosseguimento a esse projeto, pré-supomos que você já tenha instalado as bibliotecas na IDE do Arduíno, se não instalou, sugerimos a você que veja nosso outro Post:Instalando Biblioteca do Modulo ESP8266 na IDE Arduíno

Se você já instalou, vamos prosseguir...

Os Códigos

Logo abaixo temos os códigos tanto do Server, que é um AP - Access Point, e Station, quanto do outro ESP no modo STA - Station, ambos seguem os mesmos princípios,

Server_Comunic_ESP_P2P_No_Router

//==================================================================================//
// SERVER                                                                           //
// Communication Between 2 ESPs8266 Peer-to-Peer - No Router                        //
// Adapted by: Engineer Jemerson Marques, On: 21.09.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          //
//----------------------------------------------------------------------------------//

//------------------------------------------------------------------------------------
// Libraries Needed For This Project
//------------------------------------------------------------------------------------
#include <SPI.h>
#include <ESP8266WiFi.h>                     // The Basic Function Of The ESP NOD MCU


//------------------------------------------------------------------------------------
// WIFI Module Config
//------------------------------------------------------------------------------------
char ssid[] = "FVML";                        // SSID of your ESP Server
char pass[] = "fvml1234";                    // password of your ESP Server
WiFiServer server(80);

  IPAddress ip(192, 168, 10, 40);            // IP address of the server
  IPAddress gateway(192, 168, 10, 1);        // gateway of the server
  IPAddress subnet(255, 255, 255, 0);        // subnet mask of the server

//------------------------------------------------------------------------------------
// Defining I/O Pins
//------------------------------------------------------------------------------------
#define       LedBoard  2                    // WIFI Module LED
#define       BUTTON    0                    // NodeMCU Flash-Button

//====================================================================================
void setup() {
  Serial.begin(115200);                      // Only for debug
  
  WiFi.mode(WIFI_AP_STA);                    // Need both to serve the webpage and take commands via tcp

  WiFi.softAPConfig(ip, gateway, subnet);
  WiFi.softAP(ssid, pass);                   // Access point password and identification
  delay(500);
  Serial.print("AP IP address: ");
  Serial.println(ip);
  server.begin();                            // Starts the server

//------------------------------------------------------------------------------------
// Serial Network parameters - Only for debug
//------------------------------------------------------------------------------------  
  Serial.println("ESP Server Initialized - FVML");
  Serial.print("IP: ");       Serial.println(WiFi.softAPIP());
  Serial.print("SSID: ");     Serial.println(WiFi.SSID());
  Serial.print("Signal: ");   Serial.println(WiFi.RSSI());

  pinMode(LedBoard, OUTPUT);                // Initiate the Onboard Led Output
  pinMode(BUTTON, INPUT_PULLUP);            // Initiate the ESP Pin: INPUT_PULLUP - Its mean that you no need put a resistor
  digitalWrite(LedBoard, HIGH);             // Initiate the Onboard Led Off
}

void loop() {
  WiFiClient client = server.available();
  if (!client) {
    return;
  }
  String request = client.readStringUntil('\r');
  client.flush();

  if (request == "I am Transmitter") {
    digitalWrite(LedBoard, !digitalRead(LedBoard));
    Serial.print("Data Received: "); Serial.println(request);
    delay(200);
  }

  int reading = digitalRead(BUTTON);
  if (reading == LOW) {
    client.print("I am Receiver\r");
    delay(200);
  }
  client.println("Receiver\r");      // sends the answer to the client
  delay(100);
}
//============================================== www.fvml.com.br =============================================================

Client_Comunic_ESP_P2P_No_Router

//==================================================================================//
// CLIENT                                                                           //
// Communication Between 2 ESPs8266 Peer-to-Peer - No Router                        //
// Adapted by: Engineer Jemerson Marques, On: 21.09.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          //
//----------------------------------------------------------------------------------//

//------------------------------------------------------------------------------------
// Libraries Needed For This Project
//------------------------------------------------------------------------------------
#include <SPI.h>
#include <ESP8266WiFi.h>                             // The Basic Function Of The ESP NODEMCU

//------------------------------------------------------------------------------------
// Defining I/O Pins
//------------------------------------------------------------------------------------
#define       LedBoard   2                           // WIFI Module LED
#define       BUTTON     0                           // NodeMCU Button

//------------------------------------------------------------------------------------
// WIFI Authentication Variables
//------------------------------------------------------------------------------------
char ssid[] = "FVML";                                 // SSID of your ESP Server
char pass[] = "fvml1234";                             // password of your ESP SEVER
  
//------------------------------------------------------------------------------------
// WIFI Module Mode & IP
//------------------------------------------------------------------------------------
IPAddress server(192,168,10,40);                      // the fix IP address of the server
WiFiClient client;

//====================================================================================
void setup() {
  pinMode(LedBoard, OUTPUT);                           // Initiate the Onboard Led Output
  pinMode(BUTTON, INPUT_PULLUP);                       // Initiate the ESP Pin: INPUT_PULLUP - Its mean that you no need put a resistor
  digitalWrite(LedBoard, HIGH);                        // Initiate the Onboard Led Off
 
  Serial.begin(115200);                                // only for debug
  Serial.println("");
  Serial.print("Awaiting connection: ");
  WiFi.begin(ssid, pass);                              // connects to the WiFi router
  while (WiFi.status() != WL_CONNECTED) {
  Serial.print(".");
  digitalWrite(LedBoard, LOW);
  delay(250);
  digitalWrite(LedBoard, HIGH);
  delay(250);
  }
  digitalWrite(LedBoard, HIGH);
  
//------------------------------------------------------------------------------------
// Network parameters - Only for debug
//------------------------------------------------------------------------------------
  Serial.println("");
  Serial.println("ESP Client Connected - FVML");
  Serial.print("IP: ");       Serial.println(WiFi.softAPIP());
  Serial.print("SSID: ");     Serial.println(WiFi.SSID());
  Serial.print("Signal: ");   Serial.println(WiFi.RSSI());
}
//====================================================================================
void loop() {
 
  ContinuousConnection();
}
//====================================================================================

 void ContinuousConnection(){
  client.connect(server, 80);                          // Connection to the server
  ReadButton();                                        // Read Button from Transmitter
 }
//====================================================================================

void ReadButton() {
  int reading = digitalRead(BUTTON);                   // Read the Button State
  if (reading == LOW) {                                // If the button pressed
    client.print("I am Transmitter\r");                // Send messege "I am Transmitter" To Server
    delay(200);
   }else{
   ClientContinue(); 
  } 
}

//====================================================================================
void ClientContinue(){
  client.println("Transmmiter");                      // sends the message to the server
  String answer = client.readStringUntil('\r');       // receives the answer from the sever
  client.flush();
  
  if (answer == "I am Receiver") {                    // compares if the response of the receiver is equal to 'I am Receiver'
    digitalWrite(LedBoard, !digitalRead(LedBoard));   // if it changes the status of the LED
    Serial.println("Data Received: " + answer);
    delay(200);                                       // client will trigger the communication 200 milliseconds
  }
}
//============================================== www.fvml.com.br =============================================================

ARQUIVOS PARA BAIXAR:

Você também pode baixar os arquivos .ino do código de programa no link abaixo:
Link Direto: Arquivos para baixar


Você também pode assistir esse tutorial passo a passo no nosso canal do youtube




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

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

Se inscreva no nosso Blog!!! Click aqui - FVM Learning!!!

Forte abraço.

Deus vos Abençoe

Shalom


sexta-feira, 6 de setembro de 2019

Como Hackear Circuito Módulo Relé para funcionar com ESP8266 3.3V

Como Hackear Circuito Módulo Relé para funcionar com ESP8266 3.3V

Olá a Todos!!!

Fig. 1 - Módulo Relé alterado para trabalhar com ESP8266
No post de hoje, iremos fazer uma pequena alteração no circuito do módulo Relé que irá possibilita-lo a ser utilizado com o ESP8266 ou ESP32, pois os módulos de relé de 5 volts, não conseguem ser acionados por uma fonte de trigger de 3.3V, fazendo com que muitos se decepcionem depois que comprar sem saber que não vai funcionar, iremos fazer isso em um passo a passo de forma fácil e substituindo apenas um componente, o transistor PNP SMD 2TY por um transistor NPN de uso geral como os BCs, Cs, 2Ns e etc..

O Módulo

O módulo que temos é esse mostrado na figura 2 é um módulo de um só acionamento, ou seja, um relé independente, que é alimentado por 5V, então quando se utiliza um ESP8266 para acionamento de cargas com o módulo Relé, ele não responde, pois esse módulo so aciona o relé com uma tensão Trigger de 5V
Fig. 2 - Módulo Relé 1 canal 5V
Esse relé é ativado por um transistor PNP SMD 2TY que é o S8550, como podemos observa-lo na figura 3 logo abaixo, onde podemos ver a disposição dos componentes de perto.

Fig. 3 - Disposição dos componentes na placa do módulo original
Esse transistor tem uma tensão Vbe de 5 volts, e em série com a base ele tem um resistor de 1K limitador de corrente, como podemos observar no diagrama esquemático da  figura 4, mesmo se você colocar direto na porta do GPIO do ESP8266, "que não é recomendado" você não conseguirá ativar esse módulo, pois não terá corrente suficiente para ativar o Trigger do Módulo.
Fig. 4 - Diagrama Esquemático circuito original Módulo Relé

O Circuito Alterado

O que fizemos de primeiro foi, substituir o transistor por um transistor de uso comum, como os da linha BCs, Cs, 2Ns, e tantos outros que você pode escolher, o que é de fato importante é atentarmos a pinagem do transistor que você irá colocar na placa do módulo, nós escolhemos transistor NPN, por ser mais comum em nosso estoque e em placas de sucata, temos aos montes esses transistores de uso geral, podemos verificar na comparação entre os três módulos, o primeiro da esquerda é o original, sem alteração, o segundo está utilizando o transistor C945 e o terceiro da direita está utilizando o BC548, como podemos observar os transistores C945 e BC548 são diferenciado pela pinagem coletor e emissor, que são um inverso do outro, fazendo com que inverter-se-mos os lados dos transistores em cada módulo, a base de ambos é no pino central. ficando assim como ilustrado na figura 5 logo abaixo.
Fig. 5 - Os três módulos, da esquerda Original, do centro com C945 e da direita com BC548
Você pode colocar outro transistor do tipo PNP, e isso te daria até menos trabalho, pois não precisarias alterar praticamente nada no circuito. No nosso caso, com o transistor NPN, tivemos que inverter a alimentação do circuito, ou seja onde temos o Pino VCC, é agora GND, e onde temos o Pino GND, é agora VCC, e ainda tivemos que inverter o Diodo que é acoplado ao relé, e também inverter a polarização dos dois LEDs, como podemos ver no diagrama esquemático da  figura 6 logo abaixo.
Fig. 6 - Diagrama esquemático do circuito módulo relé alterado

O Funcionamento

O que diferencia o funcionamento do módulo com transistor PNP e transistor NPN em modos gerais, é  o acionamento da carga, ex.: O módulo normal "sem alteração" é ativado com pulso negativo, ou seja, ele fica ativo em quanto a porta GPIO estiver em Baixa "LOW", e ele desativa quando a porta GPIO estiver em Alta "HIGH". No nosso circuito o processo é inverso, o que denota, que ele trabalha de forma "normal", se a porta GPIO estiver em Alta, o relé será ativado e senão, o relé será desativado.

Convidamos você a assistir o nosso vídeo no nosso canal do youtube com esse tutorial passo a passo.

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

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

Se inscreva no nosso Blog!!! Click aqui - FVM Learning!!!

Forte abraço.

Deus vos Abençoe

Shalom