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:
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:
O vídeo abaixo mostra os testes sendo realizados com o servo:
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:
Conecte os pinos do OLED ao NodeMCU, conforme descritos abaixo e no diagrama elétrico acima:
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:
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:
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:
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:
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:
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
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues. Ativado por
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)