Do “blink” ao BLYNK, uma viagem pela “Internet das coisas” nas asas do NodeMCU ESP-12E

Neste tutorial, aprenderemos a lidar com este fantástico dispositivo, o NodeMCU ESP-12E Development Kit V. 1.0, onde aprenderemos como:

  • Fazer piscar um LED pela internet
  • Ligar o ESP a um display LCD do tipo “OLED”
  • Capturar dados gerados por sensores tanto analógicos como digitais
  • Subir dados a um serviço de Internet das coisas tal como o Thinkspeak
  • Controlar “coisas” pela internet, utilisando-se aplicativos para smartphones como o BLINK

2: O NodeMCU

nodeMCU.jpg

O NodeMCU ESP-12E é a versão integrada do popular ESP8266, um Serial to Wi-Fi System On a Chip (SoC), que apareceu pela primeira vez em 2013 e lançado no mercado já no ano seguinte. O ESP8266 foi desenvolvido pela empresa chinesa com sede em Shangai, Espressif Systems, uma fabricante de circuitos integrados focada no desenvolvimento de chips de RF, particularmente Wi-Fi.

Existem vários módulos no mercado que se utilizam do chip ESP8266, Eles são nomeados ESP-NN, onde NN é um número 01, 02, … .. 12, etc. e as vezes seguido de uma letra. Estes módulos tipicamente possuem: o ESP8266 SoC, memória flash, um cristal e na maioria dos casos, uma antena. No link você pode encontrar a lista completa de dispositivos baseados  no ESP8266 encontradas no mercado: Família ESP8266 .

Os 2 módulos mais importantes são sem dúvida, a ESP-01 e o ESP-12E.

O ESP-01 têm sido amplamente utilizado em projetos da Internet das coisas onde tamanho e custo, mas não número de GPIOs (há apenas 2 do tipo digital disponíveis) são importantes. Exploramos este módulo em vários outros tutoriais aqui no Blog:

O ESP8266 – Parte 1Parte 2Parte 3

O ESP-12E Development Board (NodeMCU DevKit 1.0)

Para aumentar ainda mais a capacidade de utilização do módulo ESP-12E, foram adicionados regulação de potência e conectividade USB. O ESP-12E inclui:

  • Adaptador USB para UART: Silicon Labs CP2102,
  • NCP1117 3,3VDC Voltage Regulator,
  • Conector micro-USB,
  • Pinos adicionais com GND, Vin, 3,3VDC para facilitar o acesso durante o desenvolvimento.

Em suma, o NodeMCU ESP-12E é um dispositivo pronto para ser usado, bastando que você instale os drivers USB ao seu computador e comece a escrever programas que se conectam à sua rede Wi-Fi !

Especificações Técnicas:

  • Support STA/AP/STA+AP 3 working modes;
  • Built-in TCP/IP protocol stack, support multiple-channel TCP Client connection (max 5);
  • 0~D8, SD1~SD3: used for GPIO, PWM (D1-D8), IIC, ect; the driven ability can be arrived at 15mA;
  • AD0: one-way 10 bits ADC;
  • Power input: 4.5V~9V(10VMAX), support USB powered and USB debug;
  • Working current: ≈70mA(200mA MAX, continue), standby<200uA;
  • Transmission data rate: 110-460800bps;
  • Support UART/GPIO data communication interface;
  • Support update firmware remotely (OTA);
  • Support Smart Link;
  • Working temperature:-40℃~+125℃;
  • Driven mode: double large-power H bridge driven
  • Weight: 7g.

Picture of The NodeMCU

Um excelente site para se aprender mais sobre a família do ESP 8266 é: What Is The ESP8266 And Why Is It So Popular?

 

3: Instalando o NodeMCU ao IDE do Arduino

Se você deseja programar e usar o NodeMCU como se fosse um Arduino, a boa notícia é que é possível escrever-se firmwares personalizados e carregá-los no chip (“flash-it”). É importante lembrar que qualquer novo “firmware personalizado” irá substituir qualquer coisa previamente armazenada na memória flash do chip, incluindo o firmware original carregado em fábrica (aquele que aceita os comandos AT). Embora possamos usar o SDK do fabricante para o desenvolvimento de firmwares personalizados, é muito mais fácil usar o bom e velho Arduino IDE.

Comecemos:

No Arduino IDE,  abra a janela de preferências e digite a URL (marcado em vermelho na foto abaixo) no campo Additional Boards Manager URLs e selecione OK.

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Picture of Installing the NodeMCU board at Arduino IDE

  • Selecione MENU  Tools → Board → Boards Manager…e vá rolando até encontrar a opção: esp8266 by ESP8266 Community , a qual deverá ser o último item da lista e clique INSTALL

https://mjrobot.files.wordpress.com/2016/10/arduino_ide_boards_esp8... 150w, https://mjrobot.files.wordpress.com/2016/10/arduino_ide_boards_esp8... 300w, https://mjrobot.files.wordpress.com/2016/10/arduino_ide_boards_esp8... 768w, https://mjrobot.files.wordpress.com/2016/10/arduino_ide_boards_esp8... 912w" sizes="(max-width: 709px) 85vw, (max-width: 909px) 67vw, (max-width: 1362px) 62vw, 840px" />

  • Instalando USB Drivers: O USB to Serial UART module incluído no dispositivo, é o  Silicon Labs’ CP2102, para o qual deveremos instalar o driver Virtual COM Port (VCP). No caso de meu MAC, o arquivo criado para comunicar com o CP2102 foi:  /dev/cu.SLAB_USBtoUART. Você pode encontrar o driver apropriado ao seu computador no seguinte link: CP210x USB to UART Bridge VCP Drivers
  • Depois de restartar o Arduino IDE , poderemos selecionar a placa no menu: Option Tools → Board → NodeMCU 1.0 (ESP-12E Module). Em seguida, especificar a correta frequência de operação da CPU: (Tools → CPU Frequency: “” → 80MHz) e velocidade de comunicação (Tools → Upload Speed: “” → 115,200). Finalmente, selecionar o port apropriado ao seu computador: (Tools → Port → /dev/cu.SLAB_USBtoUART).

Neste ponto estamos prontos para escrever nosso próprio firmware e enviá-lo ao dispositivo, mas vamos primeiramente tentar um dos exemplos incluídos com a biblioteca: File → Examples → ESP8266WiFi → WiFiScan. Após o upload, podemos abrir a janela do Serial Monitor e observar os resultados. Verifique que 115,200 baud é a velocidade selecionada no menu do canto inferior direito do Serial Monitor.

https://mjrobot.files.wordpress.com/2016/10/nodemcu-ide-setup-4.png... 1678w, https://mjrobot.files.wordpress.com/2016/10/nodemcu-ide-setup-4.png... 150w, https://mjrobot.files.wordpress.com/2016/10/nodemcu-ide-setup-4.png... 300w, https://mjrobot.files.wordpress.com/2016/10/nodemcu-ide-setup-4.png... 768w, https://mjrobot.files.wordpress.com/2016/10/nodemcu-ide-setup-4.png... 1024w" sizes="(max-width: 709px) 85vw, (max-width: 909px) 67vw, (max-width: 1362px) 62vw, 840px" />

4: Piscando (“Blinking”) o LED

FullSizeRender 24.jpg

 

O “Olá Mundo” de qualquer novo projeto de HW é sem dúvida alguma, um LED piscando. Para conectar-se um LED em seu ESP-12E, você poderá usar qualquer um dos seus GPIO digitais.

Picture of Blinking a LED

O diagrama de pinos acima mostra o layout da 2ª geração do NodeMCU ESP8266 . Em nosso caso, usaremos o pino D7 ou seu equivalente para Arduino: GPIO13.

blink.png

Você poderá testar o código usando tanto “D7” quanto “13”. ambas formas funcionarão. O pino D7 não precisa de um resistor externo para alimentar o LED, pois possui um internamente. Abaixo um código simples para piscar o LED:

/**********************************************
Blink
Connected to pin D7 (GPIO13) ESP8266 NODEMCU
**********************************************/

#define ledPin 13
// #define ledPin D7

void setup()
{
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Há uma relação entre alguns dos pinos do NodeMCU e do Arduino, automaticamente identificados pelo IDE, tal como descrito abaixo:

  • ESP ==> Arduino
  • D0 ==> 16
  • D1 ==> 5
  • D2 ==> 4
  • D3 ==> 0
  • D4 ==> 2
  • D5 ==> 14
  • D6 ==> 12
  • D7 ==> 13
  • D8 ==> 15
  • D9 ==> 3
  • D10 ==> 1

Abaixo o código pronto para ser executado no IDE do Arduino:

5: Instalando o display de 0.96″ (OLED)

FullSizeRender 25.jpg

Um grande companheiro para o nosso ESP-12E é o pequeno display do tipo OLED: SSD 1306. Ele pode ser muito útil em projetos tanto para mostrar seus dados ou mensagens, quanto para depurar seus programas em campo. O modelo que usei aqui é um display de 128 x 64 pixels que se comunica via I2C, o SSD 1306, cujas principais características são:

  • 128 pixels na horizontal por 64 pixels na vertical. Assim se você usar por exemplo, caracteres de  8×8 pixels, obteremos um display de “16X8” (8 linhas de 16 caracteres cada).
  • Comunicação via I2C : se deve conectar ao NodeMCU I2C pins, usando:
    • SCL ==> D1 (equ. Arduino 5)
    • SDA ==> D2 (equ. Arduino 4)

Outra característica importante do SSD1306 é que você deve alimentar-lo com 3.3V, pelo que é possível conectar-lo diretamente ao módulo nodeMCU, como mostra o diagrama eléctrico abaixo:

Picture of Using the 0.96" OLED display

Uma vez conectado o display, baixar e instalar a sua biblioteca em nosso Arduino IDE. Nós usaremos a versão ACROBOT abaixo:

SSD1306 Arduino Library

Depois de ter reiniciado o IDE, a biblioteca deverá estar instalada. Carreguemos o sketch abaixo para testar o display OLED:

/***********************************************************************
* NodeMCU and OLED display "Hello World"
* Based on original code developed by: Makerbro at https://acrobotic.com
* MJRoBot 12Oct16
************************************************************************/

#include <Wire.h>
#include <ACROBOTIC_SSD1306.h>

void setup()
{
  Wire.begin();
  oled.init(); // Initialze SSD1306 OLED display
  oled.clearDisplay(); // Clear screen
  oled.setTextXY(0,0); // Set cursor position, start of line 0
  oled.putString(" MJRoBot.org");
  oled.setTextXY(4,0); // Set cursor position, start of line 4
  oled.putString(" HELLO, WORLD");
}

void loop()
{
}

Observe que quando você não definir um tamanho em pixels para os caracteres de texto, o padrão será 8X8. Para se definir um tamanho diferente, por exemplo,5X7, você poderá utilizar: oled.setFont(font5x7);

Abaixo o código para o “Hello World”:

6: O NodeMCU e o DHT22 como uma estação climática

57fe5c32937ddb5b790007f3.jpegPicture of NodeMCU as a local weather station using DHT22

 

Um dos sensores mais utilizados normalmente para se captar dados meteorológicos é o DHT22 (ou seu irmão, o  DHT11), um sensor digital de humidade relativa do ar e temperatura. Ele usa internamente um sensor capacitivo de humidade e um termistor para medir o ar circundante, gerando um sinal digital em sua saída de dados. 

De acordo com a sua folha de dados (Datasheet), o sensor deve ser alimentado entre 3.3V e 5V (algumas especificações falam em até 6V max). Ele trabalha a partir de -40  a + 80 graus centígraods (algumas especs falam em + 125 ° C) com uma precisão de +/- 0,5 ° C de temperatura e +/-2% de umidade relativa. É importante ter em mente que o seu (“sencing period”) é em média de dois segundo (tempo mínimo entre leituras).

O site da Adafruit fornece uma série de informações sobre ambos, DHT22 e seu irmão DHT11. Para mais detalhes, visite a página:  Tutorial DHT22 / 11.

O DHT22 tem 4 pinos (de frente para o sensor, o pino 1 é o mais esquerda):

  1. VCC (3 a 5V)
  2. saída de dados
  3. Não conectado
  4. GND (Terra)

OLED_DHT22.png

Uma vez que normalmente você usará o sensor em distâncias inferiores a 20m, um resistor de 10K deve ser conectado entre os pinos de dados e o VCC. O pino de saída deve ser conectado ao pino D3 do ESP-12E (veja o diagrama acima).

Uma vez que o sensor esteja instalado fisicamente no NodeMCU, baixe a biblioteca DHT a partir do repositório de programas:  Adafruit github e a instale junto as outras  bibliotecas de seu IDE (ambiente de desenvolvimento de programas do Arduino).

Uma vez que você recarregue o IDE, a biblioteca para o  sensor de DHT deverá aparecer como instalada. Execute o código abaixo para verificar se tudo está funcionando OK:

7: Instalando sensores analógicos

57fe81bf50e1b6b8d60002fc.jpeg

O NodeMCU possui um Analog Digital Converter (ADC) de 10 bits integrado. Quando comparado com um Arduino UNO que tem 6 ADCs “portas” ou o Nano que tem 8, parece que o NodeMCU sai perdendo aqui. Mas isto não é necessariamente verdade. Primeiro, os Arduinos UNO ou Nano em realidade, possuem apenas um ADC integrado internamente o qual deve ser multiplexado para se poder ler suas múltiplas entradas analógicas. Então, podemos fazer exatamente o mesmo com o NodeMCU.

Por exemplo, suponha que você necessite ler 2 sensores analógicos:

  • LDR: para se medir a intencidade da luz
  • Higrômetro (Soil Moisture) para se medir a umidade do solo

O que devemos fazer é “alimentar” individualmente cada um desses sensores cada vez que precisemos ler um deles. Para isso você deve definir para cada sensor, uma das GPIOs digitais como saída, colocando-as em nível ALTO em cada leitura. Para saber mais sobre múltiplas entradas analógicas, consulte o site:

Multiple analog inputs using one analoge pin

Higrômetro:

Picture of Using Analog sensors No Projeto ArduFarmBot, exploramos como trabalhar com um higrômetro para medir a umidade do solo. Lá, desenvolvemos um sensor do tipo DIY (“Do it yourself” – “Faça você mesmo”), mas aqui vamos usar um eletrônico, muito comum no mercado: o par sensor YL-69 e o comparador LM393.

O módulo LM393 possui 2 saídas, uma digital (D0), que pode ser configurada usando-se o potenciômetro que existe integrado ao módulo e um analógico (A0). Este módulo pode ser alimantado com 3.3V, o que é muito conveniente quando se trabalha com um NodeMCU. O que vamos fazer, é instalar os 4 pinos do LM393  como descrito abaixo:

  • LM393 A0:    to NodeMCU A0 input
  • LM393 VCC: to NodeMCU VCC or to NodeMCU GPIO D3*
  • LM393 GND: to NodeMCU GND
  • LM393 D0:    Não conectado

NodeMCU WS V2.png

Note que no diagrama acima, um sensor de humidade equivalente de 3 pinos  foi usada apenas para referência (não encontrou o módulo apropriado para desenha-lo com o Fritzing). Também é importante notar que o o “VCC do Sensor” deve ser conectado a um pino digital como saída, de modo que o LM393 seja alimentado apenas quando precisemos fazer uma leitura. Isto é importante não só para poupar energia, mas também para proteger as sondas de corrosão.

* Eu deixei aqui as 2 opções para alimentar sensor, porque pelo menos no caso de meu sensor e módulo, percebi que o NodeMCU não carregava o sketch com o D3 conectado. Também tive eventuais erros devido ao consumo de energia. Se você alimentar o LM393 diretamente ao 3.3V, o código não precisa ser alterado.

Uma rotina simples pode ser escrita para se ler a porta analógica:

/***************************************************
* Get Soil Moister Sensor data
**************************************************/
void getSoilMoisterData(void)
{
  soilMoister = 0;
  digitalWrite (soilMoisterVcc, HIGH);
  delay (500);
  int N = 3;
  for(int i = 0; i < N; i++) // read sensor "N" times and get the average
  {
    soilMoister += analogRead(soilMoisterPin);
    delay(150);
  }
  digitalWrite (soilMoisterVcc, LOW);
  soilMoister = soilMoister/N;
  Serial.println(soilMoister);
  soilMoister = map(soilMoister, 380, 0, 0, 100);
}



Alguns comentários sobre a rotina acima:
  • Os dados do sensor é capturado 3 vezes, tirando-se uma média das mesmas.
  • Usamos MAP para configurar o intervalo em percentagem. Para definir os valores extremos, procedemos como abaixo:
    • Fazer um “curto-circuito” nas pontas de prova do higrômetro, isso equivalente a “100% de umidade”, o que gerará um valor de cerca de 0 na saída do ADC
    • Colocar o higrômetro”no ar”, se observa que o valor exibido no Serial Monitor é em torno de 380.

Abaixo o código completo para esta fase do projeto:

8: Subindo os dados para a nuvem: ThinkSpeak.com

Até agora, utilizamos o NodeMCU ESP12-E como se fosse uma placa normal de Arduino. É claro que apenas “tocamos” o verdadeiro potencial deste espectacular chip e agora é a hora de decolarmos rumo as estrelas! Quer dizer, para a nuvem! ;-)

Picture of Uploading the sensor data to ThinkSpeak.com

Comecemos!

  • Primeiro você deve abrir uma conta no ThinkSpeak.com
  • Siga as instruções para criar um canal e tome nota do seu Channel IDe Write API Key
  • Atualize o código abaixo com as credenciais de sua rede Wi-Fi e Thinkspeak
  • Execute o programa no IDE

Comentemos as partes mais importantes do código:

Primeiro:

  • Incorporamos a biblioteca do ESP8266,
  • Definimos o cliente WiFi
  • Entramos com as credenciais do roteador WiFi e do Thingspeak :

/* ESP12-E & Thinkspeak*/
#include <ESP8266WiFi.h>
WiFiClient client;
const char* MY_SSID = "YOUR SSD ID HERE";
const char* MY_PWD = "YOUR PASSWORD HERE";
const char* TS_SERVER = "api.thingspeak.com";
String TS_API_KEY ="YOUR CHANNEL WRITE API KEY";

Segundo, incluamos uma nova biblioteca, muito importante em projetos de IoT: SimpleTimer.h:

/* TIMER */
#include <SimpleTimer.h>
SimpleTimer timer;

Em terceiro lugar, durante o setup(), iniciar a comunicação serial, connectar o WiFi atarvés da função connectWiFi() e definir os temporizadores. Note-se que a linha de código: timer.setInterval (19000L, sendDataTS); chamará a função functionsendDataTS () a cada 19 segundos, a fim de transferir dados para o canal do ThinkSpeak.

void setup()
{
   ...
   Serial.begin(115200);
   delay(10);
   ...
   connectWifi();
   timer.setInterval(19000L, sendDataTS);
   ...
}

Por último mas não menos importante, durante o loop (), a única ação necessária é iniciar o temporizador e pronto!


void loop()

{
...
timer.run(); // Initiates SimpleTimer
}


Abaixo em detalhes, as duas funções utilizadas para se comunicar com o ThinkSpeak.com:

ESP12-E conectando-se com a rede WiFi:

/***************************************************
* Connecting WiFi
**************************************************/
void connectWifi()
{
  Serial.print("Connecting to "+ *MY_SSID);
  WiFi.begin(MY_SSID, MY_PWD);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(1000);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi Connected");
  Serial.println("");
}

ESP12-E enviando dados ao ThinkSpeak:



/***************************************************
* Sending Data to Thinkspeak Channel
**************************************************/
void sendDataTS(void)
{
  if (client.connect(TS_SERVER, 80))
  {
    String postStr = TS_API_KEY;
    postStr += "&field1=";
    postStr += String(temp);
    postStr += "&field2=";
    postStr += String(hum);
    postStr += "&field3=";
    postStr += String(soilMoister);
    postStr += "\r\n\r\n";

    client.print("POST /update HTTP/1.1\n");
    client.print("Host: api.thingspeak.com\n");
    client.print("Connection: close\n");
    client.print("X-THINGSPEAKAPIKEY: " + TS_API_KEY + "\n");
    client.print("Content-Type: application/x-www-form-urlencoded\n");
    client.print("Content-Length: ");
    client.print(postStr.length());
    client.print("\n\n");
    client.print(postStr);
    delay(1000);
  }
  sent++;
  client.stop();
}



/NodeMCU_Weather_Station_TS_Blog.inoNodeMCU_Weather_Station_TS_Blog.ino

9: Introduzindo o BLYNK

 Mas o que é BLYNK? Pelo Blynk website podemos entender que :

Blynk é uma plataforma baseada em Apps para iOS e Android, utilizada para controlar-se Arduino, Raspberry Pi e outros dispositivos através da Internet. É um painel digital (“Dashboard”) onde você pode construir uma interface gráfica para o seu projeto, simplesmente arrastando e soltando “widgets”.

É realmente muito fácil desenvolver projectos de IoT utilizando-se o BLYNK.

Para começar, aprendamos a controlar nosso velho LED conectado a porta D7, utilisando-se de um smartphone. Para isso, sigamos os passos abaixo:

  • Baixar o BLYNK app para o iPhone da Apple ou o Google Android
  • Instale a Biblioteca do BLYNK para Arduino. Note que você vai baixar um arquivo zip (Há 5 arquivos lá que você deverá instalar manualmente em sua Biblioteca do Arduino).
  • Uma vez que o Arduino IDE é recarregado, abra o sketch: Exemples ==> Blynk ==> Boards_WiFi ==> ESP8266_Standalone

#define BLYNK_PRINT Serial // Comment this out to disable prints and save space
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "YourAuthToken";

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "YourNetworkName";
char pass[] = "YourPassword";

void setup()
{
  Serial.begin(9600);
  Blynk.begin(auth, ssid, pass);
}

void loop()
{
  Blynk.run();
}

O código acima é basicamente tudo o que você precisa instalar em seu ESP12-E para executar seus projetos de IoT com o BLYNK. Não se esqueça de alterar a velocidade de comunicação para 115.200 bauds e entrar com as credenciais de seu roteador local e de seu projeto no BLYNK.

Agora, vamos abrir o aplicativo “Blynk” no smartphone:

blynk_led_ctrlhttps://mjrobot.files.wordpress.com/2016/10/blynk_led_ctrl.png?w=16... 1660w, https://mjrobot.files.wordpress.com/2016/10/blynk_led_ctrl.png?w=15... 150w, https://mjrobot.files.wordpress.com/2016/10/blynk_led_ctrl.png?w=30... 300w, https://mjrobot.files.wordpress.com/2016/10/blynk_led_ctrl.png?w=76... 768w, https://mjrobot.files.wordpress.com/2016/10/blynk_led_ctrl.png?w=10... 1024w" sizes="(max-width: 709px) 85vw, (max-width: 909px) 67vw, (max-width: 984px) 61vw, (max-width: 1362px) 45vw, 600px" />
  1. Clique na tela Create New Project
  2. De um nome para seu projeto (Por exemplo: “LED Control”)
  3. Selecione o HW apropriado: NodeMCU
  4. Anote seu código do Authorization Token (você pode enviar-lo por e-mail e copiar-lo no código anterior:
    char auth[] = "YourAuthToken";
  5. Pressione OK. Uma tela vazia cheia de pontos irá aparecer.
  6. Clique na tela para abrir o Widget Box
  7. Adicione o Button widget.
  8. Clique no ícone do botão para abrir o Widget Settings. A principal coisa a definir é o PIN number (Como nosso LED está conectado ao pino D7 – escolha pin D7). É bom dar um nome para o widget: “LED”. Pressione OK
  9. Caso ainda não o tenha feito, volte para o seu código e atualize-o com o código de autorização que você obteve no aplicativo: char auth[] = “YourAuthToken”;

Uma vez que o código seja carregado em seu ESP12-E e o programa seja executado, o Serial Monitor deve apresentar algo semelhante ao meu abaixo:

blynk-serial-monitorhttps://mjrobot.files.wordpress.com/2016/10/blynk-serial-monitor.pn... 150w, https://mjrobot.files.wordpress.com/2016/10/blynk-serial-monitor.pn... 300w, https://mjrobot.files.wordpress.com/2016/10/blynk-serial-monitor.pn... 768w" sizes="(max-width: 709px) 85vw, (max-width: 909px) 67vw, (max-width: 984px) 61vw, (max-width: 1362px) 45vw, 600px" />

Agora basta executar o projecto Blynk (use o botão “play” no canto superior direito do aplicativo em seu smartphone) e isto é tudo! Você estará controlando seu HW através da Internet !!!!! 

Blynk_LED.pnghttps://mjrobot.files.wordpress.com/2016/10/blynk_led.png?w=150 150w, https://mjrobot.files.wordpress.com/2016/10/blynk_led.png?w=300 300w, https://mjrobot.files.wordpress.com/2016/10/blynk_led.png?w=768 768w" sizes="(max-width: 709px) 85vw, (max-width: 909px) 67vw, (max-width: 984px) 61vw, (max-width: 1362px) 45vw, 600px" />

10: Running our Weather Station on Blynk

Podemos também enviar os dados que estamos coletando de sensores para o Blynk, da mesma maneira que fizemos com o ThingSpeak.

Criemos um novo projeto Blink em nosso aplicativo (ou atualizar o que já foi criado):

https://mjrobot.files.wordpress.com/2016/10/blynk-2.png?w=1680 1680w, https://mjrobot.files.wordpress.com/2016/10/blynk-2.png?w=150 150w, https://mjrobot.files.wordpress.com/2016/10/blynk-2.png?w=300 300w, https://mjrobot.files.wordpress.com/2016/10/blynk-2.png?w=768 768w, https://mjrobot.files.wordpress.com/2016/10/blynk-2.png?w=1024 1024w" sizes="(max-width: 709px) 85vw, (max-width: 909px) 67vw, (max-width: 1362px) 62vw, 840px" />

  1. Clique na tela e crie  3 novos Widgets. Em nosso caso: “Gauge”
  2. Para cada um desses widgets, defina: nameinput type, range e frequency para atualização dos dados

Para os nossos sensores, definamos os seguintes “Virtual Ports”:

  • V10: Temperature, range 0-50oC, 5s of pooling frequency
  • V11: Humidity, range 0-100%, 5 s
  • V12: Soil Moisture, range 0-100%, 5 s

Em nosso código para o ESP12-E teremos de introduzir os valores acima. Comecemos a partir do código anterior e adicionemos os novos sensores e timer. A linha abaixo de código incluída no setup (), da mesma maneira que vimos com a versão Thinkspeak, forçará o programa para executar a função sendUptime () a cada 5 segundos.

  timer.setInterval(5000L, sendUptime); 

Abaixo a função completa:

/***************************************************
* Send DHT data to Blynk
**************************************************/
void sendUptime()
{
  // You can send any value at any time.
  // Please don't send more that 10 values per second.
  Blynk.virtualWrite(10, temp); //virtual pin V10
  Blynk.virtualWrite(11, hum); // virtual pin V11
  Blynk.virtualWrite(12, soilMoister); // virtual pin V12
}

E, Voilá! O seu aplicativo Blynk estará recebendo informações atualizadas a respeito de seus sensores e você também poderá controlar o LED pela internet.



FullSizeRender 27.jpg

Abaixo o código completo para nosso Blynk Weather Station Control app:

11: Utilizando-se o  Blynk e o ThinkSpeak simultaneamente

Picture of Running Blynk and ThinkSpeak simustanealy

É claro que podemos ter nossos dados em ambas plataformas:

  • Blynk app (que é ótimo para o controle e mobilidade) e
  • ThinkSpeak que é muito bom para armazenamento de histórico e análise de dados.

NOTA: O Blynk possui um Widget: Webhook, onde voce pode comandar o envio automático dos dados ao ThinkSpeak sem necessidade de código adicional. O problema é que este widget só está disponível para Android. Assim fica aqui o código para fazer-lo por SW.

O arquivo abaixo mostra o código completo:

Conclusão

Como sempre, espero que este projeto ajude outras pessoas a encontrar seu caminho no apaixonante mundo da eletrônica e do IoT!

Para mais projetos, visite meu blog aqui no Garagem ou no MJRoBot.org

Um abraço e até o próximo post!

Obrigado

Saludos desde o sul do mundo!

Marcelo

Exibições: 3299

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 JOSÉ VENÂNCIO AVILA DE SOUZA em 28 janeiro 2017 às 18:24

Olá amigão. Gostaria de saber como enviar dados para o aplicativo Blynk utilizando Arduino_Serial_USB. Braço!
Comentário de Danilo César Rodrigues Azevedo em 29 novembro 2016 às 13:15

Bom demais, Marcelo! Muito obrigado mesmo.

Comentário de Marcelo Rovai em 29 novembro 2016 às 12:48

Usei o "History Graph" que te permite até 4 sensores. Abaixo o settings dele:

Comentário de Marcelo Rovai em 29 novembro 2016 às 12:45

Comentário de Marcelo Rovai em 29 novembro 2016 às 12:45

vai um print screen da tela do app do Blynk. É só deslizar o grafico para a esquerda que a opcao de download do arquivo de dados aparece.

Comentário de Marcelo Rovai em 29 novembro 2016 às 12:42

Oi Danilo.

O Blynk faz isso quase automático. Eu criei um aplicativo simples para ir registrando a temperatura da sala de casa e o deixei lá. Incluí a opçao de gráfico do Blynk que da mesma forma que o Thinkspeak te manda um arquivo com os dados que voce pode abrir no Excel. Desde que publiquei este post, deixei o circuito ligado. Foram mais de 40.000 mediçoes. te envio o gráfico para voce ver:

Comentário de Danilo César Rodrigues Azevedo em 29 novembro 2016 às 11:00

Muito bom! Obrigado mesmo. Tenho uma pergunta. Se quiser receber dados multiplexados pelo Blynk, como faço? No meu caso, recebo dados de três sensores e queria separá-los em gráficos específicos! To tomando uma suadeira do ESP nisso!

Comentário de José Gustavo Abreu Murta em 3 novembro 2016 às 11:46

Perfeito ! Extremamente didático, Prof. Marcelo. 

Muito bom. Parabéns .

Já salvei e depois irei testar. 

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço