Neste post, vamos explorar seis métodos diferentes para controlar um servo motor com Arduino, desde o básico até técnicas mais avançadas. Cada método será apresentado com diagramas de conexão e exemplos de código para que você possa seguir e implementar em seus próprios projetos.
Se você está começando a explorar o controle de servo motores com Arduino, vale a pena conferir nosso post anterior: “O que é servo motor? Funcionamento, tipos e como testar“. Lá, explicamos em detalhes o funcionamento dos servo motores, os diferentes tipos disponíveis e como você pode testar um servo motor.
Como ligar um servo motor no Arduino?
Neste primeiro exemplo, iremos aprender como ligar um servo motor ao Arduino, utilizando a biblioteca Servo.h.
Para isso, você irá precisar dos seguinte componentes:
O Micro Servo 9g possui três fios:
- Vermelho: Alimentação (5V)
- Marrom: Terra (GND)
- Laranja: Sinal (PWM)
As conexões do micro servo motor no Arduino são bastante simples:
- Alimentação: Conecte o fio vermelho do servo ao pino 5V do Arduino.
- Terra: Conecte o fio marrom do servo ao pino GND do Arduino.
- Sinal: Conecte o fio laranja ao pino digital 6 do Arduino.
Veja o esquemático abaixo com as conexões que precisam ser realizadas:
Agora que o servo motor está conectado, você pode usar o código abaixo para testar o controle do servo:
// Programa: Controlando um servo motor com Arduino (servo motor arduino code)
#include <Servo.h> // Inclui a biblioteca Servo para controlar servos
Servo meuServo; // Cria um objeto Servo para controlar o servo motor
int pos; // Declara uma variável para controlar a posição do servo motor
void setup() {
meuServo.attach(6); // Associa o servo motor ao pino digital 6 do Arduino
meuServo.write(0); // Define a posição inicial do servo motor para 0 graus
}
void loop() {
// Movimento do servo de 0 a 90 graus
for (pos = 0; pos < 90; pos++) {
meuServo.write(pos); // Define a posição atual do servo
delay(15); // Aguarda 15 milissegundos antes de mover para a próxima posição
}
delay(1000); // Aguarda 1 segundo antes de iniciar o próximo movimento
// Movimento do servo de 90 a 0 graus
for (pos = 90; pos >= 0; pos--) {
meuServo.write(pos); // Define a posição atual do servo
delay(15); // Aguarda 15 milissegundos antes de mover para a próxima posição
}
delay(1000); // Aguarda 1 segundo antes de iniciar o próximo ciclo
}
Após carregar o código, o servo motor deve começar a se mover para as posições de 0 a 90 graus e voltar para 0 graus, com uma pausa de 1 segundo entre cada ciclo.
Acima você pode ver a simulação do funcionamento do servo motor no Tinkercad.
Servo motor com Arduino: Controle com potenciômetro
Controlar um servo motor com um potenciômetro é uma forma prática de ajustar a posição do servo manualmente. Esta configuração é útil em projetos onde a entrada do usuário deve ser convertida em um movimento preciso.
Para isso, você irá precisar dos seguinte componentes:
E as conexões do potenciômetro à placa Arduino são as seguintes:
- Terminal 1: Conecte ao GND do Arduino.
- Terminal 2 (pino central): Conecte ao pino A0 do Arduino.
- Terminal 3: Conecte ao 5V do Arduino.
Veja o esquemático abaixo com as conexões que precisam ser realizadas:
Agora que o servo motor e o potenciômetro estão conectados, você pode usar o código abaixo para testar o controle do servo com o potenciômetro:
// Programa: Controlando um servo motor com potenciômetro
#include <Servo.h> // Inclui a biblioteca Servo para controlar servos
Servo meuServo; // Cria um objeto Servo para controlar o servo motor
int pos; // Variável para armazenar a posição do servo motor
int potPin = A0; // Pino analógico onde o potenciômetro está conectado
int val; // Variável para armazenar o valor lido do potenciômetro
void setup() {
meuServo.attach(6); // Associa o servo motor ao pino digital 6 do Arduino
meuServo.write(0); // Define a posição inicial do servo motor para 0 graus
}
void loop() {
val = analogRead(potPin); // Lê o valor do potenciômetro (0 a 1023)
pos = map(val, 0, 1023, 0, 180); // Mapeia o valor do potenciômetro para a faixa de 0 a 180 graus
meuServo.write(pos); // Define a posição do servo motor
delay(15); // Aguarda um curto intervalo para estabilizar o movimento do servo
}
Após carregar o código, ao girar o potenciômetro, o servo motor deve se mover para posições correspondentes entre 0 e 180 graus. É possível também ler o ângulo do Servo através do comando read() e caso precise usar o pino que o servo está conectado para outra coisa basta usar o comando detach().
Acima você pode ver a simulação do funcionamento do potenciômetro controlando o servo motor no Tinkercad.
Servo motor com Arduino: Controle de velocidade
Controlar a velocidade de um servo motor pode ser útil em muitos projetos de robótica e automação, onde um movimento mais suave e controlado é necessário. Usando a biblioteca VarSpeedServo.h, podemos ajustar diretamente a velocidade do servo motor. Além disso, usaremos dois potenciômetros: um para ajustar a posição e outro para ajustar a velocidade.
Para isso, você irá precisar dos seguinte componentes:
Veja o esquemático abaixo com as conexões que precisam ser realizadas:
Agora que o servo motor e os potenciômetros estão conectados, você pode usar o código abaixo para testar o controle da velocidade do servo com o potenciômetro:
// Programa: Controlando a velocidade de um servo motor
#include <VarSpeedServo.h> // Inclui a biblioteca VarSpeedServo para controlar servos com velocidade
VarSpeedServo meuServo; // Cria um objeto VarSpeedServo para controlar o servo motor
int posPotPin = A0; // Pino analógico onde o potenciômetro de posição está conectado
int velPotPin = A1; // Pino analógico onde o potenciômetro de velocidade está conectado
int pos; // Variável para armazenar a posição do servo motor
int vel; // Variável para armazenar a velocidade do servo motor
void setup() {
meuServo.attach(6); // Associa o servo motor ao pino digital 6 do Arduino
}
void loop() {
int posVal = analogRead(posPotPin); // Lê o valor do potenciômetro de posição (0 a 1023)
int velVal = analogRead(velPotPin); // Lê o valor do potenciômetro de velocidade (0 a 1023)
pos = map(posVal, 0, 1023, 0, 180); // Mapeia o valor do potenciômetro de posição para a faixa de 0 a 180 graus
vel = map(velVal, 0, 1023, 0, 255); // Mapeia o valor do potenciômetro de velocidade para a faixa de 0 a 255
meuServo.write(pos, vel, true); // Define a posição e a velocidade do servo motor
delay(15); // Aguarda um curto intervalo para estabilizar o movimento do servo
}
Observe o movimento do servo motor. Girar o primeiro potenciômetro (conectado ao A0) ajustará a posição do servo, enquanto girar o segundo potenciômetro (conectado ao A1) ajustará a velocidade do movimento.
Servo motor com Arduino: Utilizando o Motor Shield L293D
O Motor Shield L293D é geralmente utilizado para controlar motores DC e motores de passo, mas também pode ser usado para controlar servos em projetos que exigem um controle mais robusto ou em conjunto com outros motores. Embora o L293D não seja especificamente projetado para servos, ele pode fornecer energia adicional e permitir que você controle servos em projetos mais complexos.
Para isso, você irá precisar dos seguinte componentes:
O Motor Shield L293D possui barramentos específicos para conectar até dois servos, como ilustrado na imagem abaixo.
Na placa do Motor Shield, os pinos de sinal para os servos são marcados com a letra “S”. Esses pinos devem ser conectados diretamente aos pinos digitais 9 e 10 do Arduino. O pino digital 9 é responsável pelo controle do SERVO_2, enquanto o pino digital 10 controla o SERVO_1.
Coloque o Motor Shield L293D na placa Arduino. Certifique-se de que os pinos do shield estejam alinhados corretamente com os pinos da placa Arduino. O shield deve se encaixar diretamente sobre o Arduino.
Para controlar um servo motor com o Motor Shield L293D, você deve conectar o servo diretamente aos pinos de controle de um dos canais do shield, da seguinte forma:
- Terra: Conecte o fio marrom do servo ao pino mais a esquerda (-) do L293D.
- Alimentação: Conecte o fio vermelho do servo ao pino central (+) do L293D.
- Sinal: Conecte o fio laranja do servo ao pino mais a direita (S) do L293D.
Veja o esquemático abaixo com as conexões que precisam ser realizadas:
Agora, você pode usar o mesmo código para controlar o servo motor que usaria sem o shield, já que o controle do servo é realizado diretamente pelo Arduino. O Motor Shield L293D não altera o código necessário para o controle do servo.
#include <Servo.h> // Inclui a biblioteca Servo para controlar servos
Servo meuServo; // Cria um objeto Servo para controlar o servo motor
void setup() {
meuServo.attach(9); // Associa o servo motor ao pino digital 9 do Arduino
}
void loop() {
// Move o servo de 0 a 180 graus
for (int pos = 0; pos <= 180; pos++) {
meuServo.write(pos); // Define a posição do servo motor
delay(15); // Aguarda 15 milissegundos para o servo alcançar a posição
}
delay(1000); // Aguarda 1 segundo
// Move o servo de 180 a 0 graus
for (int pos = 180; pos >= 0; pos--) {
meuServo.write(pos); // Define a posição do servo motor
delay(15); // Aguarda 15 milissegundos para o servo alcançar a posição
}
delay(1000); // Aguarda 1 segundo
}
Observe o movimento do servo motor. Ele deve mover-se de 0 a 180 graus e de volta para 0 graus, conforme definido no código.
Controlando dois servo motores
Controlar dois servo motores simultaneamente com o Arduino é uma tarefa bastante comum em projetos de robótica e automação. A biblioteca Servo.h facilita muito essa tarefa, permitindo que você controle vários servos com apenas alguns comandos.
Para isso, você irá precisar dos seguinte componentes:
As conexões dos servo motores (1 e 2) com Arduino são as seguintes:
- Alimentação: Conecte os fios vermelhos dos servos ao pino 5V do Arduino.
- Terra: Conecte os fios marrons dos servos ao pino GND do Arduino.
- Sinal: Conecte o fio laranja do servo 1 ao pino digital 9 do Arduino. Conecte o fio laranja do servo 2 ao pino digital 10 do Arduino.
Veja o esquemático abaixo com as conexões que precisam ser realizadas:
O código abaixo mostra como controlar dois servos usando a biblioteca Servo.h. Cada servo será movido de 0 a 180 graus e de volta para 0 graus.
// Programa: Controlando dois servo motores com Arduino
#include <Servo.h> // Inclui a biblioteca Servo para controlar servos
Servo servo1; // Cria um objeto Servo para o primeiro servo motor
Servo servo2; // Cria um objeto Servo para o segundo servo motor
void setup() {
servo1.attach(9); // Associa o primeiro servo motor ao pino digital 9 do Arduino
servo2.attach(10); // Associa o segundo servo motor ao pino digital 10 do Arduino
}
void loop() {
// Move ambos os servos de 0 a 180 graus
for (int pos = 0; pos <= 180; pos++) {
servo1.write(pos); // Define a posição do primeiro servo motor
servo2.write(pos); // Define a posição do segundo servo motor
delay(15); // Aguarda 15 milissegundos para os servos alcançarem a posição
}
delay(1000); // Aguarda 1 segundo
// Move ambos os servos de 180 a 0 graus
for (int pos = 180; pos >= 0; pos--) {
servo1.write(pos); // Define a posição do primeiro servo motor
servo2.write(pos); // Define a posição do segundo servo motor
delay(15); // Aguarda 15 milissegundos para os servos alcançarem a posição
}
delay(1000); // Aguarda 1 segundo
}
Observe o movimento dos servo motores. Ambos devem mover-se de 0 a 180 graus e de volta para 0 graus, sincronizadamente.
Acima você pode ver a simulação do funcionamento dos dois servo motores no Tinkercad.
Controle sem usar uma biblioteca
Controlar um servo motor sem utilizar uma biblioteca pode ser um excelente exercício para entender melhor como funcionam os sinais PWM (Pulse Width Modulation). Em vez de usar a biblioteca Servo.h, que simplifica o controle do servo, escreveremos o código para gerar sinais PWM diretamente. Isso nos dá um controle mais granular sobre o tempo e a frequência dos pulsos enviados ao servo motor.
Para isso, você irá precisar dos seguinte componentes:
Servos geralmente são controlados por sinais PWM. A posição do servo é determinada pela largura do pulso:
- Um pulso de 0,6 ms (milissegundo) geralmente coloca o servo na posição de 0 graus.
- Um pulso de 1,5 ms coloca o servo em 90 graus (posição central).
- Um pulso de 2,4 ms coloca o servo em 180 graus.
Esses pulsos são enviados a uma frequência de aproximadamente 50 Hz, o que corresponde a um ciclo de 20 ms.
Veja o esquemático abaixo com as conexões que precisam ser realizadas:
Agora que o servo motor está conectado, você pode usar o código abaixo para testar o controle do servo sem uso de uma biblioteca, como a Servo.h:
// Programa: Controlando um servo motor sem biblioteca
/ Define o pino de controle do servo
const int servoPin = 6;
// Função para enviar um pulso PWM para o servo
void writeServo(int angle) {
// Calcula o tempo do pulso em microssegundos
int pulseWidth = map(angle, 0, 180, 544, 2400); // Mapear o ângulo para o intervalo de pulso do servo
digitalWrite(servoPin, HIGH); // Define o pino como HIGH
delayMicroseconds(pulseWidth); // Aguarda pelo tempo do pulso
digitalWrite(servoPin, LOW); // Define o pino como LOW
delay(20 - pulseWidth / 1000); // Aguarda o restante do ciclo de 20ms
}
void setup() {
pinMode(servoPin, OUTPUT); // Define o pino do servo como saída
}
void loop() {
for (int angle = 0; angle <= 180; angle++) {
writeServo(angle); // Gira o servo de 0 a 180 graus
delay(20); // Aguarda um curto intervalo para o movimento do servo
}
delay(1000); // Aguarda 1 segundo
for (int angle = 180; angle >= 0; angle--) {
writeServo(angle); // Gira o servo de 180 a 0 graus
delay(20); // Aguarda um curto intervalo para o movimento do servo
}
delay(1000); // Aguarda 1 segundo
}
As funções utilizadas no código acima estão explicadas abaixo:
- writeServo(int angle): Esta função calcula a largura do pulso necessária para a posição desejada do servo e envia o pulso através do pino definido.
- map(): A função map() é usada para converter o ângulo (0 a 180 graus) no intervalo de largura de pulso correspondente (544 a 2400 microssegundos).
- digitalWrite(): A função digitalWrite() define o pino do servo como HIGH ou LOW para iniciar e terminar o pulso.
- delayMicroseconds(): A função delayMicroseconds() aguarda pelo tempo de largura do pulso calculado.
- delay(): A função delay() aguarda o restante do ciclo de 20 ms.
Este método pode ser útil para aplicações que exigem um controle mais fino ou quando você deseja evitar o uso de bibliotecas externas.
Se você tiver dúvidas, sugestões ou experiências para compartilhar, fique a vontade para deixar um comentário abaixo. E para não perder nenhum conteúdo como este, não deixe de nos seguir no Instagram.
