Planta IoT com ESP8266 NodeMCU – Parte 1
Hoje vamos começar uma série de posts que vão compor a nossa Planta IoT, uma planta conectada à internet que avisa no seu celular quando precisa ser regada! Irado, né? Para isso será necessário um sensor de umidade do solo para medir a umidade do solo da planta e um módulo wifi ESP8266 NodeMCU para enviar os dados para a internet, simples assim 
Nessa primeira parte, vamos unir o ESP8266 NodeMCU ao ThingSpeak, mostrando como enviar dados da umidade da planta para a nuvem. Nos próximos posts você irá aprender como disparar as informações para o seu celular.
O módulo Wifi NodeMCU é uma das placas / plataformas mais populares para prototipação de soluções IoT. Conforme já mostrado neste blog, o NodeMCU funciona perfeitamente integrado ao MQTT, possibilitando controle e monitoramento remoto. Neste post, será mostrado como integrar o NodeMCU com outra grande plataforma de IoT: o ThingSpeak.
Como funciona o ThingSpeak?
O ThingSpeak é uma plataforma IoT que permite, sem custo algum, o upload de dados numéricos. Tais dados ficam armazenados na nuvem, onde então é permitido a visualização dos mesmos em gráficos em tempo real. Ou seja, se você deseja monitorar qualquer grandeza numérica (umidade, temperatura, pressão, etc.) à distância via Internet, o ThingSpeak é uma boa pedida. Vale ressaltar que o ThingSpeak está em constante evolução, portanto novos recursos podem ser adicionados a qualquer momento.
O ThingSpeak possui apenas uma limitação: o tempo entre upload de dados deve ser de, no mínimo, 15 segundos. Se isso for desobedecido, os dados enviados fora deste intervalo de tempo serão ignorados ou não registrados.
No projeto deste post os uploads serão feitos em intervalos de 30 segundos.
Upload de dados ao ThingSpeak
Para enviar dados ao ThingSpeak, faz-se uma requisição HTTP ao servidor do ThingSpeak. Uma requisição HTTP nada mais é que uma string (que contém as informações da requisição HTTP) enviada via socket TCP client (quem deseja fazer a requisição) a um socket TCP server (servidor que receberá a requisição, no caso o servidor do ThingSpeak) através da porta 80.
Outra informação importante é que, na requisição HTTP, constará uma chave de escrita para o canal ThingSpeak. Trata-se de uma string (única para cada canal), necessária para o ThingSpeak “saber” para qual canal direcionar os dados enviados.
Observação: o socket TCP estabelecido não tem grande tempo de vida. A conexão ao servidor termina assim que o mesmo envia a sua resposta à requisição. Ou seja, uma requisição HTTP foi feita para ter “vida curta”, sendo portanto destinado somente a um tráfego breve de dados entre socket TCP client e socket TCP server.
Planta IoT com ESP8266 NodeMCU
O projeto Planta IoT com ESP8266 NodeMCU consiste em fazer o NodeMCU enviar, a cada trinta segundos, a umidade percentual medida para um canal do ThingSpeak. Para este exemplo, criei um canal público (link), cuja chave de escrita é KGFP6X4JQTJZFIAP. Entretanto, recomendo fortemente você criar sua conta no ThingSpeak e criar seu próprio lá, assim você pode se divertir a vontade!
Esquema Elétrico da Planta IoT
Em termos de hardware, será necessário um NodeMCU, um sensor higrômetro, cinco resistores de 1k para o divisor de tensão, jumpers e protoboard. A alimentação é feita pelo cabo USB (o mesmo cabo utilizado na programação do NodeMCU). O sensor higrômetro é lido através do único pino de ADC do NodeMCU (A0), o que permite a leitura da umidade percentual (0 – 100%).
O divisor de tensão é necessário pois a tensão de saída A0 do sensor fornece 5V, enquanto a entrada analógica do NodeMCU aceita no máximo 1V. Você pode tentar outros valores de resistores, cuidando para que a tensão de saída seja de 1V. Utilize a calculadora de divisor de tensão deste link para realizar os cálculos de acordo com os resistores que você tem em mãos.
Observe o circuito esquemático abaixo, que será usado no projeto Planta IoT:
Programando o Módulo ESP8266 NodeMCU
Segue o código-fonte do projeto. Leia atentamente todos os comentários do mesmo.
#include <ESP8266WiFi.h> //essa biblioteca já vem com a IDE. Portanto, não é preciso baixar nenhuma biblioteca adicional
//defines
#define SSID_REDE " " //coloque aqui o nome da rede que se deseja conectar
#define SENHA_REDE " " //coloque aqui a senha da rede que se deseja conectar
#define INTERVALO_ENVIO_THINGSPEAK 30000 //intervalo entre envios de dados ao ThingSpeak (em ms)
//constantes e variáveis globais
char EnderecoAPIThingSpeak[] = "api.thingspeak.com";
String ChaveEscritaThingSpeak = "KGFP6X4JQTJZFIAP";
long lastConnectionTime;
WiFiClient client;
//prototypes
void EnviaInformacoesThingspeak(String StringDados);
void FazConexaoWiFi(void);
float FazLeituraUmidade(void);
/*
* Implementações
*/
//Função: envia informações ao ThingSpeak
//Parâmetros: String com a informação a ser enviada
//Retorno: nenhum
void EnviaInformacoesThingspeak(String StringDados)
{
if (client.connect(EnderecoAPIThingSpeak, 80))
{
//faz a requisição HTTP ao ThingSpeak
client.print("POST /update HTTP/1.1\n");
client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n");
client.print("X-THINGSPEAKAPIKEY: "+ChaveEscritaThingSpeak+"\n");
client.print("Content-Type: application/x-www-form-urlencoded\n");
client.print("Content-Length: ");
client.print(StringDados.length());
client.print("\n\n");
client.print(StringDados);
lastConnectionTime = millis();
Serial.println("- Informações enviadas ao ThingSpeak!");
}
}
//Função: faz a conexão WiFI
//Parâmetros: nenhum
//Retorno: nenhum
void FazConexaoWiFi(void)
{
client.stop();
Serial.println("Conectando-se à rede WiFi...");
Serial.println();
delay(1000);
WiFi.begin(SSID_REDE, SENHA_REDE);
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connectado com sucesso!");
Serial.println("IP obtido: ");
Serial.println(WiFi.localIP());
delay(1000);
}
//Função: faz a leitura do nível de umidade
//Parâmetros: nenhum
//Retorno: umidade percentual (0-100)
//Observação: o ADC do NodeMCU permite até, no máximo, 1V. Dessa forma,
// para 1V, obtem-se (empiricamente) 418 como leitura de ADC
float FazLeituraUmidade(void)
{
int ValorADC;
float UmidadePercentual;
ValorADC = analogRead(0); //418 -> 1.0V
Serial.print("[Leitura ADC] ");
Serial.println(ValorADC);
//Quanto maior o numero lido do ADC, menor a umidade.
//Sendo assim, calcula-se a porcentagem de umidade por:
//
// Valor lido Umidade percentual
// _ 0 _ 100
// | |
// | |
// - ValorADC - UmidadePercentual
// | |
// | |
// _|_ 418 _|_ 0
//
// (UmidadePercentual-0) / (100-0) = (ValorADC - 418) / (-418)
// Logo:
// UmidadePercentual = 100 * ((418-ValorADC) / 418)
UmidadePercentual = 100 * ((418-(float)ValorADC) / 418);
Serial.print("[Umidade Percentual] ");
Serial.print(UmidadePercentual);
Serial.println("%");
return UmidadePercentual;
}
void setup()
{
Serial.begin(9600);
lastConnectionTime = 0;
FazConexaoWiFi();
Serial.println("Planta IoT com ESP8266 NodeMCU").
}
//loop principal
void loop()
{
float UmidadePercentualLida;
int UmidadePercentualTruncada;
char FieldUmidade[11];
//Força desconexão ao ThingSpeak (se ainda estiver desconectado)
if (client.connected())
{
client.stop();
Serial.println("- Desconectado do ThingSpeak");
Serial.println();
}
UmidadePercentualLida = FazLeituraUmidade();
UmidadePercentualTruncada = (int)UmidadePercentualLida; //trunca umidade como número inteiro
//verifica se está conectado no WiFi e se é o momento de enviar dados ao ThingSpeak
if(!client.connected() &&
(millis() - lastConnectionTime > INTERVALO_ENVIO_THINGSPEAK))
{
sprintf(FieldUmidade,"field1=%d",UmidadePercentualTruncada);
EnviaInformacoesThingspeak(FieldUmidade);
}
delay(1000);
}
Resultado da Planta IoT no ThingSpeak
Após carregar o código fonte para o NodeMCU, abra o Serial Monitor (com baudrate em 9600 bauds) para acompanhar o que o NodeMCU está fazendo. Abra o site do canal também (no caso deste exemplo, o canal https://thingspeak.com/channels/137361), assim pode-se ver, em tempo real, cada chegada dos dados da nossa Planta IoT no gráfico.
O gráfico resultante será algo semelhante a figura abaixo:
Gráfico de umidade percentual x tempo
Sugestão
Este post utilizou-se de um canal ThingSpeak pré-definido / já criado. É fortemente recomendado que, ao reproduzir este projeto, você crie seu próprio canal ThingSpeak (o que implica em alterar a chave de escrita no código-fonte). Se isto não for feito, você estará fazendo upload de dados em um canal “público” / de demonstração, o que pode não garantir o funcionamento que deseja.
Gostou ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!
Site: Blog FILIPEFLOP