<
*

Boss

  • Alahu Akbar
  • *****
  • 73
  • 3
  • Boss O Regresso
    • Ver perfil
[html]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






1: Lista de Material




  1. Node MCU ESP-12E Development Kit V 1.0

  2. 0.96″ I2C IIC SPI Serial 128X64 Yellow&Blue OLED LCD LED Display

  3. DHT22 AM2302 Temperature And Humidity Sensor

  4. YL-69 sensor and LM393 Comparator module soil medium Hygrometer,

  5. Breadboard

  6. LED

  7. Resistor 10K ohms

  8. Cabos






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 INSTALLarduino_ide_boards_esp8266

    • 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).

    • nodemcu-ide-setup-3

    • 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.

    • nodemcu-ide-setup-4

      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, automaticamante 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


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
#include

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.jpeg


 





Picture 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)

  5. OLED_DHT22.png




  6. 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:



    • Higrômetro (Soil Moisture) para se medir a umidade do solo (Sensor 1)

    • LDR: para se medir a intensidade da luz ou um segundo higrômetro (Sensor 2)


    O que devemos fazer é criar um “multiplexador”, “alimentando-se individualmente cada um desses sensores a 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.


    Analog Sensor Mux


    Por exemplo, o código abaixo daria conta do recado:







 
#include

int sensorPin = A0;    // analog input for both sensors
int enable1 = D1;      // enable reading Sensor 1
int enable2 = D2;      // enable reading Sensor 2

int sensorValue1 = 0;  // variable to store the value coming from sensor 1
int sensorValue2 = 0;  // variable to store the value coming from sensor 2

void setup()
{
  Serial.begin(115200);
  delay(10);
  pinMode(enable1, OUTPUT);
  pinMode(enable2, OUTPUT);
}

void loop()
{
// Sensor 1
  digitalWrite(enable1, HIGH);
  sensorValue1 = analogRead(sensorPin);
  sensorValue1 = constrain(sensorValue1, xxx, yyy);
  sensorValue1 = map(sensorValue1, xxx, yyy, 0, 1023);
  Serial.print("Sensor 1 value:  ");
  Serial.println(sensorValue1);
  digitalWrite(enable1, LOW);
  delay(100);

// Sensor 2

  digitalWrite(enable2, HIGH);
  delay(500);
  sensorValue2 = analogRead(sensorPin);
  sensorValue2 = constrain(sensorValue2, xxx, yyy);
  sensorValue2 = map(sensorValue2, xxx, yyy, 1023, 0);

  Serial.print("Sensor 1 value:  ");
  Serial.println(sensorValue2);
  Serial.println();
  delay(100);

  digitalWrite(enable2, LOW);
}
 

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!



Boss O regresso