Tutorial de IoT: Mostrador RGB de Temperatura usando ESP8266

Olá garagistas,

Neste tutorial vamos usar o módulo ESP8266 para fazer um projeto de "Internet das Coisas" (IoT, em inglês). Vamos conectá-lo à internet via Wi-Fi e adquirir dados de temperatura de diferentes cidades através de uma API disponível na web. Com esses dados, vamos variar a cor de um LED RGB de acordo com a temperatura recebida.

Recomendamos que já se tenha feito o tutorial anterior sobre como começar a utilizar o módulo ESP8266 com a IDE do Arduino. Link aqui

Materiais Utilizados:

1x Módulo GarageLab ESP8266 Breakout

1x Conversor USB/Serial do Garagino

1x Suporte para 4 pilhas AA

1x LED RGB

2x Chaves Tácteis

2x Resistor de 10K

4x Resistor de 330R

1x Resistor de 180R

2x Capacitores de 10uF

1x Regulador de tensão LM1117

Alguns jumpers

Vamos utilizar o Protocolo de Transferência de Hipertexto (HTTP, em inglês) para fazer a conversa entre o dispositivo e a API. Este protocolo é muito utilizado para a transferências de páginas HTML da internet para o computador, e é usado para sistemas de informação de hipermídia, distribuídos e colaborativos, sendo a base para a comunicação de dados da World Wide Web.

No sketch usamos esse protocolo para se conectar à API da Open Weather Map (OWM) e assim solicitar o envio de dados de temperatura de uma cidade qualquer, definida pelo usuário. Para noções mais profundas de HTTP recomenda-se o tutorial deste link.

O LED RGB possui, em um único encapsulamento, três LEDs, um de cada cor básica, Vermelho (Red), Verde (Green) e Azul (Blue). Com a combinação destes LEDs pode-se formar quase qualquer cor, apenas alterando a intensidade luminosa de cada um deles. Para este projeto vamos fazer o LED variar em uma escala de cores de vermelho, para altas temperaturas, a azul, para baixas temperaturas.

Uma Interface de Programação de Aplicativos (API, em inglês) é um conjunto de rotinas de programação utilizados para acessar um aplicativo. Muitas empresas disponibilizam API´s na internet com a finalidade de se obter temperaturas, que podem ser pagas ou não, e assim desenvolvedores podem usar de seus serviços no desenvolvimento de produtos.

A OWM, assim como outras empresas, exige que se faça um cadastro em seu site para usar sua API, o cadastro é gratuito e rápido. Com o cadastramento feito pode-se encontrar no site a APPID, que é uma chave pessoal de acesso a API, e assim finalmente usar a API em seu programa ou site.

http://openweathermap.org/

Utilizando essa API vamos fazer a leitura de temperatura de uma cidade qualquer e então fazer um LED RGB variar a cor dependendo da temperatura. Se a temperatura estiver muito baixa, o LED vai ficar na cor azul, se a temperatura estiver muito alta o LED vai ficar na cor vermelha. Para temperaturas amenas, teremos uma combinação dessas cores. Como o LED trabalha com PWM que varia de 0 a 255, vamos utilizar fórmulas para alterar a intensidade dos LED´s azul e vermelho, deixando o verde sempre em 0.

O LED vermelho vai variar proporcionalmente com a temperatura multiplicado por 7. Assim quando a temperatura for 35 ºC a intensidade do LED vermelho será 245. O LED azul vai variar pela fórmula abaixo, e assim para uma temperatura de 35 ºC a intensidade do LED azul será 0. Para uma temperatura de 5º C o LED vermelho terá uma intensidade de 35 e o azul de 240, e assim o LED RGB terá uma luz azul forte.

vermelho = temperatura*7

azul = (35-temperatura)*8 

A montagem do circuito será similar a montagem feita no primeiro tutorial sobre o ESP8266.

Os pinos VCC, CH_PD e GPIO2 devem sempre estar em nível lógico alto, os pinos GND e GPIO15 devem sempre estar em nível baixo. Os pinos REST e GPIO0 devem estar em pull up, estes pinos vão ser usados para colocar o módulo em modo de programação. O módulo ESP8266 e o módulo conversor USB/Serial e suas pinagens são mostrados na figura abaixo, respectivamente:

Os pinos TXD e RXD do conversor serão ligados nos pinos RX e TX do módulo ESP8266 respectivamente. É importante lembrar que a maioria dos módulos USB/Serial trabalham com 5V, como é o caso do conversor USB/Serial do Garagino, então a saída TX do conversor deve passar por um divisor de tensão, rebaixando o seu nível para 3.3V, tensão de operação do módulo ESP8266. Nós utilizamos um divisor de tensão com resistores de 330R e 180R. Esse divisor de tensão é utilizado apenas na linha TXD do módulo conversor já que na "volta" receberá 3.3V do módulo ESP8266 e será "entendido" como nível HIGH.

Neste tutorial usaremos o pino GPIO 14, será ligado a um resistor de 330R e este será ligado em série com a entrada vermelha do LED RGB, o pino GPIO 12 será ligado da mesma forma, porém na entrada verde do LED. O pino GPIO 13 será ligado da mesma forma na entrada Azul do LED, conforme figura.

O código que usaremos será o abaixo.

#include <ESP8266WiFi.h> //Inclui a Biblioteca ESP8266

const char* rede = "SSID DA SUA REDE WI-FI"; //Cria o vetor de char rede
const char* senha = "SENHA DA SUA REDE WI-FI";//Cria o vetor de char senha
String site = "api.openweathermap.org"; //Cria a string site
String resposta, stempk, cod;

#define vermelho 14 //Define os pinos do LED
#define verde 12
#define azul 13
WiFiClient cliente; //Cria o objeto cliente
int incod, tempk, tempc, postemp, quente, frio;

void setup()
{

Serial.begin(9600);// inicializa a porta serial com 9600 baud
Serial.println();
pinMode(vermelho,OUTPUT);// Define os pinos como saída
pinMode(verde,OUTPUT);
pinMode(azul,OUTPUT);
Serial.print("Conectando a rede ");
Serial.println(rede);

WiFi.begin(rede, senha);//conecta a Rede

Serial.println("Aguardando conexao com o roteador...");
while (WiFi.status() != WL_CONNECTED)//imprime na serial "-" enquanto o modulo não se conectar a rede
{
delay(500);
Serial.print("-");
}
Serial.print("\nWi-Fi conectado. IP: ");
Serial.println(WiFi.localIP());//Imprime o IP
}

void loop()
{
Serial.print("Entre com o codigo da cidade.");//Solicita ao usuario entrar com o cód da cidade
/* Moscou - 5202009
* Atenas - 264371
* Pequim - 1816670
* Cancum - 3531673
* Nova York - 5106292
* Cairo - 360630
* Helsinque - 658224
* Barueri - 3470353
* Manaus - 3663517
* Fortaleza - 3399415
* Itaporanga - 3460666
* São Paulo - 3448433
* Porto Alegre - 3452925
* Rio de Janeiro - 3451189
* Brasilia - 3469058
*/
while(!Serial.available());//Aguarda o cód da cidade na entrada serial

while(Serial.available()){//Guarda todos os caractes car da entrada da serial na String cod

char car = Serial.read();
cod = cod + car;
delay(100);

}
incod = cod.toInt();//Transforma a String cod em um inteiro incod
Serial.println("\nAguardando conexao com o servidor...");
while (!cliente.connect(site.c_str(), 80))//Aguarda a conexão imprimindo |
{
delay(500);
Serial.print('|');
}
if (cliente.connect(site.c_str(), 80))//
{
Serial.println();
Serial.println("Enviando requisicao HTTP"); // Solicia do servidor informações de sobre o tempo
cliente.print("GET /data/2.5/weather?");
cliente.print("id=");
cliente.print(incod);
cliente.println("&APPID=COLOQUE AQUI SUA APPID ");//APPID adquirida no site da OWP
cliente.print("HTTP/1.0\r\n");
cliente.print("Host: " + site + "\r\n\r\n");
cliente.print("Connection: close");

Serial.println("Aguardando resposta do servidor...");
while (!cliente.available())
{
Serial.print('*');
delay(500);
}
while (cliente.available())//Lê a resposta da API e guarda todos os caractéres na String resposta
{
char c = cliente.read();
resposta += c;
}
}
postemp = resposta.indexOf("temp");//Encontra na resposta o índice que começa com temp
stempk = resposta.substring(postemp + 6, postemp + 13);//Obtem da resposta uma String com o valor da temperatura em kelvin
tempk = stempk.toInt();//Transforma a stempk em int
tempc = tempk - 273;//tranforma a temperatura para Celsius
Serial.print("Temperatura e ");
Serial.println(tempc);
Serial.print("\n\n\n\n\n\n");

quente = tempc*7;//converte a temperatura para a leitura no LED
frio = (35-tempc)*8;

if(tempk<273)//Se a temperatura for menor que 0 ºC desliga o led vermelho e o led azul fica com o valor máximo
{
quente = 0;
frio = 255;
}

if(tempk>308)//Se a temperatura for maior que 35 ºC desliga o led azul e o led vermelho fica com o valor máximo
{
quente = 255;
frio = 0;
}


analogWrite(azul,frio);
analogWrite(vermelho,quente);
delay(5000);
cod = "";//Limpa a String
stempk = "";
resposta = "";

}

Para adicionar o código ao módulo é necessário colocá-lo em módulo de programação, para fazer isso deve-se segurar o botão da esquerda (GPIO0) pressionado, e então pressionar o botão da direita (Reset). Finalmente pode-se carregar o programa no módulo apertando “upload” na IDE do Arduino. Agora deve-se abrir a janela do serial monitor, a seguinte mensagem vai aparecer.

Deve-se então colocar o código da cidade, que está comentado dentro do sketch, na entrada da serial monitor e clicar em “Send”. Para o exemplo foi utilizado o Código da cidade de São Paulo (3448433), a janela abaixo deverá aparecer.

Agora deve-se abrir a janela do serial monitor, a seguinte mensagem vai aparecer.

A temperatura obtida de São Paulo foi 33 ºC e isso fez o LED RGB bem vermelho.

Muitos projetos podem ser feitos com esta mesma API, já que ela retorna muitas informações diferentes, como informações de humidade, velocidade do vento, pressão. Portanto pode-se incrementar muito o programa.

No link, pode-se baixar uma lista com os códigos de várias cidades diferentes. Esperamos ter ajudado a formar uma base e com os conceitos vistos neste tutorial já se pode começar a trabalhar em projetos mais complexos.

Bons projetos!

Referências:

http://openweathermap.org/appid#use

http://labdegaragem.com/profiles/blogs/tutorial-led-rgb-com-arduino

https://www.arduino.cc/en/Reference/WiFi

http://labdegaragem.com/profiles/blogs/tutorial-esp8266-programando...

Exibições: 3814

Comentar

Você precisa ser um membro de Laboratorio de Garagem (arduino, eletrônica, robotica, hacking) para adicionar comentários!

Entrar em Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)

Comentário de Marlon Tiedt em 17 novembro 2015 às 12:01

Parabéns pelo post. Aproveitando o mesmo para compartilhar algumas dúvidas sobre IoT e gostaria da opinião de vocês.

Vi uma palestra que se falou da casa conectada, e do ar condicionado ser ligado a partir da proximidade do "dono" com a casa.

Também foi comentado de programar para encher a banheira, mas no caso da banheira, o que eu mandaria para "internet das coisas"?

A quantidade de vezes que enchi a banheira? A quantidade de água usada? O consumo elétrico?

Vi outro vídeo, que se falou máquinas conversando entre sim, "M2M", sobre que o uma tomada poderia informar ao equipamento, se o mesmo pode ser ligado na tomada, ou se o consumo aumentar enviar um alerta para a central.
Neste caso seria somente uma automação? Ou o fato de enviar para um central conectada na internet vira IoT?

Além disto, uma central local, intranet vale? Pensando em uma empresa, que deseja deixar os dados locais, chão de fabrica, que tem seu sensores e estes são usados para monitorar e executar ações, embora não tenha internet, seria o mesmo conceito? Ou não?

Para o hardware ser considerado IoT, o dispositivo deve enviar/receber comandos da internet ou somente enviando leituras ele é IoT?

Se ele tem que enviar e receber dados, como ele é cliente, ele vai tempo na "nuvem" e busca se tem alguma ação para ele, ou ele tem que receber comandos externos?

Destaques

Registre-se no
Lab de Garagem
Clicando aqui

Convide um
amigo para fazer
parte

curso gratis de arduino

© 2019   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço