Jar inteligente baseado em IoT usando NodeMCU ESP8266 e sensor ultrassônico

Publicado em por
Tempo de leitura: 7 minutes

Este Jar inteligente nos permite acompanhar os estoques e é facilmente acessível pela internet. O Jar inclui um sensor ultrassônico na parte superior e usa as ondas ultrassônicas refletidas para descobrir até que ponto o Jar é preenchido e quanto espaço resta dentro do jarro. Sempre que a quantidade de conteúdo muda no jar, ela é detectada pelo NodeMCU, e o mesmo é atualizado no servidor web. Isso pode ser útil para rastrear suprimentos e planejar o reabastecimento de qualquer lugar do mundo.

Componentes necessários

  • NodeMCU ESP8266
  • Sensor Ultrassônico HC-05
  • ProtoBoard
  • Jumper Wires

Como funciona um sensor ultrassônico?

Antes de prosseguirmos, devemos saber como funciona um sensor ultrassônico para que possamos entender este tutorial muito melhor. O sensor ultrassônico usado neste projeto é mostrado abaixo.

Como você pode ver, ele tem dois olhos circulares como projeções e quatro pinos saindo dele. As duas projeções semelhantes a olhos são o transmissor e o receptor de onda ultrassônica (doravante denominada onda dos EUA). O transmissor emite uma onda dos EUA com uma frequência de 40 Hz, essa onda viaja pelo ar e é refletida de volta quando detecta um objeto. As ondas de retorno são observadas pelo receptor. Agora sabemos o tempo que leva para essa onda ser refletida e voltar e a velocidade da onda dos EUA também é universal (3400cm / s). Usando essas informações e as fórmulas do ensino médio abaixo, podemos calcular a distância percorrida.

Distância = Velocidade × Tempo

Agora que sabemos como funciona um sensor US, vamos ver como ele pode ser conectado a qualquer MCU/CPU usando os quatro pinos. Esses quatro pinos são Vcc, Trigger, Echo e Ground, respectivamente. O módulo funciona em + 5V e, portanto, o Vcc e o pino de aterramento são usados para alimentar o módulo. Os outros dois pinos são os pinos de E/S com os quais nos comunicamos com nosso MCU. O pino do gatilho deve ser declarado como um pino de saída e feito alto para 10µS, isso transmitirá a onda dos EUA para o ar como uma explosão sônica de 8 ciclos. Assim que a onda for observada, o pino Echo ficará alto pelo exato intervalo de tempo que a onda uS levou para retornar ao módulo do sensor. Portanto, este pino de eco será declarado como entrada e um temporizador será usado para medir quanto tempo o pino esteve alto. Isso pode ser melhor compreendido pelo diagrama de tempo abaixo.

Diagrama de circuito

O diagrama do circuito para Jarro baseado em IoT é fornecido abaixo:

O circuito é muito simples, pois estamos usando apenas o sensor ultrassônico e o NodeMCU. O sensor ultrassônico HC-SR04 funciona com 5V, portanto, se você conectá-lo a 3,3V, ele não funcionará. O pino VCC do sensor ultrassônico é conectado ao pino VIN do NodeMCU. Os pinos de disparo e eco são conectados ao pino D5 e D6 do NodeMCU, enquanto o pino GND do sensor é conectado ao pino GND do NodeMCU. Uma fonte de alimentação de 5V alimenta o NodeMCU.

 

Configuração IFTTT para Jarro baseado Iot

IFTTT (If This Then That) é um serviço baseado na web em que podemos criar cadeias de instruções condicionais, chamadas de miniaplicativos. Usando esses miniaplicativos, podemos enviar notificações de Emails, Twitter, Facebook. Aqui, estamos usando o IFTTT para enviar notificações por e-mail quando o Jar está quase vazio. Anteriormente, usamos o IFTTT em muitos aplicativos para enviar um alerta por e-mail, como neste projeto de campainha Wi-Fi.

Primeiro faça login no IFTTT e pesquise por ‘Webhooks’.

Agora, para obter a chave privada, clique em ‘Documentação’. Copie esta chave em algum lugar, ela será usada no código.

Como temos a chave privada, criaremos um miniaplicativo usando Webhooks e serviços de e-mail. Para criar um miniaplicativo, clique em seu perfil e clique em ‘Create’ a partir das opções disponíveis.

Agora, na próxima janela, selecione If This Then That.

No campo ‘This’, usaremos webhooks para obter as solicitações da web do NodeMCU.

Agora selecione o gatilho ‘Receive a Web Request’, insira o nome do evento como jar_event e clique em ‘Create Trigger’.

Depois disso, clique em ‘Then That’ e, em seguida, clique em E-mail.

Agora, em Email, clique em ‘send me an email’ e digite o assunto e o corpo do email e clique em criar ação.

Na última etapa, clique em ‘Finish’ para concluir a configuração do miniaplicativo.

 

Explicação do código

Estamos usando o Arduino IDE para programar o NodeMCU. Portanto, certifique-se de ter baixado os arquivos da placa NodeMCU. Para saber mais sobre como programar NodeMCU com Arduino IDE, siga o link.

O código completo é fornecido no final do documento. Aqui estamos explicando o código passo a passo.

Portanto, comece seu código incluindo todos os arquivos de biblioteca necessários. O sensor ultrassônico não requer um arquivo de biblioteca, então só precisamos do arquivo de biblioteca ESP8266WiFi.h.

#include <ESP8266WiFi.h>

Depois disso, defina os pinos onde você conectou os pinos Trig e Echo e também defina duas variáveis para calcular a distância e a duração.

const int trigPin = D5;
const int echoPin = D6;
long duration;
int distance;

Depois disso, crie instâncias para o nome do Wi-Fi, a senha do Wi-Fi, o nome do host IFTTT e a chave privada.

const char* ssid = "Nome do Wi-Fi";
const char* password = "Senha";
const char *host = "maker.ifttt.com";
const char *privateKey = "Chave Privada";

Agora, para acessar o WiFiServer, declaramos uma biblioteca de objetos WifiServer. 80 é a porta padrão para HTTP.

WiFiServer server(80);

Agora, dentro da função void loop, calcule o tempo entre o sinal disparado e o sinal recebido. Este tempo será usado para calcular a distância.

duration = pulseIn(echoPin, HIGH);
distance = duration * 0.0340 / 2;

Depois disso, a distância é convertida em uma porcentagem para mostrar a ocupação do Jar.

level =((14-distance)/14.0)*100;

Em seguida, comparamos a ocupação do frasco e, se o nível de ocupação for inferior a 5, ele acionará um evento IFTTT para enviar um e-mail de aviso

if ( level <= 10) {
        send_event("jar_event");
   }

 

Testando o contêiner inteligente

Assim que seu hardware e código estiverem prontos, carregue o código e coloque o sensor ultrassônico no topo do Jar, ou você pode colá-lo na tampa do Jar como mostrado na figura. Agora verifique a página da Web usando o endereço IP que está impresso no Monitor Serial. Deve mostrar o nível de ocupação do Jar. E se o nível de ocupação do Jar for inferior a 10, ele enviará um e-mail de aviso. Aqui, o nível de aviso é definido de acordo com o comprimento do meu Jar. Você pode alterá-lo de acordo com o seu.

 

Código

#include <ESP8266WiFi.h>

const int trigPin = D5;
const int echoPin = D6;

long duration;
int distance; 
float level;

const char* ssid = "Galaxy-A31"; 
const char* password = "xxxxxxxx";       // Sua senha 

void send_event(const char *event);

const char *host = "maker.ifttt.com";
const char *privateKey = "xxxxxxxxxxx";  // Sua chave Privada do ifttt

WiFiServer server(80);

void setup() {
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 Serial.begin(9600);
 Serial.print("Conectando-se à rede Wifi");
 Serial.println(ssid);
 WiFi.begin(ssid, password);
 while (WiFi.status() != WL_CONNECTED) {
   delay(500);
   Serial.print(".");
 }
 Serial.println("");
 Serial.println("Conectado com sucesso ao WiFi.");
 Serial.println("Endereço IP é : ");
 Serial.println(WiFi.localIP());
 server.begin();
 Serial.println("Servidor iniciado");
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = duration * 0.0340 / 2;
  Serial.println("Distance");
  Serial.println(distance);
  level =((14-distance)/14.0)*100;
  Serial.println("level");
  Serial.println(level);
  delay(1000);
  WiFiClient client = server.available();
  if (client) 
  { 
    Serial.println("Cliente da Web conectado");
    String request = client.readStringUntil('\r'); 
    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html");
    client.println("Connection: close");  // a conexão será fechada após a conclusão da resposta
    client.println("Refresh: 10");        // atualize a página após 10 segundos
    client.println();
    client.println("<!DOCTYPE HTML>");
    client.println("<html>");
    client.println("<style>html { font-family: Cairo; display: block; margin: 0px auto; text-align: center;color: #333333; background-color: ##f3ffee;}");
    client.println("body{margin-top: 50px;}");
    client.println("h1 {margin: 50px auto 30px; font-size: 50px;  text-align: center;}");
    client.println(".side_adjust{display: inline-block;vertical-align: middle;position: relative;}");
    client.println(".text1{font-weight: 180; padding-left: 5px; font-size: 50px; width: 170px; text-align: left; color: #3498db;}");
    client.println(".data1{font-weight: 180; padding-left: 1px; font-size: 50px;color: #3498db;}");
    client.println(".data{padding: 1px;}");
    client.println("</style>");
    client.println("</head>");
    client.println("<body>");
    client.println("<div id=\"webpage\">");   
    client.println("<h1>Jar baseado em Iot</h1>");
    client.println("<div class=\"data\">");
    client.println("<div class=\"side_adjust text1\">Status:</div>");
    client.println("<div class=\"side_adjust data1\">");
    client.print(level);
    client.println("<div class=\"side_adjust text1\">% Preenchido</div>");
    client.println("</div>");
    client.println("</div>");
    client.println("</body>");
    client.println("</html>");
    //client.println("<h1>Level Indicator</h1>");
    if ( level <= 10) {
        send_event("jar_event");
    }
  } 
}

void send_event(const char *event)
{
  Serial.print("Connecting to "); 
  Serial.println(host);
  // Use a classe WiFiClient para criar conexões TCP
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("Conexão falhou");
    return;
  }
  // Agora criamos um URI para a solicitação
  String url = "/trigger/";
  url += event;
  url += "/with/key/";
  url += privateKey;
  Serial.print("Solicitando URL: ");
  Serial.println(url);
  // Isso irá enviar a solicitação para o servidor
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" + 
               "Connection: close\r\n\r\n");
  while(client.connected())
  {
    if(client.available())
    {
      String line = client.readStringUntil('\r');
      Serial.print(line);
    } else {
      // Sem dados ainda, espere um pouco
      delay(50);
    };
  }
  Serial.println();
  Serial.println("fechando a conexão");
  client.stop();
}

 

Twittar
Compartilhar
Compartilhar
0 Compart.