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.

Servo Control Block Diagram

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

https://www.youtube.com/watch?v=AJlDOx_fKjM

1. BoM (Lista de materiais)

BoM
Valores em USD, apenas para referência.

2. Conectando o servo e o potenciômetro

IMG_1573.jpg

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

Servo-Pot Block Diagram

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:

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:

https://www.youtube.com/watch?v=xrtK1I8UyQE

3. Instalando um display

Let's 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


IMG_1582.jpg

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

Showing the Servo Position in the OLED Display

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:

https://www.youtube.com/watch?v=iLsWBcXGV24

5. Criando a App Blynk para o controle do servo

IMG_1593.jpg

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

Marcelo

Exibições: 93

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)

Destaques

Registre-se no
Lab de Garagem
Clicando aqui

Convide um
amigo para fazer
parte

curso gratis de arduino

© 2017   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço