Controle de Servos com a Vespa

Introdução

Você recebeu a sua Vespa e quer saber como usá-la? Não se preocupe, estamos aqui para ajudá-lo nestes primeiros passos e para mostrar como usar as funções básicas da biblioteca desenvolvida para ela.

Neste tutorial você verá como fazer o controle de servomotores pela Vespa, o comportamento de cada função de controle da biblioteca da Vespa, e como isso pode ser aplicado na prática.

Lista de Materiais

Mini Protoboard 170 Pontos - Preta

R$3.90

Jumpers Macho-Fêmea x40 Unidades

R$7.90

Controle Automático

Neste primeiro projeto, iremos fazer um controle automático da posição do eixo do servomotor usando as funções da biblioteca da Vespa, onde o eixo irá do seu limite mínimo até o seu limite máximo e vice-versa repetidamente.

Circuito

Para este primeiro projeto, apenas conecte o servo ao pino S1 da Vespa, conforme mostrado na imagem abaixo. A conexão pode ser direta, apenas atente-se à polaridade.

Código

Para o controle do servomotor, usaremos a biblioteca da Vespa, portanto, para instalá-la, siga os passos do tutorial Primeiros Passos com a Vespa.

Como um primeiro controle simples do servo, faremos com que ele mova o seu eixo de 0 a 180° e depois de 180 a 0°. Para isso, carregue o código a seguir na sua Vespa.

/*******************************************************************************
* Vespa - Primeiros Passos para Controle de Servomotor (v1.0)
* 
* Codigo de demonstracao das funcoes para o controle do angulo de
* servomotor pela Vespa.
* 
* Copyright 2022 RoboCore.
* Escrito por Giovanni de Castro (06/06/2022).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Inclusao da biblioteca da Vespa
#include <RoboCore_Vespa.h>

//Criacao do objeto "servo" para o controle do servo
VespaServo servo;

//Declaracao das variaveis de angulo maximo e minimo do servo
const int ANGULO_MAXIMO = 180;
const int ANGULO_MINIMO = 0;

//------------------------------------------------------------------------------
void setup() {

  //Inicializacao do monitor serial
  Serial.begin(115200);
  Serial.println("<--- Primeiros Passos com o Controle de Servomotor da Vespa --->");

  //Conecta o objeto "servo" ao pino S1 (GPIO 26) da Vespa
  servo.attach(VESPA_SERVO_S1);

  //Inicia o servo com eixo centralizado
  servo.write(90);
      
}

//------------------------------------------------------------------------------
void loop() {

  Serial.println("<--- ANTI-HORARIO --->");
  //Move o eixo do servo de 0 a 180
  for(int i = ANGULO_MINIMO; i <= ANGULO_MAXIMO; i++){
    //Atualiza o angulo do servo de acordo com o valor da variavel "i"
    servo.write(i);
    Serial.print("Angulo: ");
    Serial.println(i);
    delay(5); //Atrasa a movimentacao do servo
  }

  delay(100); //Atraso para nova movimentacao do servo

  Serial.println("<--- HORARIO --->");
  //Move o eixo do servo de 180 a 0
  for(int i = ANGULO_MAXIMO; i >= ANGULO_MINIMO; i--){
    //Atualiza o angulo do servo de acordo com o valor da variavel "i"
    servo.write(i);
    Serial.print("Angulo: ");
    Serial.println(i); //Atrasa a movimentacao do servo
    delay(5);
  }

  delay(100); //Atraso para nova movimentacao do servo

}
//------------------------------------------------------------------------------

Entendendo o Código

O código se inicia com a inclusão da biblioteca "RoboCore_Vespa" e, em seguida, é criado o objeto servo como instância "VespaServo" da biblioteca, que será utilizado para o controle do servomotor.

Para finalizar as declarações globais do código, temos a declaração das constantes ANGULO_MAXIMO e ANGULO_MINIMO, que armazenam, respectivamente, o ângulo máximo (180°) e o ângulo mínimo (0°) de movimentação do servo.

Já nas configurações do código (função void setup()), além de iniciar a comunicação com o monitor serial em 115200 bps, também "conectamos" o objeto servo ao pino S1 (GPIO 26 do ESP32) através da função attach(), que é chamada no código pelo comando servo.attach(VESPA_SERVO_S1). O parâmetro VESPA_SERVO_S1 é uma definição interna da biblioteca, que atrela esta "palavra" ao GPIO 26 do ESP32. Para encerrar as configurações do código, o servo é acionado para o seu ângulo central (90°) pela função write(), que é chamada no código pelo comando servo.write(90).

Já na repetição do código, o servo é controlado para se mover no sentido anti-horário de 0 a 180° por um laço for, onde, a cada repetição, o ângulo do servo é atualizado pelo comando servo.write(i) de acordo com o valor da variável i criada para o laço. Em seguida, é feito basicamente o mesmo novamente, porém, no segundo laço for, o motor é movido no sentido horário de 180 a 0°.

void loop() {

  Serial.println("<--- ANTI-HORARIO --->");
  //Move o eixo do servo de 0 a 180
  for(int i = ANGULO_MINIMO; i <= ANGULO_MAXIMO; i++){
    //Atualiza o angulo do servo de acordo com o valor da variavel "i"
    servo.write(i);
    Serial.print("Angulo: ");
    Serial.println(i);
    delay(5); //Atrasa a movimentacao do servo
  }

  delay(100); //Atraso para nova movimentacao do servo

  Serial.println("<--- HORARIO --->");
  //Move o eixo do servo de 180 a 0
  for(int i = ANGULO_MAXIMO; i >= ANGULO_MINIMO; i--){
    //Atualiza o angulo do servo de acordo com o valor da variavel "i"
    servo.write(i);
    Serial.print("Angulo: ");
    Serial.println(i); //Atrasa a movimentacao do servo
    delay(5);
  }

  delay(100); //Atraso para nova movimentacao do servo

}

O Que Deve Acontecer

Após carregar o código para a Vespa, você verá que o eixo do servo começará a se mover em ambos os sentidos até seus limites máximo e mínimo, como no GIF abaixo. Se abrir o monitor serial com a velocidade 115200 bps, você também verá a atualização do ângulo que está sendo usado para controlar o servo.

Resultado Final

Controle Manual

Agora que já entendemos o básico de como controlar servomotores pela Vespa, porque não realizar um controle manual do eixo do servo para replicar o eixo de um potenciômetro? Afinal, eles possuem limites de giro similares, então seria possível ter uma grande precisão no posicionamento do eixo do servo.

Circuito

Para este projeto, monte o circuito a seguir.

Código

Com o circuito montado, carregue o código a seguir para a sua Vespa para controlar o movimento do eixo do servo pelo potenciômetro, basicamente replicando-o.

/*******************************************************************************
* Vespa - Primeiros Passos para Controle de Servomotor (v1.0)
* 
* Codigo de demonstracao das funcoes para o controle do angulo do
* servomotor pela Vespa. A leitura analogica pelo pino VP de um potenciometro
* atualiza a posicao do servo.
* 
* Copyright 2022 RoboCore.
* Escrito por Giovanni de Castro (06/06/2022).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Inclusao da biblioteca da Vespa
#include <RoboCore_Vespa.h>

//Criacao do objeto "servo" para o controle do servo
VespaServo servo;

//Declaracao da variavel que armazena o pino VP conectado ao potenciometro
const int PINO_POTENCIOMETRO = 36;

//Declaracao das variaveis de angulo maximo e minimo do servo
const int ANGULO_MAXIMO = 180;
const int ANGULO_MINIMO = 0;

//Declaracao das variaveis de leitura maxima e minima analogica
const int LEITURA_MAXIMA = 4095;
const int LEITURA_MINIMA = 0;

//------------------------------------------------------------------------------
void setup() {
  
  //Inicializacao do monitor serial
  Serial.begin(115200);
  Serial.println("<--- Primeiros Passos com o Controle de Servomotor da Vespa --->");

  //Conecta o objeto "servo" ao pino S1 (GPIO 26) da Vespa
  servo.attach(VESPA_SERVO_S1);

  //Inicia o servo com eixo centralizado
  servo.write(90);

  //Configura o pino conectado ao potenciometro como entrada
  pinMode(PINO_POTENCIOMETRO, INPUT);

}

//------------------------------------------------------------------------------
void loop() {

  //Realiza a leitura analogica do potenciometro
  int leitura_analogica = analogRead(PINO_POTENCIOMETRO);
  //Mapeia o angulo de controle do servo pela leitura analogica do potenciometro
  int angulo_mapeado = map(leitura_analogica, LEITURA_MINIMA, LEITURA_MAXIMA, ANGULO_MINIMO, ANGULO_MAXIMO);

  Serial.print("Leitura analogica: ");
  Serial.print(leitura_analogica);
  Serial.print(" | Angulo mapeado: ");
  Serial.println(angulo_mapeado);

  //Atualiza a posicao do servo com o angulo mapeado
  servo.write(angulo_mapeado);
  
}
//------------------------------------------------------------------------------

Entendendo o Código

Este código se inicia basicamente idêntico ao do projeto anterior, porém com a declaração de algumas variáveis adicionais, sendo elas PINO_POTENCIOMETRO, que armazena o número do GPIO do pino VP conectado ao potenciômetro do circuito; LEITURA_MAXIMA, que armazena o valor máximo da leitura analógica do ESP32; e LEITURA_MINIMA, que armazena o valor mínimo da leitura analógica do ESP32.

Na configuração do código (função void setup()), além das mesmas configurações feitas no projeto anterior, configuramos o pino VP do ESP32, conectado ao potenciômetro do circuito, como uma entrada da placa.

Já na repetição do código (função void loop()), declaramos a variável leitura_analogica para armazenar a leitura analógica do pino VP e, em seguida, é declarada a variável angulo_mapeado que recebe o ângulo mapeado de acordo com o retorno da função map(). Esta última função leva em conta os valores das variáveis leitura_analogica, LEITURA_MINIMA, LEITURA_MAXIMA, ANGULO_MINIMO e ANGULO_MAXIMO para calcular um valor resultante entre 0 e 180º, já que a leitura analógica do potenciômetro retorna um valor entre 0 e 4095. Com o ângulo mapeado, a posição do eixo do servo é atualizado com o valor armazenado na variável angulo_mapeado.

void loop() {

  //Realiza a leitura analogica do potenciometro
  int leitura_analogica = analogRead(PINO_POTENCIOMETRO);
  //Mapeia o angulo de controle do servo pela leitura analogica do potenciometro
  int angulo_mapeado = map(leitura_analogica, LEITURA_MINIMA, LEITURA_MAXIMA, ANGULO_MINIMO, ANGULO_MAXIMO);

  Serial.print("Leitura analogica: ");
  Serial.print(leitura_analogica);
  Serial.print(" | Angulo mapeado: ");
  Serial.println(angulo_mapeado);

  //Atualiza a posicao do servo com o angulo mapeado
  servo.write(angulo_mapeado);
  
}

O Que Deve Acontecer

Após carregar o código para a placa, mova o eixo do potenciômetro e note que o eixo do servo irá se mover junto, tentando replicar a movimentação do potenciômetro. Juntamente com isso, se quiser, você pode monitorar o mapeamento da leitura do potenciômetro pelo monitor serial em 115200 bps.

Resultado Final

Indo Além

Os códigos deste tutorial são apenas demonstrações do uso das funções da biblioteca da Vespa para o controle de servomotores, porém é possível implementar diversas funcionalidades com este controle simples de servomotores, por exemplo, para o controle de braços robóticos, como mostramos no tutorial Controle Web de Braço Robótico com a Vespa.

Além disso, também temos diversos outros tutoriais demonstrando todas as funcionalidades da Vespa.

Conclusão

Neste tutorial vimos as funções de controle de servomotores da biblioteca da Vespa e como usá-las para o controle de servos.

Controle de Servos com a Vespa

Introdução

Lista de Materiais

Lista completa de produtos

Vespa

Micro Servo DS-S006

Potenciômetro 10kΩ

Mini Protoboard 170 Pontos - Preta

Cabo USB Micro B 80cm

Jumpers Macho-Fêmea x40 Unidades

Controle Automático

Circuito

Código

Entendendo o Código

O Que Deve Acontecer

Controle Manual

Circuito

Código

Entendendo o Código

O Que Deve Acontecer

Indo Além

Conclusão