Envie dados do temperatura e umidade relativa do ar para o ThingSpeak com o ESP8266 8

O ESP8266 quebrou barreiras. Com ele, makers, hobistas e profissionais puderam prototipar e transformar em produtos sua soluções relacionadas a Internet das Coisas. Oferecendo processamento, memórias (Flash e RAM) e conectividade wi-fi à Internet, aliado a um preço muito competitivo, o ESP8266 rapidamente se popularizou como uma das mais indicadas plataformas para quem quer desenvolver projetos que exijam conectividade à Internet. Dentre as plataformas IoT existentes, uma das mais populares e simples de se usar é a ThingSpeak, a qual inclusive possui possibilidade de uso gratuito. Simplificadamente, o ThingSpeak permite o envio de dados numéricos a partir dos mais diferentes dispositivos (incluindo o ESP8266), permitindo a visualização de tais dados na forma de gráficos ao longo do tempo. Dessa forma, o ThingSpeak é uma das plataformas ideais para acompanhamento de dados numéricos de forma histórica / ao longo do tempo.

Este post vai unir estas duas coisas e te ensinar a enviar dados numéricos para o ThingSpeak. Isso será feito na forma de um projeto que envia a temperatura e umidade relativa do ar para a plataforma.

Material necessário

Para fazer o projeto aqui proposto, você precisará de:

Esse post assume que você já consegue programar o NodeMCU com a Arduino IDE. Se você ainda não sabe como fazer isso, confira este nosso post aqui do blog.

Para o projeto funcionar, você também precisará de uma rede Wi-Fi operante (a qual você já conheça o nome e senha). Pode ser a mesma rede wi-fi que você usa na sua casa, por exemplo.

Como funciona o ThingSpeak?

O ThingSpeak é uma plataforma IoT que permite, sem custo algum, o upload de dados numéricos, os quais serão plotados ao longo do tempo na forma de gráficos. Ou seja, se você deseja monitorar qualquer grandeza numérica (umidade, temperatura, pressão, luminosidade etc.) à distância via Internet, o ThingSpeak é uma das plataformas IoT mais indicadas.

O ThingSpeak possui tanto planos grátis quanto pagos (comerciais). Além de menores limitações, os planos comerciais oferecem suporte a uso do Matlab, algo que pode ser interessante dependendo da complexidade do processamento de dados numéricos que você precisa na plataforma IoT. De modo geral, o plano gratuito do ThingSpeak possui as seguintes limitações:

  • Envio máximo de 3 milhões de mensagens por ano ao ThingSpeak, o que resulta numa média de 8219 mensagens por dia (algo que deve ser suficiente para a grande maioria das aplicações em Internet das Coisas).
  • No máximo quatro canais (projetos diferentes) podem ser cadastrados.
  • O tempo entre o envio de duas mensagens não pode ser menor que 15 segundos. Se isso for desobedecido, os dados enviados fora deste limite mínimo de tempo serão ignorados / não registrados no ThingSpeak.

No projeto deste post os uploads serão feitos em intervalos de 30 segundos, de forma a estabelecer uma diferença de tempo bem segura (sem chance dos dados enviados não serem registrados no ThingSpeak) entre envios.

Upload de dados do ESP8266 ao ThingSpeak

Para enviar dados ao ThingSpeak, faz-se uma requisição HTTP (HyperText Transfer Protocol) ao servidor do ThingSpeak. Uma requisição HTTP nada mais é que uma string (que contém as informações da requisição HTTP) enviada de 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.

Na requisição HTTP podem ser enviados dados para mais de um gráfico por vez do mesmo canal. Para isso, observe o exemplo abaixo, que contém o payload / conteúdo de uma requisição HTTP:

field1=10&field2=5&field3=60

Neste exemplo, são enviados dados para três gráficos distintos, os quais são indicados pelos nomes field1, field2 e field3. Os dados a serem enviados são os números 10, 5 e 60. Para enviar os dados desses três gráficos numa só requisição HTTP, faz-se uso do conector &. Dessa forma, você consegue construir requisições HTTP para quaisquer números de gráficos no ThingSpeak.

Como o ThingSpeak possui a limitação de, no mínimo, 15 segundos de intervalo entre dois envios seguidos, o recurso de enviar vários dados de uma só vez (numa só requisição) torna-se muito interessante, ou até mesmo necessário (a depender do projeto).

Cadastro no ThingSpeak

Para utilizar a plataforma ThingSpeak, o primeiro passo é fazer o cadastro na plataforma. Para isso, acesse o site do ThingSpeak e preencha o cadastro. É muito importante que você informe seu e-mail verdadeiro, uma vez que todos os resgates de senha e autenticações são feitos utilizando tal e-mail. Se questionado, lembre-se de selecionar o plano grátis (free).

Feito isso, você terá acesso ao ThingSpeak. Agora, é preciso criar um canal. Um canal é uma espécie de espaço para seu projeto dentro do ThingSpeak, o qual contém seus gráficos e dados. Na barra superior, clique em “Channels”, conforme destacado na figura 1.

Figura 1 - menu de criação, edição e exclusão de canais no ThingSpeak
Figura 1 – menu de criação, edição e exclusão de canais no ThingSpeak

Feito isso, clique sobre o botão “New Channel”, conforme destacado na figura 2.

Figura 2 - botão de criação de um novo canal no ThingSpeak
Figura 2 – botão de criação de um novo canal no ThingSpeak

Preencha os dados requeridos sobre seu canal conforme mostra a figura 3.

Atenção na parte dos Fields: cada Field equivale a um gráfico diferente dentro de seu canal. Logo, como neste post iremos enviar os valores de temperatura e umidade relativa do ar, precisaremos de dois fields distintos.

Ao final do preenchimento dos dados, clique no botão “Save Channel”, em destaque na figura 3.

Figura 3 - cadastro de um canal no ThingSpeak
Figura 3 – cadastro de um canal no ThingSpeak

Seu canal está pronto para uso e a tela de administração do mesmo irá surgir.

Para enviar dados ao seu canal, só falta obter a chave de escrita (Write API Key). Esta chave é uma das informações usadas na requisição HTTP e está atrelada ao seu canal. Sem ela, não é possível enviar dados ao seu canal. Para obter a chave de escrita (Write API Key), clique sobre a aba API Keys e copie a informação do campo Write API Key, conforme indica a figura 4. Salve esta chave em local seguro, ela será necessária mais a frente neste post.

Figura 4 - chave de escrita de seu canal no ThingSpeak
Figura 4 – chave de escrita de seu canal no ThingSpeak

Pronto! Agora seu o canal do ThingSpeak já está preparado para receber os dados de temperatura e umidade relativa do ar vindos do ESP8266.

Instalação da biblioteca do sensor DHT22

Para fazer esse projeto, você precisará instalar as bibliotecas para se comunicar com o sensor DHT22.
Para isso, utilizando o gerenciador de bibliotecas da Arduino IDE, instale as seguintes bibliotecas:

  • Adafruit Unified Sensor
  • DHT Sensor Library by Adafruit

ESP8266 e ThingSpeak: Circuito esquemático

Monte o circuito esquemático do projeto conforme mostra a figura 5.

Figura 5 - circuito esquemático do projeto
Figura 5 – circuito esquemático do projeto

ESP8266 e ThingSpeak: Código-fonte

O código-fonte do projeto está abaixo.

  1. Leia atentamente os comentários presentes no código-fonte para total compreensão do mesmo.
  2. Não se esqueça de por a chave de escrita do ThingSpeak na seguinte linha:String chave_escrita_thingspeak = ” “; /* Coloque aqui sua chave de escrita do seu canal */
  3. Não se esqueça de por o nome e a senha da rede wi-fi nas seguintes linhas:#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 */
#include <ESP8266WiFi.h> //essa biblioteca já vem com a IDE. Portanto, não é preciso baixar nenhuma biblioteca adicional
#include <DHT.h>

/*
* Defines do projeto
*/
//GPIO do NodeMCU que o pino de comunicação do sensor está ligado.
#define DHTPIN D1

/* defines - wi-fi */
#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) */

/* A biblioteca serve para os sensores DHT11, DHT22 e DHT21.
* No nosso caso, usaremos o DHT22, porém se você desejar utilizar
* algum dos outros disponíveis, basta descomentar a linha correspondente.
*/

//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301

/* constantes e variáveis globais */
char endereco_api_thingspeak[] = "api.thingspeak.com";
String chave_escrita_thingspeak = " ";  /* Coloque aqui sua chave de escrita do seu canal */
unsigned long last_connection_time;
WiFiClient client;
DHT dht(DHTPIN, DHTTYPE);

/* prototypes */
void envia_informacoes_thingspeak(String string_dados);
void init_wifi(void);
void conecta_wifi(void);
void verifica_conexao_wifi(void);

/*
* Implementações
*/

/* Função: envia informações ao ThingSpeak
* Parâmetros: String com a informação a ser enviada
* Retorno: nenhum
*/
void envia_informacoes_thingspeak(String string_dados)
{
    if (client.connect(endereco_api_thingspeak, 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: "+chave_escrita_thingspeak+"\n");
        client.print("Content-Type: application/x-www-form-urlencoded\n");
        client.print("Content-Length: ");
        client.print(string_dados.length());
        client.print("\n\n");
        client.print(string_dados);
        
        last_connection_time = millis();
        Serial.println("- Informações enviadas ao ThingSpeak!");
    }
}

/* Função: inicializa wi-fi
* Parametros: nenhum
* Retorno: nenhum
*/
void init_wifi(void)
{
    Serial.println("------WI-FI -----");
    Serial.println("Conectando-se a rede: ");
    Serial.println(SSID_REDE);
    Serial.println("\nAguarde...");

    conecta_wifi();
}

/* Função: conecta-se a rede wi-fi
* Parametros: nenhum
* Retorno: nenhum
*/
void conecta_wifi(void)
{
    /* Se ja estiver conectado, nada é feito. */
    if (WiFi.status() == WL_CONNECTED)
    {
        return;
    }
    
    /* refaz a conexão */
    WiFi.begin(SSID_REDE, SENHA_REDE);
    
    while (WiFi.status() != WL_CONNECTED)
    {
        delay(100);
    }

    Serial.println("Conectado com sucesso a rede wi-fi \n");
    Serial.println(SSID_REDE);
}

/* Função: verifica se a conexao wi-fi está ativa
* (e, em caso negativo, refaz a conexao)
* Parametros: nenhum
* Retorno: nenhum
*/
void verifica_conexao_wifi(void)
{
    conecta_wifi();
}

void setup()
{
    Serial.begin(115200);
    last_connection_time = 0;

    /* Inicializa sensor de temperatura e umidade relativa do ar */
    dht.begin();

    /* Inicializa e conecta-se ao wi-fi */
    init_wifi();
}

//loop principal
void loop()
{
    char fields_a_serem_enviados[100] = {0};
    float temperatura_lida = 0.0;
    float umidade_lida = 0.0;

    /* Força desconexão ao ThingSpeak (se ainda estiver conectado) */
    if (client.connected())
    {
        client.stop();
        Serial.println("- Desconectado do ThingSpeak");
        Serial.println();
    }

    /* Garante que a conexão wi-fi esteja ativa */
    verifica_conexao_wifi();
    
    /* Verifica se é o momento de enviar dados para o ThingSpeak */
    if( millis() - last_connection_time > INTERVALO_ENVIO_THINGSPEAK )
    {
        temperatura_lida = dht.readTemperature();
        umidade_lida = dht.readHumidity();
        sprintf(fields_a_serem_enviados,"field1=%.2f&field2=%.2f", temperatura_lida, umidade_lida);
        envia_informacoes_thingspeak(fields_a_serem_enviados);
    }

    delay(1000);
}

Agora basta entrar no seu canal do ThingSpeak e observar as medições de temperatura e umidade relativa do ar chegarem!

Recapitulando: o programa acima faz uso da conexão Wi-Fi para enviar a temperatura e umidade relativa do ar para a plataforma IoT ThingSpeak. O envio é feito a cada 30 segundos, de forma a respeitar (com segurança) o limite mínimo de tempo de envio da plataforma.
Dessa forma, com o programa aqui mostrado, você poderá monitorar, de qualquer lugar do mundo, a temperatura e umidade relativa do ar de qualquer local que você deseja, desde que tal local possua conectividade Wi-Fi à Internet.

Gostou deste post sobre como usar o ThingSpeak com o ESP8266? Deixe seu comentário logo abaixo. Em caso de dúvidas, caso queira trocar uma ideia, ou até mesmo dividir seu projeto, acesse nosso Fórum!

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

8 Comentários

  1. Show de bola, funcionou 100% obg por compartilhar e ainda tudo facil e em portugues.

  2. Na figura 5 – circuito esquemático do projeto, mostra o NodeMcu conectado apenas no computador.

    A minha dúvida é a seguinte, após tudo gravado e testado, posso alimentar meu NodeMcu no carregador do meu celular? Sendo que nele está escrito que fornece 5V e 2A?

    1. Adriano, boa tarde.

      Sim, depois de gravado você pode alimentar o NodeMCU no carregador de celular, desde que este tenha tensão de saída 5V e corrente de saída maior ou igual a 2A.

  3. Muuuuuuuuiiitooooo show, brother. Rodou liso. Parabéns pelo código e pela transmissão do conhecimento. Ajudou muito, vc nem sabe o quanto.

    1. Adriano,

      Que bom que pudemos ajudar!!

      Abraços!
      Diogo – Equipe FilipeFlop

  4. Amigo, fiz tudo igual.
    Mas no site do thingspeak não aparece dados…
    o que pode ter acontecido?
    obrigado

  5. No serial aparece isso:
    3:44:44.189 -> Conectando-se a rede:
    13:44:44.189 -> VIRUS
    13:44:44.189 ->
    13:44:44.189 -> Aguarde…
    13:44:48.116 -> Conectado com sucesso a rede wi-fi
    13:44:48.150 ->
    13:44:48.150 -> VIRUS
    13:45:14.199 -> – Informações enviadas ao ThingSpeak!
    13:45:15.214 -> – Desconectado do ThingSpeak
    13:45:15.214 ->
    13:45:44.272 -> – Informações enviadas ao ThingSpeak!
    13:45:45.293 -> – Desconectado do ThingSpeak
    13:45:45.293 ->

    Mas lá no site dos dados continua zero entrada