Capitulo 9788575226803 by Ana Carolina Prates

Catalin Batrinu

Novatec

Copyright © Packt Publishing 2017. First published in the English language under the title “ESP8266 Home Automation Projects – (9781787282629) Copyright © Packt Publishing 2017. Publicação original em inglês intitulada “ESP8266 Home Automation Projects – (9781787282629) Esta tradução é publicada e vendida com a permissão da Packt Publishing. © Novatec Editora Ltda. [2018]. Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora. Editor: Rubens Prates OG20180523 Tradução: Cláudio José Adas Revisão gramatical: Smirna Cavalheiro Editoração eletrônica: Carolina Kuwabata ISBN: 978-85-7522-680-3 Histórico de impressões: Junho/2018

Primeira edição

Novatec Editora Ltda. Rua Luís Antônio dos Santos 110 02460-000 – São Paulo, SP – Brasil Tel.: +55 11 2959-6529 Email: novatec@novatec.com.br Site: www.novatec.com.br Twitter: twitter.com/novateceditora Facebook: facebook.com/novatec LinkedIn: linkedin.com/in/novatec

capítulo 1

Introdução ao ESP8266

É impossível não ter ouvido falar de Internet das Coisas (IoT em inglês), que está começando a entrar em nossas casas e nossas vidas, junto com a necessidade de consumir e controlar uma enorme quantidade de dados todos os dias. Todos nós usamos um smartphone conectado à internet e somos capazes de instantaneamente encontrar e nos conectarmos com pessoas ao redor do mundo. Se somos capazes de nos conectar e conversar com pessoas ao redor do mundo, por que não controlar nossas casas, nossos carros e nossos escritórios a partir de nosso smartphone? É aí que a IoT entra em cena e nos permite conectar quase qualquer objeto à internet. Atualmente existem no mercado alguns chips que são capazes de conexão com a internet, mas um pequeno processador chamou a atenção dos desenvolvedores graças a seus recursos e preço. Este chip é o ESP8266, um microcontrolador de baixo custo com recursos de TCP/IP e Wi-Fi, desenvolvido pela EspressIf Systems, uma empresa localizada em Xangai, e descobriremos mais sobre ele neste livro. Neste capítulo, cobriremos os seguintes tópicos: • Instalar o Arduino IDE. • Configurar o Arduino IDE para o ESP8266. • Descobrir o ESP8266. • Conectar seu ESP a uma rede Wi-Fi.

Introdução ao chip ESP8266 Para começar a trabalhar com o ESP8266, você precisará de uma série de componentes de software e hardware. O ESP8266 é um microcontrolador RISC de 32 bits 16

Capítulo 1 ■ Introdução ao ESP8266

e baixo custo com conectividade Wi-Fi, capaz de funcionar a 80 MHz ou 160 MHz. Ele tem 64 KiB de RAM para instruções e 96 KiB de RAM para dados. Para o firmware e outros armazenamentos de dados, uma memória flash QSPI externa é conectada a ele e o tamanho pode variar entre 512 KiB e 4 MiB. O próprio chip tem 16 pinos GPIO (pinos e entrada/saída de uso geral), mas alguns deles são usados para conexão com a memória flash QSPI. Os demais pinos podem funcionar como Interface Serial Periférica (SPI), I2C, I2S, Receptor/Transmissor Universal Assíncrono (UART) e um Conversor Analógico-Digital (ADC) de 10 bits. A conectividade Wi-Fi é compatível com o padrão IEEE 80.11 b/g/n e oferece autenticação WPA/WPA2 e WEP, mas também pode se conectar a redes abertas. Para este capítulo você só precisa de um módulo ESP8266 de sua escolha, já que atualmente existem muitos fabricantes e tipos de placa disponíveis. Uma boa placa pode ser encontrada em Sparkfun.com ou em sites de e-commerce, como banggood.com ou aliexpress.com, mas não deixe de procurá-las em sua loja local de eletrônicos. O fator de forma de sua placa depende de suas restrições de projeto, mas, para começar com este chip, podemos usar uma das seguintes placas: • Witty ESP12-F. • NodeMCU v1.0. • WeeMos D1 mini. Qualquer uma dessas placas funciona bem, mas se você é um novato, recomendo começar com a placa Witty ESP12-F, pois ela já tem: • LDR (fotorresistor) conectado ao pino de entrada analógica A0. • LED RGB conectado ao GPIO 15, GPIO 12 e GPIO13. • Um botão de pressão conectado ao GPIO 4. Mais tarde, quando adicionarmos outros sensores ao ESP8266, este módulo pode ser substituído por qualquer um dos outros módulos ESP8266.

Instalar o Arduino IDE O ESP8266 pode ser usado com os SDKs oficiais da EspressIf que contêm SDKs NonOS (sem sistema operacional) e SDKs FreeRTOS para escrever código em

Projetos de Automação Residencial com ESP8266

C/C++, mas outras empresas e pessoas acrescentam outras linguagens de programação a ele, como Lua, Javascript ou MicroPhyton. Este livro usará o SDK NonOS e como um IDE de desenvolvimento o Arduino IDE. Nesta parte você irá baixar o software do Arduino (IDE), configurá-lo e instalar o SDK para ESP8266.

Baixar o software Arduino IDE Para baixar o Arduino IDE, vá para https://www.arduino.cc/en/Main/Software e baixe a versão mais recente (Figura 1.1):

Figura 1.1

Você pode baixar a versão desejada dependendo de seu sistema operacional. Existem versões para Windows com e sem direitos de administrador, macOS X, e Linux de 32 bits, 64 bits, ou processadores ARM de modo que você possa instalar e trabalhar mesmo em um Raspberry Pi. Depois de baixar o Arduino IDE, é preciso instalá-lo em seu computador local. Se você estiver no Linux, é preciso usar os comandos xz e tar para abrir o arquivo do Arduino IDE, então você pode ir para o Arduino-1.8.2 e iniciá-lo com sudo ./arduino. No Windows, basta iniciar o arquivo executável do Arduino (Figura 1.2). Parabéns! Você instalou o Arduino IDE e agora chegou o momento de configurá-lo para o ESP8266.

Configurar o Arduino IDE Para configurar o Arduino IDE para o ESP8266 é preciso ir para File | Preferences (Arquivo | Preferências) (Figura 1.3).

Capítulo 1 ■ Introdução ao ESP8266

Figura 1.2

Figura 1.3

Projetos de Automação Residencial com ESP8266

Nesta tela, você pode personalizar alguns campos desta maneira: • Sketchbook location: aqui você pode escolher o local onde os arquivos de seu projeto são armazenados. • Editor language: se preferir outro idioma diferente do padrão, você pode mudar este campo; mas depois você precisa reiniciar o IDE. • Editor font size: este é o tamanho da fonte usada no IDE. • Show verbose output during: compilation and upload: sugiro marcar ambas as opções para obter uma saída detalhada durante a compilação, quando é possível ver os arquivos, seus caminhos e também a carga. • Display line numbers: este campo é bom para ver o número da linha do lado direito de seu número IDE. • Enable Code Folding: este campo proporciona mais espaço na tela. • Additional Boards Manager URLs: este é o campo que permite obter e instalar o compilador ESP8266 Xtensagcc, as ferramentas necessárias para carregar o firmware obtido na memória flash do ESP8266 junto com outros tipos de placas. Neste campo você precisa acrescentar http://arduino.esp8266.com/stable/ package_esp8266com_index.json e a tela Preferences se parecerá assim (Figura 1.4):

Figura 1.4

Capítulo 1 ■ Introdução ao ESP8266

Depois de definir suas preferências, você pode clicar no botão OK. Não se esqueça de que você está atrás de um servidor proxy; é preciso preencher os detalhes necessários na guia Network (Rede).

Instalar o SDK para o ESP8266 Depois de configuradas as preferências, chegou o momento de realmente obter o SDK e as ferramentas para o ESP8266. Para isso, é preciso ir até o seguinte caminho e seguir estes passos: 1. Vá para Tools | Board: “Arduino/Genuino Uno” | Boards Manager... (Figura 1.5):

Figura 1.5

2. Em seguida a página Boards Manager (Gerenciador de placas) será aberta. 3. Vá para o final da lista e selecione a placa ESP8266 e clique em Install (Figura 1.6):

Projetos de Automação Residencial com ESP8266

Figura 1.6

4. Agora, dependendo de sua conexão de internet, isto pode levar um tempo. Aguarde e relaxe, você está prestes a entrar no mundo da IoT. 5. Aguarde a mensagem INSTALLED, como exibido na Figura 1.7:

Figura 1.7

6. Agora volte para Tools | Board: “Arduino/Genuino Uno” e você deve ver várias placas baseadas no ESP8266 na seção inferior (Figura 1.8):

Capítulo 1 ■ Introdução ao ESP8266

Figura 1.8

7. Selecione NodeMCU 1.0 (ESP-12E Module) e volte para o menu Tools, onde você verá outras configurações possíveis para o ESP8266: • CPU Frequency: “80 MHz”: este campo pode ser mudado de 80 MHz para 160 MHz. • O tamanho de memória de seu módulo e o tamanho dos SPIFFS (1 ou 3 MiB). • A velocidade de carga da interface UART entre seu computador e o módulo ESP8266. Selecione uma opção no campo Upload Speed: “115200” de modo que o arquivo binário seja carregado 8 vezes mais rápido que o valor padrão de 115200:

Projetos de Automação Residencial com ESP8266

Figura 1.9

8. Se você tiver um módulo, é possível conectá-lo ao seu computador. Voltando ao menu Tools, você verá isso no menu Port e poderá selecionar sua interface serial conectada ao módulo ESP8266. Para o Linux, você pode selecionar / dev/ttyUSB0 e para o Windows, uma de suas portas COM. Antes de começar qualquer programa, vamos observar os botões do IDE (Figura 1.10):

Figura 1.10

Comecemos da esquerda para a direita: • Verify: este botão permite compilar e verificar se há erros em seu código. • Upload: este botão executa as funções do botão Verify e carrega o firmware gerado na memória flash do ESP8266. • New: este botão abre uma nova janela para que você possa criar outro programa. • Open: este botão abre um programa existente em seu disco local. • Save: este botão salva seus arquivos no disco.

Capítulo 1 ■ Introdução ao ESP8266

• Serial Monitor: este botão abre uma janela, na qual será possível ver e depurar o que você adicionou ao seu programa.

Como instalar uma biblioteca Em alguns capítulos deste livro, são necessárias diferentes bibliotecas; vejamos como uma biblioteca pode ser instalada. O SDK instalado contém algumas bibliotecas básicas, mas certamente você precisará de mais bibliotecas para ler vários sensores, para analisar dados JSON ou para enviar mensagens MQTT. Para as bibliotecas que são referenciadas no repositório do SDK, basta instalá-las, mas as demais precisam ser instaladas manualmente.

Bibliotecas do repositório do Arduino Algumas bibliotecas existem no repositório oficial e você pode instalá-las seguindo estes passos: 1. Se ela já existe, vá para Sketch | Include Library | Manage Libraries (Figura 1.11):

Figura 1.11

2. Em uma nova janela, limpe o campo “Filter your search...” e digite Arduino Json. O Arduino IDE irá então procurar esta biblioteca para você e, se encontrar, poderá instalá-la clicando sobre ela. Você também pode usar este menu para atualizar uma biblioteca instalada anteriormente ou trocar as versões de uma biblioteca:

Projetos de Automação Residencial com ESP8266

Figura 1.12

3. Depois que a biblioteca estiver instalada, você verá a seguinte tela (Figura 1..13):

Figura 1.13 Como um exercício, faça o mesmo para as bibliotecas WiFiManager e PubSubClient.

Biblioteca não está no repositório Às vezes, a biblioteca que você precisa não está no repositório oficial, mas você pode encontrá-la em http://github.com como um arquivo ZIP. Para instalar a biblioteca, neste caso, é preciso seguir estes passos: 1. Baixe o arquivo ZIP e instale-o manualmente. Para isso, vá até Sketch|Include Library|Add .ZIP Library... e selecione biblioteca baixada em seu disco e pressione Open.

Capítulo 1 ■ Introdução ao ESP8266

2. Inclua uma biblioteca existente. 3. Para incluir uma biblioteca existente, vá para Sketch | Include Library e selecione a biblioteca que deseja incluir em seu sketch. 4. O arquivo .h será adicionado ao seu sketch e agora você tem acesso à função a nesta biblioteca para usá-la em seu próprio programa:

Figura 1.14

Chegou a hora de seu primeiro programa Para começar, vamos avaliar a entrada e saída básicas do módulo Witty ESP8266 (Figura 1.15). A definição dos pinos é a seguinte: o fotorresistor (LDR) no Witty está conectado ao pino A0 (a entrada analógica), o botão de pressão está conectado ao GPIO 4, e os LEDs estão conectados aos pinos GPIO 12, GPIO 13 e GPIO 15. Apague tudo que está em seu Arduino IDE e substitua pelo seguinte código: #define #define #define #define #define

LDR BUTTON RED GREEN BLUE

A0 4 15 12 13

A função setup será executada uma única vez depois que o módulo for reiniciado ou ligado. A interface serial UART é iniciada com 115200 bps para que as mensagens

Projetos de Automação Residencial com ESP8266

possam ser vistas na janela do Monitor Serial, onde também é preciso configurar a mesma velocidade no canto inferior direito da janela; caso contrário, caracteres estranhos serão exibidos.

Figura 1.15

Todos os pinos são configurados como INPUT ou OUTPUT (entrada ou saída), dependendo de seu uso. O botão e o LDR são configurados como pinos de entrada e todos os pinos conectados a LEDs são configurados como saída: void setup() { Serial.begin(115200); pinMode(LDR, INPUT); pinMode(BUTTON, INPUT); pinMode(RED, OUTPUT); pinMode(GREEN, OUTPUT); pinMode(BLUE, OUTPUT); }

A função loop() é executada continuamente depois da função setup() e nela: 1. A função analogRead lê o valor da luz ambiente fornecido como 0-1 V pelo LDR.

Capítulo 1 ■ Introdução ao ESP8266

2. A função digitalRead lê o valor do pino GPIO 4, que pode ser 0 V quando o botão estiver pressionado ou 3,3 V se o botão não estiver pressionado. 3. Os dados são exibidos no Monitor Serial com a função Serial.print. A função Serial.println apenas adiciona uma nova linha. 4. Um valor aleatório entre 0 e 1023 é escrito nos pinos GPIO 15 e GPIO 12 para controlar a intensidade de cor dos LEDs vermelho e verde. Trata-se da Modulação por Largura de Pulso (PWM). 5. É aceso o LED azul conectado ao GPIO 13. 6. Aguarda-se 1000 ms (um segundo). 7. É apagado o LED azul e retornamos ao passo 1: void loop() { Serial.print("LDR: "); Serial.println(analogRead(LDR)); Serial.print("BUTTON: "); Serial.println(digitalRead(BUTTON)); analogWrite(RED, random(0,1023)); analogWrite(GREEN, random(0,1023)); digitalWrite(BLUE, HIGH); delay(1000); digitalWrite(BLUE, LOW); }

Para compilar e carregar o código binário no chip ESP8266 é preciso pressionar o botão Upload.

Ver os resultados Na janela do Monitor Serial, como mostrado na Figura 1.16, podemos ver os valores da luz ambiente e o status do botão, em que 0 significa pressionado e 1 significa não pressionado. Se você não tiver um módulo Witty, precisará de alguns componentes extras como resistores, LEDs, botões de pressão e sensores LDR, de acordo com o diagrama mostrado na Figura 1.17.

Projetos de Automação Residencial com ESP8266

Figura 1.16

Vamos rever as funções que permitem controlar os pinos GPIO e a função que exibirá os valores no Monitor Serial: • analogRead(pin): lê o valor do pino A0. • digitalRead(pin): lê o valor de um pino específico, LOW ou HIGH. • digitalWrite(pin, value): escreve um valor LOW ou HIGH em um pino digital. • Serial.println (val): envia dados por uma porta serial na forma de caracteres ASCII legíveis, terminando por um \r e um caractere de nova linha \n. Usando a função analogWrite(val), em que val está no intervalo entre 0 e 1023, um pino de saída digital PWM terá uma tensão entre 0 e 3,3V com 1023 incrementos.

Capítulo 1 ■ Introdução ao ESP8266

Figura 1.17

Conectar o ESP8266 ao Wi-Fi Até agora você instalou e configurou o Arduino IDE para o ESP8266 e aprendeu como controlar um LED, ler uma entrada analógica e alterar o brilho de um LED. Agora chegou o momento de conectar o ESP8266 ao Wi-Fi. Inclua a biblioteca Wi-Fi do ESP8266 e configure o nome SSID e a senha do Wi-Fi: #include <ESP8266WiFi.h> const char* ssid = "your_wifi_name"; const char* password = "your_wifi_password";

Na seção setup, o objeto Serial é iniciado e configurado para enviar dados a 115200 bps; um atraso de 10 ms é adicionado para permitir que Serial termine e os pinos GPIO de 12 a 15 são configurados como saída e seus valores são definidos como LOW: void setup() { Serial.begin(115200); delay(10); pinMode(12, OUTPUT);

Projetos de Automação Residencial com ESP8266 pinMode(13, OUTPUT); pinMode(14, OUTPUT); pinMode(15, OUTPUT); digitalWrite(12,LOW); digitalWrite(13,LOW); digitalWrite(14,LOW); digitalWrite(15,LOW);

Começaremos conectando a uma rede Wi-Fi: Serial.println(); Serial.println(); Serial.print("Connecting to "); Serial.println(ssid); WiFi.begin(ssid, password);

Aguardamos até que o status indique que o ESP8266 está conectado à rede Wi-Fi. Em seguida, a mensagem Wi-Fi connected é exibida com o endereço IP atribuído a ele pelo roteador. Seu roteador precisa ser compatível com DHCP e ter o recurso DHCP ativado: while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected"); Serial.println("IP address: "); Serial.println(WiFi.localIP()); }

Na seção loop, o código verifica se o chip está conectado ao Wi-Fi e, em caso afirmativo, o LED verde será aceso no módulo Witty: void loop() { if(WiFi.status() == WL_CONNECTED) digitalWrite(12, HIGH); }

Como um exercício, você pode acender o led VERMELHO se não houver conectividade com seu roteador, e o LED verde caso contrário.

Capítulo 1 ■ Introdução ao ESP8266

O Monitor Serial exibirá o endereço IP atribuído pelo roteador, como mostrado na Figura 1.18):

Figura 1.18

Obter dados da Internet Agora que conectamos o ESP8266 à rede Wi-Fi, podemos receber e enviar dados pela internet. Além disso, podemos ler dados da entrada ou de sensores ligados à placa e enviar seus valores para a internet. Primeiro, vamos ler alguns dados e não há nada mais interessante que os dados atuais da previsão do tempo. Vamos criar uma conta no site http://www.wunderground.com e então acessar https://www.wunderground.com/weather/api/d/pricing.htm, onde você comprará uma chave por US$ 0, como mostrado na Figura 1.19. Depois de preencher alguns dados sobre o projeto, você terá sua chave:

Figura 1.19

Como você pode ver, com a chave de desenvolvedor você tem 10 chamadas limitadas por minuto, o que significa que você pode obter dados a cada 6 segundos. Posteriormente, no código, obteremos os dados a cada 10 segundos. Para verificar sua API_KEY, use-a em um navegador e veja se você consegue obter alguns dados.

Projetos de Automação Residencial com ESP8266

Substitua APY_KEY pela sua própria chave:

Figura 1.20

Depois disso, se você acessar este link em seu navegador, http://api.wunderground. com/api/APY_KEY/conditions/q/NL/Eindhoven.json; você obterá a seguinte resposta JSON formatada do servidor wunderground.com (Figura 1.21):

Figura 1.21

Capítulo 1 ■ Introdução ao ESP8266

Inclua a biblioteca ESP8266WiFi e a biblioteca ESP8266HTTPClient que permitem executar uma ação HTTP GET para obter a mesma mensagem JSON formatada, obtida usando um navegador: #include <ESP8266WiFi.h> #include <ESP8266HTTPClient.h>

Declare o nome SSID e a senha de sua rede Wi-Fi: const const const const const

char* ssid = "Your_WiFi_Name"; char* password = "Your_WiFi_Password"; String WUNDERGROUND_API_KEY = "YOUR_Wunderground_API_KEY"; String WUNDERGROUND_COUNTRY = "NL"; String WUNDERGROUND_CITY = "Eindhoven";

Construa a URL que será usada para obter os dados: const String dataURL = "http://api.wunderground.com/api/"+WUNDERGROUND_API_KEY+"/ conditions/q/"+WUNDERGROUND_COUNTRY+"/"+WUNDERGROUND_CITY+".json";

Como sempre, na seção setup conectaremos o chip à rede Wi-Fi: void setup() { Serial.begin(115200); delay(10); Serial.println(); Serial.println(); Serial.print("Connecting to "); Serial.println(ssid); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected"); Serial.println("IP address: "); Serial.println(WiFi.localIP()); }

Na seção loop, se o status Wi-Fi for conectado, você irá instanciar um objeto HTTPClient chamado http e começar a obter dados a cada 10 segundos do link construído anteriormente.

Projetos de Automação Residencial com ESP8266

Na variável payload você terá a resposta completa do servidor: void loop() { if(WiFi.status() == WL_CONNECTED) { HTTPClient http; http.begin(dataURL); inthttpCode = http.GET(); if(httpCode> 0) { // cabeçalho HTTP foi enviado e cabeçalho da resposta do servidor foi tratado Serial.printf("[HTTP] GET... code: %d\n", httpCode); // arquivo encontrado no servidor if(httpCode == HTTP_CODE_OK) { String payload = http.getString(); Serial.println(payload); } } } delay(10000); }

Se obter dados a cada 10 segundos for muito frequente, podemos mudar o intervalo para 1 minuto substituindo a chamada delay(10000) que está bloqueando outras execuções do código. Depois de const String WUNDERGROUND_CITY = "Eindhoven", adicione duas linhas de código: const long interval = 60 * 1000; unsigned long previousMillis = 0;

Agora a função loop mudará para: void loop() { unsigned long currentMillis = millis(); if(currentMillis - previousMillis>= interval) { previousMillis = currentMillis; if(WiFi.status() == WL_CONNECTED) { HTTPClient http; http.begin(dataURL); inthttpCode = http.GET(); if(httpCode> 0) { // cabeçalho HTTP foi enviado e cabeçalho da resposta do servidor // foi tratado Serial.printf("[HTTP] GET... code: %d\n", httpCode);

Capítulo 1 ■ Introdução ao ESP8266

// arquivo encontrado no servidor if(httpCode == HTTP_CODE_OK) { String payload = http.getString(); Serial.println(payload); } } } } }

Agora o Monitor Serial exibirá um enorme JSON com todas as informações sobre o tempo, desde temperatura, umidade, velocidade do vento, ponto de condensação da água e muito mais, a cada minuto, da seguinte maneira (Figura 1.22):

Figura 1.22

Projetos de Automação Residencial com ESP8266

Porém, e se você só quiser obter alguns dados específicos deste JSON? Felizmente existe uma biblioteca Wunderground para isso. Para instalá-la, vá para Sketch | Include Library | Manage Libraries e procure por ESP8266 Weather Station. Depois de instalar esta biblioteca, você também precisa instalar a biblioteca Json Straming Parser que irá analisar o JSON recebido. Você pode seguir estes passos: 1. Instale a biblioteca ESP8266 Weather Station (Figura 1.23):

Figura 1.23

2. Instale também a biblioteca JSON Streaming Parser (Figura 1.24):

Figura 1.24

Agora vamos obter os mesmos dados, portanto, a mesma API_KEY será usada, mas os dados serão analisados pelas funções das bibliotecas: 1. Inclua os arquivos de cabeçalho para ESP8266Wi-Fi.h , JSONListener.h e WundergroundClient: #include <ESP8266WiFi.h> #include <JsonListener.h> #include "WundergroundClient.h"

2. Defina a API_KEY e configure a variável métrica booleana: const String WUNDERGRROUND_API_KEY = "YOUR_API_KEY"; constboolean IS_METRIC = true;

Capítulo 1 ■ Introdução ao ESP8266

3. Inicie o WundergoundClient para o sistema métrico: WundergroundClientweather_data(IS_METRIC);

4. Além disso, inicie as configurações e constantes Wi-Fi usadas para obter os dados do tempo: const char* WIFI_SSID = "YOUR_WIFI_SSID"; const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"; const String WUNDERGROUND_LANGUAGE = "EN"; const String WUNDERGROUND_COUNTRY = "NL"; const String WUNDERGROUND_CITY = "Eindhoven"; WiFiClientwifiClient;

5. Inicie a função setup para se conectar à rede Wi-Fi: void setup() { Serial.begin(115200); delay(10); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); delay(20); Serial.print("Connecting to "); Serial.println(WIFI_SSID); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected!"); Serial.println(); }

6. Na função loop obtenha os dados do site wunderground.com a cada minuto e exiba-os na janela do Monitor Serial: void loop() { if ((millis() % (60 * 1000)) == 0) { Serial.println(); Serial.println("\n\nNext Loop-Step: " + String(millis()) + ":"); weather_data.updateConditions(WUNDERGRROUND_API_KEY,

Projetos de Automação Residencial com ESP8266 WUNDERGROUND_LANGUAGE, WUNDERGROUND_COUNTRY, WUNDERGROUND_CITY); Serial.println("wundergroundHours: " + weather_data.getHours()); Serial.println("wundergroundMinutes: " + weather_data.getMinutes()); Serial.println("wundergroundSeconds: " + weather_data.getSeconds()); Serial.println("wundergroundDate: " + weather_data.getDate()); Serial.println("wundergroundMoonPctIlum: " + weather_data.getMoonPctIlum()); Serial.println("wundergroundMoonAge: " + weather_data.getMoonAge()); Serial.println("wundergroundMoonPhase: " + weather_data.getMoonPhase()); Serial.println("wundergroundSunriseTime: " + weather_data.getSunriseTime()); Serial.println("wundergroundSunsetTime: " + weather_data.getSunsetTime()); Serial.println("wundergroundMoonriseTime: " + weather_data.getMoonriseTime()); Serial.println("wundergroundMoonsetTime: " + weather_data.getMoonsetTime()); Serial.println("wundergroundWindSpeed: " + weather_data.getWindSpeed()); Serial.println("wundergroundWindDir: " + weather_data.getWindDir()); Serial.println("wundergroundCurrentTemp: " + weather_data.getCurrentTemp()); Serial.println("wundergroundTodayIcon: " + weather_data.getTodayIcon()); Serial.println("wundergroundTodayIconText: " + weather_data.getTodayIconText()); Serial.println("wundergroundMeteoconIcon: " + weather_data.getMeteoconIcon(weather_data.getTodayIconText())); Serial.println("wundergroundWeatherText: " + weather_data.getWeatherText()); Serial.println("wundergroundHumidity: " + weather_data.getHumidity()); Serial.println("wundergroundPressure: " + weather_data.getPressure()); Serial.println("wundergroundDewPoint: " + weather_data.getDewPoint()); Serial.println("wundergroundPrecipitationToday: " + weather_data.getPrecipitationToday()); Serial.println(); Serial.println("---------------------------------------------------\n"); } }

7. A saída do Monitor Serial é mostrada na Figura 1.25: Agora, como um exercício, você pode ler a temperatura e acender ou apagar um LED se houver condições de congelamento ou umidade e a temperatura externa for muito alta.

Capítulo 1 ■ Introdução ao ESP8266

Figura 1.25

Enviar dados para internet Agora vamos enviar os mesmos dados para a internet. A primeira coisa a fazer é criar uma conta em http://thingspeak.com e configurar um canal. Cada canal tem oito campos que podem ser usados para armazenar os dados transmitidos pelo ESP8266. Como se trata de uma conta gratuita, é preciso enviar dados no máximo três vezes por minuto. A vantagem é que seus dados são armazenados no servidor deles e você pode visualizá-los em um belo gráfico ou embuti-los como um IFRAME em outro servidor de internet.

Projetos de Automação Residencial com ESP8266

Na seção Channel Settings, crie um campo e chame-o de Light, então vá para a guia da chave de API e obtenha uma Write API KEY. Aqui você também pode definir uma APY KEY de leitura se você tiver uma aplicação que deseja ler dados escritos por outros módulos. É uma forma rudimentar de compartilhar dados entre módulos. Uma vez que o módulo Witty tem um LDR, vamos usá-lo para gravar dados a cada minuto no api.thingspeak.com: #include <ESP8266WiFi.h> const char* WIFI_SSID = "YOUR_WIFI_SSID"; const char* WIFI_PASSWORD = "YOUR WIFI_PASSWORD"; const char* host = "api.thingspeak.com"; const char* writeAPIKey = "YOUR_WRITE_API_KEY"; #define LDR A0

Na função setup(), que é executada uma única vez, o pino do LDR é definido como um pino de INPUT e o ESP8266 se conectará à rede Wi-Fi com a função WiFi.begin(WIFI_SSID, WIFI_PASSWORD): void setup() { Serial.begin(115200); delay(10); pinMode(LDR, INPUT); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); delay(20); Serial.print("Connecting to "); Serial.println(WIFI_SSID); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected!"); Serial.println(); }

Na função loop() a intensidade da luz será lida a cada minuto do sensor LDR e publicada no campo Light em um canal do https://thingspeak.com/: void loop() { if ((millis() % (60 * 1000)) == 0) {

Capítulo 1 ■ Introdução ao ESP8266

// cria conexões TCP WiFiClient client; constinthttpPort = 80; if (!client.connect(host, httpPort)) { return; } String url = "/update?key="; url+=writeAPIKey; url+="&field1="; url+=String(analogRead(LDR)); url+="\r\n"; Serial.println(url); // Solicita ao servidor client.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); } }

Vejamos agora os dados depois de alguns minutos (Figura 1.26):

Figura 1.26

Projetos de Automação Residencial com ESP8266

Agora vamos combinar o sketch que lê os dados do tempo de wunderground.com com este que envia dados para thingspeak.com. Ele lerá os dados de temperatura, umidade, ponto de condensação e precipitação e os armazenará em thinkspeak.com para que possam ser importados futuramente. Basicamente, ele será um registro de dados meteorológicos: #include <ESP8266WiFi.h> #include <JsonListener.h> #include "WundergroundClient.h"

Estas são as configurações do Wunderground: const String WUNDERGRROUND_API_KEY = "58dfbeb30d02af26"; constboolean IS_METRIC = true; WundergroundClientweather_data(IS_METRIC); const char* WIFI_SSID = "YOUR_WIFI_SSID"; const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"; const String WUNDERGROUND_LANGUAGE = "EN"; const String WUNDERGROUND_COUNTRY = "NL"; const String WUNDERGROUND_CITY = "Eindhoven"; const char* host = "api.thingspeak.com"; const char* writeAPIKey = "YOUR_WRITE_API_KEY"; WiFiClientwifiClient;

A seguir temos a função setup() para conexão com a rede Wi-Fi: void setup() { Serial.begin(115200); delay(10); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); delay(20); Serial.print("Connecting to "); Serial.println(WIFI_SSID); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi connected!"); Serial.println(); }

Capítulo 1 ■ Introdução ao ESP8266

Na função loop() a cada minuto os dados do tempo serão lidos do site wunderground.com e publicados em thingspeak.com. Junto com a temperatura, pressão, ponto de precipitação e condensação, outras informações serão exibidas na saída serial, como fase da lua, horário de nascimento e pôr do sol. São informações que podem ser usadas se você planeja adicionar um módulo de exibição para visualizar todas as condições climáticas: void loop() { if ((millis() % (60 * 1000)) == 0) { Serial.println(); Serial.println("\n\nNext Loop-Step: " + String(millis()) + ":"); weather_data.updateConditions(WUNDERGRROUND_API_KEY, WUNDERGROUND_LANGUAGE, WUNDERGROUND_COUNTRY, WUNDERGROUND_CITY); Serial.println("wundergroundHours: " + weather_data.getHours()); Serial.println("wundergroundMinutes: " + weather_data.getMinutes()); Serial.println("wundergroundSeconds: " + weather_data.getSeconds()); Serial.println("wundergroundDate: " + weather_data.getDate()); Serial.println("wundergroundMoonPctIlum: " + weather_data.getMoonPctIlum()); Serial.println("wundergroundMoonAge: " + weather_data.getMoonAge()); Serial.println("wundergroundMoonPhase: " + weather_data.getMoonPhase()); Serial.println("wundergroundSunriseTime: " + weather_data.getSunriseTime()); Serial.println("wundergroundSunsetTime: " + weather_data.getSunsetTime()); Serial.println("wundergroundMoonriseTime: " + weather_data.getMoonriseTime()); Serial.println("wundergroundMoonsetTime: " + weather_data.getMoonsetTime()); Serial.println("wundergroundWindSpeed: " + weather_data.getWindSpeed()); Serial.println("wundergroundWindDir: " + weather_data.getWindDir()); Serial.println("wundergroundCurrentTemp: " + weather_data.getCurrentTemp()); Serial.println("wundergroundTodayIcon: " + weather_data.getTodayIcon()); Serial.println("wundergroundTodayIconText: " + weather_data.getTodayIconText()); Serial.println("wundergroundMeteoconIcon: " + weather_data.getMeteoconIcon(weather_data.getTodayIconText())); Serial.println("wundergroundWeatherText: " + weather_data.getWeatherText());

Projetos de Automação Residencial com ESP8266 Serial.println("wundergroundHumidity: " + weather_data.getHumidity()); Serial.println("wundergroundPressure: " + weather_data.getPressure()); Serial.println("wundergroundDewPoint: " + weather_data.getDewPoint()); Serial.println("wundergroundPrecipitationToday: " + weather_data.getPrecipitationToday()); WiFiClient client; constinthttpPort = 80; if (!client.connect(host, httpPort)) { return; } String url = "/update?key="; url+=writeAPIKey; url+="&field1="; url+=String(weather_data.getCurrentTemp()); url+="&field2="; url+=String(weather_data.getPressure()); url+="&field3="; url+=String(weather_data.getDewPoint()); url+="&field4="; url+=String(weather_data.getPrecipitationToday()); url+="\r\n"; Serial.println(url); // Solicita ao servidor client.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); Serial.println("---------------------------------------------------/\n"); } }

Depois de alguns minutos, você poderá ver os valores recebidos do site wunderground.com pelo ESP8266 e publicados no site thingspeak.com sendo exibidos em quatro gráficos:

Capítulo 1 ■ Introdução ao ESP8266

Figura 1.27

Resumo O primeiro passo para desenvolver aplicações de IoT foi concluído. Agora você tem o conhecimento para instalar e configurar o Arduino IDE para o desenvolvimento com o ESP8266, e aprendeu a transmitir e receber dados da internet. O próximo passo será fazer os módulos ESP8266 falarem entre si onde quer que eles estejam localizados.