Recents in Beach


Receba o meu conteúdo GRATUITAMENTE


Acionamento remoto via ESP32 Lora

 

Nesse post eu mostro uma opção de acionamento remoto de cargas usando uma conexão LoRa, combinada a uma rede WiFi.





Funcionamento: Acionamento de cargas distantes

    O objetivo deste exemplo é apresentar um circuito capaz de acionar cargas elevadas, distantes e de forma cômoda. Para isso vamos supor que desejamos acionar o motor de uma bomba, um aquecedor e um holofote.



    Acessaremos o ESP WiFi LoRa 32 através do WiFi, usando o como um servidor HTTP. Através de uma página simples, servida por ele, selecionaremos os comandos que serão enviados via LoRa para o ESP WiFi LoRa 32 receptor. Este por sua vez, será encarregado de realizar a atuação sobre as cargas.

Como Funciona:



Configuração do rádio Lora


    Ao clicar no botão “Bomba”, da página servida pelo ESP WiFi LoRa 32 transmissor, uma requisição é enviada para este que por sua vez a retransmite para o ESP WiFi LoRa 32 receptor. Podemos ver o mensagem enviada via LoRa no registro espectral do software SDR. Abaixo, a saída COM4 do ESP WiFi LoRa 32 receptor mostra os sinais recebidos.

Usando o navegador do celular, é possível ser servido pela página fornecida pelo ESP WiFi LoRa 32 transmissor e controlar as cargas.

Detalhe do processo de iniciação do transmissor. Cada etapa de ajuste é informada e o IP para acesso é disponibilizado.

Depois de uma primeira conexão, somente o IP fica disponível no display.




    Abaixo a captura de uma atualização do receptor.





Recursos usados


  • 2x ESP WiFi LoRa 32 da Heltec.
  • 1x módulo de relés.
  • 1x contator trifásico.
  • 1x motor 220V (representa o motor da bomba).
  • 1x lâmpada 127V
  • Fios e conexões variadas.
  • SDR para visualização do sinal LoRa.

Circuito receptor

Circuito receptor – Módulo de relés


    O circuito do transmissor é formado simplesmente pelo ESP WiFi LoRa 32. Já o circuito do receptor possui, além do ESP WiFi LoRa 32, uma interface para o acionamento das cargas de potência elevada. A primeira é um módulo de relés.
    
    Estes relés podem acionar cargas de 250Vac x 10A no máximo, mas devemos ficar atentos a cargas indutivas e capacitivas, que podem gerar tensões e correntes, respectivamente, muito elevadas durante transientes.
    
  É recomendável também que sejam alimentados por uma fonte independente, principalmente se o número de relés for elevado. No exemplo utilizamos o pino de 5V disponível no módulo da Heltec, já que a corrente absorvida não ultrapassou os limites do módulo.


Circuito receptor – Contador

    Para aumentar a capacidade de acionamento de carga, vamos utilizar um contator. Os contatores são como relés, mas podem precisar de correntes mais elevadas para seu acionamento. Utilizaremos então o relé para acionar o contator.

    Para mais detalhes sobre os tipos e aplicações de contatores, acesse a norma IEC 60497-4.





Circuito Elétrico


    Abaixo temos o circuito elétrico com as três cargas de exemplo: Um motor conectado a duas fases através do contator, um aquecedor monofásico ligado a um relé e um holofote conectado a um terceiro relé.


    Em destaque os dispositivos de acionamento: relés e contator. Note que o contator é acionado por um dos relés.



Configuração do rádio LoRa

    Para configurar o rádio LoRa, utilizamos a calculadora disponibilizada pela Semtech no link abaixo:


    Usando esta calculadora, podemos obter informações muito importantes sobre a transmissão LoRa que será efetua e ajuda na melhor escolha dos parâmetros, permitindo o equilíbrio mais adequando entre alcance e velocidade de transmissão.



    Abaixo vemos as configurações usadas nos testes. A calculadora fornece algumas estimativas como: consumo, tempo no ar, orçamento do link, chip compatível entre outros.




    Há também estimativas mais detalhadas sobre o perfil energético do chip. Não entraremos nestes detalhes nesta aplicação.


Código Fonte (transmissor)

Código – Fonte: declarações
//COM 8
#include "Arduino.h" //inclui a biblioeca padrão Arduino.h
#include "heltec.h" //inclui a biblioteca da Heltec
#include "WiFi.h" //inclui a biblioteca WiFi
// Definições do rádio LoRa
#define DisplayEstado true //define se o display estará ou não ativo
#define LoRaEstado true //define se o rádio LoRa estará ou não ativo
#define SerialEstado true //define se a Serial do módulo estará ou não disponível (Baud Rate padrão 115200)
#define AmplificadorDePotencia true // define se o amplificador de potência PABOOST estará ou não ativo
#define BandaDeTransmissao 433E6 //define a frequência média de transmissão: 868E6, 915E6
// Definições do WiFi
#define SSid "Seu_SSID" //Identificador do serviço de rede WiFi
#define Senha "Sua senha" //Senha de acesso ao serviço WiFi
//Variáveis de estado dos controlados
bool EstadoBomba = 0;
bool EstadoAquecedor = 0;
bool EstadoHolofote = 0;
bool Atuar = false;
//inicia o servidor na porta 80
WiFiServer servidor(80);
Código – Fonte: setup()
void setup()
{
  //inicia os dispositivos do devKit da Heltec (DEVE SER INICIADO ANTES DE TUDO)
  Heltec.begin(DisplayEstado, LoRaEstado, SerialEstado, AmplificadorDePotencia, BandaDeTransmissao);
  Heltec.display->clear(); //Limpa qualquer mensagem inicial do display
  SetupWiFi(); //Configura a conexão Wifi
  SetupLoRa(); //Configura o rádio LoRa
  //Sinaliza o fim dos ajustes
  Heltec.display -> drawString(0, 40, "Setup concluído!");
  Heltec.display -> display();
  servidor.begin();// inicia o servidor 
  //informa ip no display
  Heltec.display -> drawString(0, 50, "Servidor: " + WiFi.localIP().toString());
  Heltec.display -> display();
  delay(1000);
}
Código – Fonte: loop()
void loop() 
{
  TrataRequisicao();//trata as requisições HTTP
  enviarPacote();//Envia as mensagens LoRa
}

Código – Fonte: SetupWiFi()
void SetupWiFi()
{
  //inicio dos ajustes do conexão WiFi
  WiFi.disconnect(true); //Desconecta de uma possível conexão prévia
  delay(100);
  IPAddress ip(192, 168, 0, 119); // Definição de um IP fixo
  IPAddress gateway(192, 168, 0, 1); //Gateway da rede
  IPAddress subnet(255, 255, 255, 0); //Máscara de rede
  WiFi.mode(WIFI_STA); //Ajusta para o modo STATION
  WiFi.setAutoConnect(true); //Ativa a auto reconexão
  WiFi.config(ip, gateway, subnet); //Configura os endereços fixos
  WiFi.begin(SSid, Senha); //Informa o id do Serviço WiFi e a senha
  delay(100);
  byte count = 0; // Contador das tentativas de conexão
  
 while (WiFi.status() != WL_CONNECTED && count < 10)
  {
    count ++;
    delay(500);
    Heltec.display -> drawString(0, 0, "Conectando WiFi...");
    Heltec.display -> display();
  }
  if (WiFi.status() == WL_CONNECTED) //Se conseguiu conectar...
  {
    Heltec.display -> drawString(0, 10, "Conexão WiFi ok!");
    Heltec.display -> display();
    delay(100);
  }
  else // ... caso falhe a conexão
  {
    Heltec.display -> drawString(0, 10, "Falha na conexão!");
    Heltec.display -> display();
    delay(100);
    //pode aplicar um loop infinito ou reset AQUI;
  }
}




 Código – Fonte: SetupLoRa()
void SetupLoRa()
{
  //Sinaliza o início dos ajustes
  Heltec.display -> drawString(0, 20, "Configurando LoRa...");
  Heltec.display -> display();
  delay(100);
  LoRa.setSpreadingFactor(12); //define o fator de espalhamento
  LoRa.setSignalBandwidth(250E3); //define a largura de banda
  LoRa.setCodingRate4(5); //define o Codding Rate
  LoRa.setPreambleLength(6); //define o comprimento do preâmbulo
  LoRa.setSyncWord(0x12); //define a palavra de sincronização
  //LoRa.disableCrc(); //desabilita o CRC
  LoRa.crc(); //ativa o CRC
  //Sinaliza o fim dos ajustes do rádio LoRa
  Heltec.display -> drawString(0, 30, "LoRa configurado!");
  Heltec.display -> display();
  delay(100);
}
Código – Fonte: TrataRequisicao()
void TrataRequisicao()
{
  //cria um objeto "cliente" se há uma conexão disponível
  WiFiClient cliente = servidor.available();
  if (!cliente) return; //se não há cliente, retorna
  // se há um cliente, sinaliza no display
  Heltec.display -> clear();
  Heltec.display -> drawString(0, 0, "Servidor: " + WiFi.localIP().toString());
  Heltec.display -> drawString(0, 10, "Cliente conectado!");
  Heltec.display -> display();
  while (cliente.connected()) //executa enquanto houver conexão
  {
    if (cliente.available()) //se há uma requisição disponível
    {
      String req = cliente.readStringUntil('\r'); //Lê a requisição
     //A partir daqui, verificamos se a requisição possui
      //algum comando de ajuste de sinal
      if (req.indexOf("acao=0") != -1) //para o motor da bomba
      {
        Atuar = true; //enviar os dados para atuar
        EstadoBomba = !EstadoBomba;
      }
      else if (req.indexOf("acao=1") != -1)//para o aquecedor
      {
        Atuar = true; //enviar os dados para atuar
        EstadoAquecedor = !EstadoAquecedor;
      }
	else if (req.indexOf("acao=2") != -1)//para o holofote
      {
        Atuar = true; //enviar os dados para atuar
        EstadoHolofote = !EstadoHolofote;
      }
      else if (req.indexOf("acao=3") != -1)//desligar tudo
      {
        Atuar = true; //enviar os dados para atuar
        EstadoBomba = 0;
        EstadoAquecedor = 0;
        EstadoHolofote = 0;
      }
      else if (req.indexOf("acao=-1") != -1) //somente atualizar os dados
      {
        Atuar = true; //enviar os dados para atuar
        Serial.println("Atualizar estado");
      }
      else //nenhuma opção válida
      {
        Atuar = false; //sinaliza que não é para atuar
      }
      
//Este é o html que iremos retornar para o cliente
      String html =
  String html =
        "<html>"
        "<head>"
        "<meta name='viewport' content='width=device-width, initial-scale=1, user-scalable=no'/>"
        "<title>Controle WiFi / LoRa</title>"
        "<style>"
        "body{"
        "text-align: center;"
        "font-family: sans-serif;"
        "font-size:15px;"
        "padding: 25px;"
        "}"
        "p{"
        "color:#444;"
        "}"
        "button{"
        "font-size:15px;"
        "outline: none;"
        "border: 2px solid #1fa3ec;"
        "border-radius:18px;"
        "background-color:#FFF;"
        "color: #000;"
"padding: 5px 25px;"
        "}"
        "button:active{"
        "color: #fff;"
        "background-color:#1fa3ec;"
        "}"
        "button:hover{"
        "border-color:#0000ff;"
        "}"
        "</style>"
        "</head>"
        "<body>"
        "<H1>Controle WiFi / LoRa</H1>"
        "<H2>Selecione um comando:</H2>"
        "<p><a href='?acao=0'><button>Bomba</button></a>"
        "<a href='?acao=1'><button>Aquecedor</button></a>"
        "<a href='?acao=2'><button>Holofote</button></a>"
        "<a href='?acao=3'><button>Desligar tudo.</button></a></p>"
        "<p></p>"
        "<p></p>"
        "<p><a href='?acao=-1'><button>Atualizar estados.</button></a></p>"
        "<p></p>"
        "<H3>Bomba: " + String(EstadoBomba) + "</H3>"
        "<H3>Aquecedor: " + String(EstadoAquecedor) + "</H3>"
        "<H3>Holofote: " + String(EstadoHolofote) + "</H3>"
        "</body>"
        "</html>\r";

//Escreve o html no buffer que será enviado para o cliente
      cliente.print(html);
      //Envia os dados do buffer para o cliente
      cliente.flush();
    }
    //aguarda para que o trafego das informações seja concluído
    delay(20);
    //força a desconexão do cliente
    cliente.stop();
  }
  //sinaliza o IP do servidor no display
  Heltec.display -> clear();
  Heltec.display -> drawString(0, 0, "Servidor em:");
  Heltec.display -> drawString(0, 10, WiFi.localIP().toString());
  Heltec.display -> display();
}



Código – Fonte: EnviarPacote()
void enviarPacote()
{
  if (!Atuar) return; //se não é para atuar, retorna
  //envia para a serialos dados que serão enviados pelo LoRo
  Serial.println("Enviando: " + String(EstadoBomba) + String(EstadoAquecedor) + String(EstadoHolofote));
  //Enviar pacote
  //inicia a montagem do pacote (parâmetro FALSE desativa o Header);
  LoRa.beginPacket();
  //enviando os estado um a um
  LoRa.write(EstadoBomba);
  LoRa.write(EstadoAquecedor);
  LoRa.write(EstadoHolofote);
  LoRa.endPacket(); // finaliza o pacote
  Atuar = false; //Sinaliza que já houve a atuação
}

Código Fonte (receptor)


Código – Fonte: declarações
// COM 4
#include "heltec.h" //inclui a biblioteca da Heltec
#define DisplayEstado true //define se o display estará ou não ativo
#define LoRaEstado true //define se o rádio LoRa estará ou não ativo
#define SerialEstado true //define se a Serial do módulo estará ou não disponível 
			// (Baud Rate padrão 115200)
#define AmplificadorDePotencia true // define se o amplificador de potência PABOOST estará ou não ativo
#define BandaDeTransmissao 433E6 //define a frequência média de transmissão: 868E6, 915E6
#define pinBomba 22 //pino usado para acionar o motor da bomba
#define pinAquecedor 23 //pino usado para acionar o aquecedor
#define pinHolofote 17 //pino usado para acionar o holofote
Código – Fonte: setup()
void setup()
{
  //define os pino como saída
  pinMode(pinBomba, OUTPUT);
  pinMode(pinAquecedor, OUTPUT);
  pinMode(pinHolofote, OUTPUT);
  //os pinos são ajustados para nível alto logo no início
  //porque o módulo de relés tem lógica invertida
  digitalWrite(pinBomba, HIGH);
  digitalWrite(pinAquecedor, HIGH);
  digitalWrite(pinHolofote, HIGH);
//inicia o ESP WiFi LoRa 32 da Heltec
  Heltec.begin(DisplayEstado, LoRaEstado, SerialEstado, AmplificadorDePotencia, BandaDeTransmissao);
  SetupLoRa(); //faz os ajustes do rádio LoRa
  delay(100);
  //Sinaliza o fim dos ajustes
  Heltec.display -> clear();
  Heltec.display -> drawString(0, 0, "Setup concluído!");
  Heltec.display -> drawString(0, 10, "Aguardando dados...");
  Heltec.display -> display();
}


Código – Fonte: loop()
void loop()
{
  //verifica a chegada dos dados
  RecebeDados();
}
Código – Fonte: SetupLoRa()
void SetupLoRa()
{
  LoRa.setSpreadingFactor(12); //define o fator de espalhamento
  LoRa.setSignalBandwidth(250E3); //define a largura de banda
  LoRa.setCodingRate4(5); //define o Codding Rate
  LoRa.setPreambleLength(6); //define o comprimento do preâmbulo
  LoRa.setSyncWord(0x12); //define a palavra de sincronização
  //LoRa.disableCrc(); //desabilita o CRC
  LoRa.crc(); //ativa o CRC
}

Código – Fonte: RecebeDados()
void RecebeDados()
{
  // tenta analisar o pacote
  int packetSize = LoRa.parsePacket();
  if (packetSize)  // se o pacote não tiver tamanho zero
  {
    //matriz para armazenamento dos estados
    byte Dados[3];
    // Lê o pacote
    while (LoRa.available())
    {
      Dados[0] = LoRa.read(); //estado do motor da bomba
      Dados[1] = LoRa.read(); //estado do aquecedor
      Dados[2] = LoRa.read(); //estado do holofote
    }
    //os dados são convertidos para booleanos e invertidos
    digitalWrite(pinBomba, !bool(Dados[0]));
    digitalWrite(pinAquecedor, !bool(Dados[1]));
    digitalWrite(pinHolofote, !bool(Dados[2]))
    //Sinaliza os dados recebidos e o RSSI no display
    Heltec.display -> clear();
    Heltec.display -> drawString(0, 0, "Bomba: " + String(Dados[0]));
    Heltec.display -> drawString(0, 10, "Aquecedor: " + String(Dados[1]));
    Heltec.display -> drawString(0, 20, "Holofote: " + String(Dados[2]));
    Heltec.display -> drawString(0, 30, "RSSI: " + String(LoRa.packetRssi()));
    Heltec.display -> display();
    //Sinaliza os dados recebidos e o RSSI na serial
    Serial.println("Bomba: " + String(Dados[0]));
    Serial.println("Aquecedor: " + String(Dados[1]));
    Serial.println("Holofote: " + String(Dados[2]));
    Serial.println("RSSI: " + String(LoRa.packetRssi()));
  }
}
   

    Sempre me perguntam se eu uso Esp32 da Heltec ou da TTGO, bem como o software e a lib é toda da Heltec então eu compro deles, porque eles deixam o software open.

    Eu uso dois Esp32 Lora da Heltec de 433Mhz mas lembre-se que a frequência aqui no Brasil é de 915Mhz. Se você está em Portugal ou um outro país diferente tem que verificar qual a frequência permitida.

    Nesse link você encontra esse maravilhoso componente. bit.ly/3j15hFv

  O primeiro Esp32 Lora é também um WEB server e na demonstração eu mostro o analisador de espectro que se trata de um SDR que é um Rádio Defini por Software, que eu aconselho você a possuir um se quiser progredir no mundo da internet das coisas IoT.

    Veja qual se encaixa no seu bolso:
HackRF One 1MHz a 6GHz USB Open Source Software Plataforma de rádio SDR RTL
Placa de desenvolvimento de recepção de sinais

RTL-SDR V3 RTL2832 1PPM TCXO HF até 1GHz    // Serve para todos os Loras

   Imaginei uma aplicação comum para uma área rural onde acionamentos de motores a longa distância são comuns. Contudo o rádio Lora é muito bom para ambientes industriais por ser praticamente imune a ruídos eletromagnéticos e ter uma boa relação de distância x potência.

     Você pode realmente mandar por muitos KMs um sinal wifi Lora .
Como sempre eu uso um programa bem simples que você pode alterar para seu uso profissional.

    O sinal LoRa só consegue chegar realmente longe se você tiver uma antena profissional.
    A antena profissional da Steelbras voçê encontra em bit.ly/3tcV91k 
    Suporte magnético da antena : bit.ly/3pBZj0y

    Veja aqui a linha de contatores de WEG 


Faça download dos arquivos:

Postar um comentário

1 Comentários

  1. boa noite fernando. acompanho seu canal há bastante tempo. teria como implementar duas funcionalidades a este projeto?

    primeiro, inserir a opção de botoeiras, dispensando assim o uso do smartphone.

    segundo. supondo que meu receptor esteja ha mais de 3 km de distancia. inserir leds no transmissor indicando o estado dos relés do receptor. ON ou OFF. mas tais informações deveriam ser confiáveis. O receptor deveria enviar informações para o transmissor

    ResponderExcluir