o NodeMCU ESP12-E e o Blynk.

Começaremos por aprender como conectar um servo com o NodeMCU, como controlá-lo localmente com um potenciômetro, como ver sua posição em um display e finalmente como controlá-lo através da internet usando um smartphone.

O diagrama de blocos abaixo nos dá uma visão geral do projeto final:

E o vídeo, mostrará o projeto funcionando:

1. BoM (Lista de materiais)

Valores em USD, apenas para referência.

1. NodeMCU ESP8266-12E V1.0 (US$ 8.79)
   
2. 0.96″ Inch I2c IIC Serial 128×64 Oled LCD White Display (US$ 9.99)
   
3. Mg995 Servo 180 Degree (US$ 19.99)
   
4. Breadboard Power Supply Module 3.3V/5V (US$ 5.99)
   
5. 10K ohms Potentiometer (US$ 7.19)
   
6. 400 points Breadboard (US$ 5.89)
   
7. Dupont Cables (US$ 7.29)
    

2. Conectando o servo e o potenciômetro

A primeira coisa que faremos é configurar o NodeMCU para lidar com o Servo, controlando-o através de um potenciômetro de 10K ohm.

Cuidado! O NodeMCU é alimentado com 5V, mas todos os seus GPIOs trabalham com um nível de 3.3V.

Dividiremos os barramentos de alimentação do Breadboard, deixando um para 5V e o outro para 3.3V. Para isso, usaremos uma fonte de alimentação específica para Breadboards como a mostrada no diagrama elétrico abaixo:

NOTA: Durante a fase de desenvolvimento (PC ligado à NodeMCU via porta USB), não é necessário ligar o pino Vin a + 5V (fio vermelho no diagrama), uma vez que a energia será fornecida pelo computador. Deixe-o desconectado.

Para o controle do servo, usaremos a biblioteca: Servo.h :

#include <Servo.h>   // Include the library
 
Servo servo1;        // Name it "servo1"
 
#define servo1Pin D2 // Define the NodeMCU pin to attach the Servo

Durante setup(), a variável servo1 deve ser iniciada:

servo1.attach(servo1Pin);

O potenciômetro de 10K funcionará como um divisor de tensão, alterando o nível da entrada analógica no NodeMCU (A0) de 0 a 3.3V. Internamente, o ADC de 10 bits (Conversor Analógico-Digital) gerará um valor digital correspondente (de 0 a 1023), armazenado na variável potReading, equivalente à entrada de tensão analógica.

potReading = analogRead(A0);

Devemos “mapear” esse valor digital, para que a saída digital modulada por largura de pulso (PWM) do pino D2 varie de 0 a 180 (variável servo1Angle).

servo1Angle = map(potReading, 0, 1023, 0, 180);

O servo girará de 0 a 180 graus, utilizando-se do comando abaixo:

servo1.write(servo1Angle);

A posição do Servo em graus será exibida, durante esta fase de teste, no Monitor Serial:

Serial.println(servo1Angle);

O codigo completo para os testes com o servo, poderá ser descarregado desde meu GitHub:

NodeMCU_Servo_Control_Test

O vídeo abaixo mostra os testes sendo realizados com o servo:

3. Instalando um display

Esta bem utilizar o Serial Monitor durante os testes, mas o que acontecerá quando você estiver utilizando seu protótipo longe de seu PC em modo autônomo? Para isso, instalaremos um display do tipo OLED, o nosso velho conhecido: SSD1306, cujas principais características são:

• Tamanho da tela: 0.96 “
  
• Comunicação Serial I2C IIC SPI
  
• 128X64
  
• Display de caracteres na cor branca

Conecte os pinos do OLED ao NodeMCU, conforme descritos abaixo e no diagrama elétrico acima:

• SDA    ==> D1 (5)
  
• SCL * ==> D2 (4) * Você também poderá encontrar “SDC” ao invés de SCL
  
• VCC   ==> 3.3V ou 5V
  
• GND ==> GND

O SSD1306 pode ser alimentado tanto com 5V quanto com 3.3V. Usaremos 3.3V fornecidos externamente para não sobrecarregar o NodeMCU.

Depois de conectar o OLED, deveremos baixar e instalar sua biblioteca no IDE do Arduino. Usaremos a biblioteca gráfica desenvolvida por Daniel Eichhorn.  Entre no link abaixo e descarregue a biblioteca, instalando-a no IDE do Arduino:

https://github.com/squix78/esp8266-oled-ssd1306

Certifique-se de usar a versão 3.0.0 ou maior!

Depois de reiniciado o IDE, a biblioteca já deverá estar instalada.

A biblioteca suporta o protocolo I2C para acessar a modulo OLED, usando a biblioteca Wire.h:

#include <Wire.h>
 
#include "SSD1306.h"
 
SSD1306  display(ADDRESS, SDA, SDC);

Listaremos apenas algumas API mais importantes, as quais serão utilizadas com o OLED.

A lista completa poderá ser encontrada no GITHub fornecido anteriormente neste tópico.

A. Controle de exibição do display:

void init(); // Initialise the display
 
void displayOn(void); // Turn the display on
 
void displayOff(void); // Turn the display offs
 
void clear(void); // Clear the local pixel buffer
 
void flipScreenVertically(); // Turn the display upside down

B. Operações com texto:

void drawString(int16_t x, int16_t y, String text); // (xpos, ypos, "Text")
 
void setFont(const char* fontData);  // Sets the current font.

Fonts disponíveis:

• ArialMT_Plain_10,
  
• ArialMT_Plain_16,
  
• ArialMT_Plain_24

Uma vez que tenhamos instalado o OLED e sua biblioteca, devemos utilizar um programa simples para testá-lo. Digite o código abaixo em seu IDE, o resultado deverá ser como o mostrado na foto acima:

/*NodeMCU */
 
#include <ESP8266WiFi.h>
 
/* OLED */
 
#include "SSD1306Wire.h"
 
#include "Wire.h"
 
const int I2C_DISPLAY_ADDRESS = 0x3c;
 
const int SDA_PIN = 0;
 
const int SCL_PIN = 2;
 
SSD1306Wire display(I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);
 
void setup ()
 
{
 
Serial.begin(115200);
 
displaySetup();
 
}
 
void loop()
 
{
 
}
 
/* Initiate and display setup data on OLED */
 
void displaySetup()
 
{
 
display.init();         // initialize display
 
display.clear();        // Clear display
 
display.display();      // Put data on display
 
 
 
Serial.println("Initiating Display Test");
 
 
 
display.setFont(ArialMT_Plain_24);
 
display.drawString(30, 0, "OLED");  // (xpos, ypos, "Text")
 
display.setFont(ArialMT_Plain_16);
 
display.drawString(18, 29, "Test initiated");
 
display.setFont(ArialMT_Plain_10);
 
display.drawString(10, 52, "Serial BaudRate:");
 
display.drawString(90, 52, String(11500));
 
display.display();  // Put data on display
 
delay (3000);
 
}

Se desejar, o codigo acima poderá ser descarregado de meu GitHub:

NodeMCU_OLED_Test

4. Mostrando a posição do servo no OLED

Agora “misturemos” os 2 códigos anteriores, assim poderemos não apenas controlar a posição do servo utilizando-se do potenciômetro, mas também ver sua posição na tela do OLED.

O código completo poderá ser baixado desde meu GitHub:

NodeMCU_Servo_Control_Test_OLED

E o resultado verificado no video abaixo:

5. Criando a App Blynk para o controle do servo

Basicamente, precisaremos alterar o código anterior, incluindo a parte referente ao Blynk mostrada a seguir:

#include <BlynkSimpleEsp8266.h>
 
char ssid [] = "YOUR SSID";
 
char pass [] = "YOUR PASSWORD";
 
char auth [] = "YOUR AUTH TOKEN"; // Servo Control Project
 
/* Reads slider in the Blynk app and writes the value to "potReading" variable */
 
BLYNK_WRITE(V0)
 
{
 
potReading = param.asInt();
 
}
 
/* Display servo position on Blynk app */
 
BLYNK_READ(V1)
 
{
 
Blynk.virtualWrite(V1, servo1Angle);
 
}
 
void setup ()
 
{
 
Blynk.begin(auth, ssid, pass);
 
}
 
void loop()
 
{
 
Blynk.run();
 
}

Deveremos definir um pino virtual V0, onde o Blynk irá “escrever” (ou “comandar”) a posição de servo, da mesma forma que fizemos com o potenciômetro. Na app do Blynk, usaremos um “Slider” (com saída definida de 0 a 1023) que usaremos para comandar a posição do servo.

Outro pino virtual, V1, será utilizado para “ler” a posição do servo, da mesma forma que fazemos com o OLED. Na app do Blynk, usaremos um “Display” (com saída definida de 0 a 180) onde mostraremos a posição do servo.

As fotos acima mostram as telas referents ao app do Blynk.

Voce poderá descarregar o programa complete desde meu GitHub:

NodeMCU_Servo_Ctrl_Blynk_EXT

6. Conclusão

Como sempre, espero que este projecto possa ajudar outros a encontrarem o seu caminho no emocionante mundo da electrônica, robótica e do IoT!

Visite o meu depositário de arquivos no GitHub para obter os arquivos atualizados:

IoT-Servo-Control

Não deixem de visitar e seguir minha página: MJRoBot.org no Facebook

Saludos desde el sur del mundo!

Até o próximo post!

Obrigado