IOT FEITO SIMPLES: CONTROLANDO SERVOS COM O NODEMCU E O BLYNK

Neste tutorial, exploraremos como controlar um servo através da Internet. Para isso, lançaremos mão de uma importante dupla de dispositivos no mundo do IoT:

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:

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/Node

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

1. BoM (Lista de materiais)

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/Valores-em-USD

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

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/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.

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/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:

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/servo-circuit-1

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

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/SSD1306

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

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/ArialMT_Plain

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

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/App-Blynk

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.

Imagem Páginas/03. Blog/Artigos/Controlando servos com o NodeMCU e o Blynk/pino-virtual-V1

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

A Maior Comunidade de Internet das Coisas do Brasil
Ver mais do o autor

Matérias relacionadas

Imagem principal do artigo Soluções para o Transporte Inteligente de Cargas e Pessoas

Soluções para o Transporte Inteligente de Cargas e Pessoas

No mundo dinâmico da mobilidade industrial e urbana, a necessidade de soluções robustas, fiáveis ​​e eficientes é fundamental.

Em 29/02/2024 às 14h10 - Atualizado em 29/02/2024 às 14h12

Imagem principal do artigo Diversidade, Equidade e Inclusão: o que isso tem a ver com Tecnologia?

Diversidade, Equidade e Inclusão: o que isso tem a ver com Tecnologia?

O mercado de trabalho está cada vez mais conectados a debates importantes como a necessidade de construção de empresas plurais.

Em 28/03/2023 às 08h40 - Atualizado em 29/03/2023 às 08h15

Imagem principal do artigo Como você contrata e o que espera de um profissional de TI

Como você contrata e o que espera de um profissional de TI

Veja as principais discussões sobre as exigências do profissional de IT.

Em 02/12/2022 às 06h01 - Atualizado em 07/02/2023 às 15h03

Imagem principal do artigo COMO CRIAR A SUA REDE LORA | TUDO SOBRE IOT

COMO CRIAR A SUA REDE LORA | TUDO SOBRE IOT

Entenda as principais diferenças entre LoRa e LoRaWAN e como criar sua própria rede.

Em 02/12/2022 às 05h09 - Atualizado em 07/02/2023 às 15h03

Imagem principal do artigo ROBÔ CONTROLADO POR VOZ VIA WIFI

ROBÔ CONTROLADO POR VOZ VIA WIFI

Como desenvolver um robô controlado por voz via WiFi e utilizando como microcontrolador nosso velho amigo, o NodeMCU!

Em 01/12/2022 às 13h31 - Atualizado em 07/02/2023 às 15h03

Imagem principal do artigo IOT FEITO SIMPLES: ESTAÇÃO METEOROLÓGICA DOMÉSTICA COM NODEMCU E OLED

IOT FEITO SIMPLES: ESTAÇÃO METEOROLÓGICA DOMÉSTICA COM NODEMCU E OLED

Continuemos nossa exploração pelo mundo do IoT, nas asas do NodeMCU! Vamos desenvolver uma estação meteorológica doméstica!

Em 01/12/2022 às 11h25 - Atualizado em 07/02/2023 às 15h02

Imagem principal do artigo “IOT FEITO FÁCIL”: CONECTANDO COISAS DESDE QUALQUER CANTO DO MUNDO!

“IOT FEITO FÁCIL”: CONECTANDO COISAS DESDE QUALQUER CANTO DO MUNDO!

Nosso objetivo neste tutorial será basicamente coletar informações de uma unidade local, enviando-as à internet.

Em 30/11/2022 às 13h21 - Atualizado em 07/02/2023 às 15h02

Imagem principal do artigo O IOT FEITO SIMPLES: MONITORANDO MÚLTIPLOS SENSORES

O IOT FEITO SIMPLES: MONITORANDO MÚLTIPLOS SENSORES

Alguns meses atrás, publiquei aqui um tutorial sobre o monitoramento de temperatura usando o DS18B20, um sensor digital que se comunica através de um barramento de um único fio (bus do tipo “1-wire”), sendo os dados enviados pela à internet com a ajuda de

Em 30/11/2022 às 10h44 - Atualizado em 07/02/2023 às 15h02

Imagem principal do artigo IOT FEITO FÁCIL: ESP-MICROPYTHON-MQTT-THINGSPEAK

IOT FEITO FÁCIL: ESP-MICROPYTHON-MQTT-THINGSPEAK

Com a ajuda do protocolo MQTT, enviaremos dados capturados de sensores, à um serviço de IoT, o ThingSpeak.com e a um aplicativo móvel, o Thingsview.

Em 30/11/2022 às 10h13 - Atualizado em 07/02/2023 às 15h02

Imagem principal do artigo IOT FEITO FÁCIL”: BRINCANDO COM O ESP32 NO ARDUINO IDE

IOT FEITO FÁCIL”: BRINCANDO COM O ESP32 NO ARDUINO IDE

este tutorial, exploraremos o ESP32, o mais novo dispositivo para uso no campo do IoT. Esta placa, desenvolvida pela Espressif, deverá ser a sucessora do ESP8266, devido ao seu baixo preço e excelentes recursos.

Em 29/11/2022 às 16h06 - Atualizado em 08/05/2024 às 15h52