Calibração Precisa de Servos com Arduino UNO e Shield PWM Adafruit

Componentes e Materiais

Arduino UNO	1
Shield Driver PWM para Servos Adafruit	1
Parafuso M3	8
Arruela M3	8
Conversor DC-DC Step Down LM2596	1
Filamento PLA Vermelho	1
Filamento PLA Branco	1
Transferidor de 180° Transparente	1
Potenciômetro Rotativo (genérico)	1
Servomotor 9g	1

Ferramentas Necessárias

• Impressora 3D (genérica)

Aplicativos e Serviços Online

• Arduino IDE
• Autodesk Fusion 360

Sobre o Projeto

Em uma publicação anterior no Hackster, descrevi como criei um equipamento para comparar o comportamento de diferentes servos do mesmo lote, demonstrando que o envio do mesmo sinal PWM para servos distintos resulta em diferenças significativas — a imagem abaixo mostra servos que partiram da mesma posição extrema anti-horária e receberam o mesmo sinal PWM; todos apresentam comportamento ligeiramente diferente.

Por Que Não Usar Bibliotecas de Servo Existentes para Arduino?

Utilizo o Adafruit PWM Servo Driver para acionar vários servos, permitindo enviar um sinal PWM diferente para cada um. Poderia usar a biblioteca Servo nativa do Arduino, mas tenho alguns motivos para não fazê-lo:

• Com o Adafruit PWM Servo Driver, controlo meus servos usando apenas dois pinos via I2C, em vez de dedicar um pino do Arduino a cada servo.
• Às vezes, com a biblioteca Servo do Arduino, ao anexar a um servo e enviar sinal para a posição de zero graus, ele gira até o limite de curso e tritura as engrenagens internas.

Claro, os servos 9g que uso são baratos e não projetados para precisão — mas acredito que posso extrair mais valor deles. Quero usá-los em um robô andarilho e preciso que seu comportamento seja mais preciso e previsível.

Como Controlar Meus Servos Hobby com Mais Precisão?

Confirmar que meus servos se comportam de forma diferente me levou a construir um dispositivo para calibrar um servo: quais valores PWM preciso enviar para mover o servo à posição de 0 graus? Ou ao ponto central de 90 graus? Como evitar enviar um valor PWM que leve o servo a uma posição extrema com trituração de engrenagens?

Decidi combinar dois conceitos simples:

• Alinhar o servo com o centro de um transferidor simples, de modo que, à medida que o braço do servo gira, posso medir sua posição.
• Conectar um potenciômetro a uma entrada analógica do Arduino, para controlar a posição do braço do servo ajustando o valor PWM conforme giro o eixo do potenciômetro.

Nesta versão, usei o Monitor Serial da Arduino IDE para ler o valor do sinal PWM, que registro manualmente.

Usei o Autodesk 123D para projetar um suporte simples que acomoda o potenciômetro, o transferidor, um único servo, o Arduino, o driver PWM Adafruit e uma fonte de alimentação.

Quis manter o uso do driver PWM Adafruit na calibração, pois é o que usarei no projeto final. Se fosse controlar o servo diretamente de um pino do Arduino, replicaria isso no dispositivo e calibraria contra o PWM do Arduino.

Construindo o Dispositivo

Imprimi todas as peças e as fixei com parafusos e arruelas M3. Os furos de montagem no projeto são ajustados para meus componentes — componentes diferentes podem ter variações nos diâmetros e posições dos furos.

Para a eletrônica, conectei o pino central do potenciômetro ao pino A0 do Arduino, e os outros pinos a 0V e 5V no Arduino. Montei o driver PWM de servos sobre o Arduino e conectei o conversor buck DC-DC (ajustado para converter entrada de 9V em saída de 5V). Conectei o servo 9g ao primeiro slot do shield do driver de servos e carreguei o sketch no Arduino.

O resultado final é mostrado nas fotos abaixo. Girando o botão no canto superior esquerdo do dispositivo, controlo a posição do servo e, usando o Monitor Serial na Arduino IDE, leio o sinal PWM enviado ao servo para qualquer ângulo.

O Que o Dispositivo Me Diz?

Para meu servo, girei-o até seu limite horário extremo e posicionei o braço de forma que ficasse pouco além da marca de 180° no transferidor do dispositivo.

Liguei a alimentação e girei o botão do potenciômetro até o braço do servo alinhar com a marca de 0° no transferidor, anotando o valor PWM exibido no Monitor Serial da Arduino IDE. Repeti o processo a cada 10° até 180°, registrando os resultados na tabela abaixo.

Criei um gráfico dos resultados (abaixo), e como esperado, há uma relação fortemente linear entre PWM e ângulo do servo.

Agora tenho pares de valores PWM e ângulo característicos deste servo específico — outros servos podem ter características semelhantes, mas não idênticas.

Tenho duas opções para desempenho mais preciso:

1. Tabela de busca: Registrar esses pares de valores em um array no sketch do Arduino. Quando quiser mover o braço a 90° (por exemplo), consulto qual valor PWM corresponde a esse ângulo e envio esse valor. Desvantagem: só posso girar para ângulos múltiplos de 10.
2. Regressão linear: Usar regressão linear no conjunto de dados para obter a fórmula que relaciona ângulo e PWM (para este servo, PWM = 2.35 * Ângulo + 159.4). Assim, posso passar o ângulo desejado como parâmetro e calcular programaticamente o PWM necessário para posicionar este servo específico.

De qualquer forma, consigo controlar este servo com mais precisão e confiança. Calibrar cada servo individualmente dá mais trabalho, mas para meu projeto vale a pena pela precisão adicional.

Claro, ao remover o servo do dispositivo, devo manter o braço fixo, pois as medições referem-se à forma como o braço estava preso durante a calibração.

Melhorias para a Próxima Versão

Após calibrar alguns servos, pensei em melhorias para a próxima versão:

• Mecanismo de liberação rápida para o servo — talvez usar clipe com ímãs de neodímio em vez de parafusos M3.
• Tornar o dispositivo menor — talvez reorientar o Arduino e a fonte de alimentação.
• Adicionar chave liga/desliga entre a bateria de 9V e o conversor buck, para não precisar desconectar a bateria sempre.
• Imprimir o suporte em menos peças.
• Em vez de ler manualmente o transferidor, um sensor poderia detectar quando o servo atinge posições angulares específicas e retroalimentar o Arduino — eliminaria erro de paralaxe.
• Display LCD para mostrar resultados, dispensando a conexão com o computador.

Conclusão

Meus servos hobby são baratos e não feitos para precisão — e para muitas aplicações estão perfeitamente bem. No entanto, gostaria de obter mais precisão e desempenho repetível dos meus, e o equipamento deste post me ajuda a alcançar isso.

Código

Sketch para Dispositivo Calibrador de Servo

#include <Adafruit_PWMServoDriver.h>
#define analogIn A0
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
int inputValue = 0;
int tmpPwmValue = 0;

void setup() {
  Serial.begin(9600);
  pwm.begin();
  pwm.setPWMFreq(60);
}

void loop() {
  inputValue = analogRead(analogIn); // 0 a 1024
  // Valores PWM min/max do servo geralmente entre 100 e 612
  int pwmValue = (int)(100 + (inputValue / 2));
  pwm.setPWM(0, 0, pwmValue);

  // Evita exibir dados duplicados desnecessariamente
  if (pwmValue != tmpPwmValue) {
    Serial.print("Potentiometer Input = ");
    Serial.print(inputValue);
    Serial.print(", PWM = ");
    Serial.println(pwmValue);
  }
  tmpPwmValue = pwmValue;
  delay(15);
}

Peças Personalizadas e Gabinetes

Repositório das peças do Calibrador de Servo:
https://github.com/jeremylindsayni/ServoCalibrator