Franzininho WiFi: Servo Motor com Arduino

02/05/2023

ÍNDICE DE CONTEÚDO

Este post faz parte da série Franzininho WiFI - Arduino

Introdução ao servo motor

O Servo Motor é um equipamento eletromecânico controlável por comandos gerados por um sinal PWM (Pulse Width Modulation). Internamente ao servo, há um encoder junto a um controlador responsáveis por interpretar e executar a movimentação de acordo com a posição e velocidade pretendida. Esse atuador possui modelos com eixo de 180° e outros modelos de 360°. A rotação do eixo varia entre 0 e o valor máximo (180° ou 360°). Caso esse limite seja ultrapassado por um esforço mecânico, pode danificar as engrenagens e acabar inutilizando o mesmo.

Os servos são compostos por três componentes: atuador, encoder e controlador. O atuador é um conjunto de engrenagens (plásticas ou metálicas) responsável por fornecer o torque e velocidade necessários. O encoder tem a função de identificar a posição do servo, geralmente com um minúsculo potenciômetro interno, onde cada valor da resistência elétrica é associado a diferentes posições do eixo do motor. O controlador é responsável por ler o sinal PWM e, através de uma malha fechada (realimentação e comparação), corrigir a posição e executar a movimentação.

O servo motor é um atuador fundamental em projetos de robótica, automação e controle. Ao final deste artigo, você estará apto a desenvolver mecanismos utilizando servos e dar vida às suas criações com a Franzininho WiFi.

Biblioteca ESP32Servo para controle do Servo motor com a Franzininho WiFi

Nesta sessão vamos apresentar os métodos mais comuns utilizados pela biblioteca ESP32Servo, derivada da biblioteca Servo, comumente utilizada em projeto com Arduino, permanecendo os mesmos métodos e exemplos de projetos (Knob e Sweep).

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

attach()

Seleciona a GPIO para o motor servo. Para selecionar o pino é importante lembrar que a GPIO deve ter suporte para gerar o sinal PWM. Devido a sobrecarga do método temos duas opções de configurar, segue abaixo:

uint8_t attach(int pin);

pin : pino para o motor servo

uint8_t attach(int pin,int min,int max);

pin : pino para o motor servo
min : configura o valor mínimo para rotação (valor em microsegundos)
max : configura o valor máximo para rotação (valor em microsegundos)

Retorna o número do canal ou INVALID_SERVO caso não registrou a GPIO

write()

Seleciona o valor em graus do servo.

void write(int value);

value : valor do ângulo desejado

writeMicroseconds()

Seleciona o valor em milissegundos do comprimento dos pulso do sinal modulador (PWM).

void writeMicroseconds(int value);

value : valor em milissegundos

read()

Pega o último escrito para comprimento do pulso.

int read(void);

Retorna o valor em graus da posição atual do servo.(0 – 180).

readMicroseconds()

Pega o último escrito para comprimento do pulso.

int readMicroseconds(void);

Retorna o valor em microsegundos da posição atual do servo.

attached()

Verifica se a GPIO foi configurada.

bool attached(void);

Retorna true se o servo foi configurado caso contrário false

detach()

Para de utilizar a GPIO configura para o servo

bool detach(void);

Materiais necessários

Para desenvolver nossa aplicação os materiais utilizados foram:

Placa Franzininho WiFi
Servo Motor 9g
Potenciômetro
Jumpers (Opcional)
Arduino IDE

Circuito para controle do Servo motor com a Franzininho WiFi

No circuito proposto utilizamos o motor servo 9g (GPIO 18) conectado ao 5V da placa Franzininho, abaixo segue uma imagem do circuito.

Código

O projeto proposto utilizou a comunicação serial para receber pelo Monitor Serial os valores de ângulos que o motor servo vai executar. Nesse projeto é necessário adicionar a biblioteca ESP32Servo.h, para isso acesse Ferramentas -> Gerenciador de Biblioteca (Tools -> Library Manager ), digite no campo de texto o nome da biblioteca, instale e já está pronta para utilizar.

/*
 Autor: Equipe Embarcados
*/
// Incluir biblioteca
#include <ESP32Servo.h>
// Declarar as variáveis
String cmd;
int current_angle;
int angle;
//Declarar o construtor
Servo servo;
//Definir o pino do servo
const int servo_pin = 18;
void setup() {


 // Inicializa o canal serial e o baud rate
 Serial.begin(115200);
 // Configura a GPIO e os limites mínimos e máximos em milisegundos
 servo.attach(servo_pin,500, 2400);
 // Move o eixo para o ângulo 0
 servo.write(0);
 // Aguarda 1 segundo
 delay(1000);
 // Imprime na serial
 Serial.println("Iniciando Projeto com Motor Servo");
 Serial.println(" Insira o angulo: ");
}






void loop()
{
 // Caso receba algum dado na Serial, então ...
 if(Serial.available()>0)
 {
   // Ler todo o buffer da serial antes de chegar no \n( carácter fim de linha)
   cmd = Serial.readStringUntil('\n');
   // Realizar um cast de String para um valor inteiro
   angle = atoi(cmd.c_str());
   // Imprimir um carácter "">>"
   Serial.print(">> ");
   // Se o ângulo for maior que 0 e menor que 180, então ...
   if(angle >=0 && angle <=180)
   {
     // Imprime o valor do ângulo na tela
     Serial.println(angle);
     // Move o eixo do motor para o ângulo desejado
     servo.write(angle);
    
   }
   // Caso não seja um valor dentro dos limites então...
   else
   {
     // Imprime na saída do monitor serial
     Serial.println ("Valor inválido");
   }
  
 }
}

Simule esse exemplo no Wokwi: https://wokwi.com/projects/363626452192856065

Explicação do Código

Nesta seção explicaremos cada trecho do código a fim de esclarecer como nosso programa funciona.

Inclusão da biblioteca ES32Servo.h

// Incluir bibiloteca
#include <ESP32Servo.h>

Declaração das variáveis, para receber os comandos da serial (cmd) e o valor do ângulo desejado (angle).

// Declarar as váriaveis
String cmd;
int angle;

Cria o objeto do tipo servo:

//Declarar o construtor
Servo servo;

Declara o pino onde está conectado o motor servo:

//Definir o pino do servo
const int servo_pin = 18;

No setup(), temos a inicialização da comunicação serial e a seleção da velocidade de comunicação. Configuramos o pino que está conectado ao motor servo no método attach com os valores máximo e mínimo o quais são padrões. E por fim imprimimos uma mensagem para o usuário inserir os valores dos ângulos:

void setup() {


 // Inicializa o canal serial e o baud rate
 Serial.begin(115200);
 // Configura a GPIO e os limites mínimos e máximos em milisegundos
 servo.attach(servo_pin,500, 2400);
 // Move o eixo para o ângulo 0
 servo.write(0);
 // Aguarda 1 segundo
 delay(1000);
 // Imprime na serial
 Serial.println("Iniciando Projeto com Motor Servo");
 Serial.println(" Insira o angulo: ");
}

No loop, construímos nossa lógica propriamente dita para receber os comandos da Serial e realizar a execução dos movimentos no motor servo. Dentre os métodos apresentada nesse exemplo de projeto, o que pode ser que não esteja familiarizado é o readStringUntil(), bem esse método apenas pega todos os caracteres que entraram Serial e devolver até último caractere antes do ‘\n’ (fim de linha):

void loop()
{
 // Caso receba algum dado na Serial, então ...
 if(Serial.available()>0)
 {
   // Ler todo o buffer da serial antes de chegar no \n( carácter fim de linha)
   cmd = Serial.readStringUntil('\n');
   // Realizar um cast de String para um valor inteiro
   angle = atoi(cmd.c_str());
   // Imprimir um carácter "">>"
   Serial.print(">> ");
   // Se o ângulo for maior que 0 e menor que 180, então ...
   if(angle >=0 && angle <=180)
   {
     // Imprime o valor do ângulo na tela
     Serial.println(angle);
     // Move o eixo do motor para o ângulo desejado
     servo.write(angle);
    
   }
   // Caso não seja um valor dentro dos limites então...
   else
   {
     // Imprime na saída do monitor serial
     Serial.println ("Valor inválido");
   }
  
 }
}

Conclusão

Nesse artigo abordamos sobre o motor servo e os métodos da biblioteca (ESP32Servo), esse atuador possui elevada precisão e é muito simples de realizar sua montagem no circuito. Devido a sua popularidade esse motor atende a uma vasta quantidade de aplicações: robótica, aeromodelismo, automação, Controle Eletromecânicos e diversas outras áreas. No exemplo de projeto apresentamos uma das possíveis formas de criar uma interface Serial para o controle de servos, mas encorajamos a procurar outros projetos para explorar mais esse atuador.