Driver de servomotores PCA9685

O que é

O PCA9685 é um multiplicador de servomotores. Um microcontrolador tem apenas alguns canais PWM de hardware; portanto, acionar os seis servomotores de um braço robótico—sem falar nos dezoito de um hexápode—esgota rapidamente seus pinos e temporizadores. Esta pequena placa assume essa tarefa: gera 16 sinais PWM independentes em hardware, e você comanda todos eles por dois fios I²C. É a placa por trás da maioria dos robôs com vários servomotores.

Como funciona

Você se comunica com o PCA9685 por I²C—os mesmos dois pinos (SCL/SDA) também podem atender a outros sensores. Define uma frequência PWM para todo o chip (50 Hz para servomotores hobby) e depois define a largura de pulso de cada canal para posicionar seu servomotor. Como o chip mantém todos os 16 sinais em hardware, o microcontrolador apenas envia “canal 3 → 1,5 ms” e segue em frente; nunca precisa gerar a temporação por software. É isso que mantém todos os servomotores suaves, mesmo quando os 16 estão se movendo. A ideia de converter largura de pulso em ângulo é a mesma apresentada na página do servomotor SG90.

Quando usar

Use um PCA9685 sempre que um robô tiver mais servomotores do que o microcontrolador tem pinos PWM, ou quando quiser servomotores muito estáveis:

• Braços robóticos — vários servomotores de juntas se movendo juntos (combine com cinemática inversa).
• Hexápodes / quadrúpedes — servomotores suficientes para uma dúzia ou mais pernas.
• Estruturas pan-tilt e de câmera — liberam os temporizadores do microcontrolador para outras tarefas.

Para um único servomotor de varredura—como o sensor ultrassônico de varredura de um robô que desvia de obstáculos—você não precisa dele; o microcontrolador pode acionar um servomotor diretamente.

Conexões e armadilhas

• Duas trilhas de alimentação. Lógica (VCC) do microcontrolador; alimentação dos servomotores pelo terminal V+. Nunca passe a corrente de 16 servomotores pelo 5 V do Arduino.
• Dimensione V+ para o travamento, não para a corrente ociosa. Dezesseis servomotores juntos podem consumir vários ampères; uma fonte subdimensionada faz a tensão cair e toda a placa oscilar.
• Defina endereços únicos ao encadear placas, por meio dos jumpers de solda.
• Acrescente um capacitor em paralelo com V+ para absorver os picos de corrente quando os servomotores começam a se mover.

Pinagem

Três grupos de conexões: um conector de controle ligado ao microcontrolador, dezesseis conectores de servomotor e um terminal de alimentação que não deve ser confundido com o primeiro.

O fato mais importante nesta placa é que VCC e V+ são trilhas diferentes. VCC alimenta o chip; V+ alimenta os servomotores. Ligá-las faz a corrente de travamento dos servomotores passar pelo regulador do microcontrolador, a maneira mais rápida de causar queda de tensão em um Arduino.

Conexão com um Arduino

OE é mais útil do que parece. Levá-lo ao nível alto desativa todas as dezesseis saídas em hardware, instantaneamente e sem uma transação I²C. Em um braço que pode cair por gravidade, isso é uma parada de emergência real e funciona mesmo que o código tenha travado.

Dimensionando a alimentação dos servomotores

É aqui que a maioria dos projetos PCA9685 dá errado, e a conta não é difícil.

Um servomotor hobby consome aproximadamente:

Quatro SG90 em um braço pequeno, todos se movendo ao mesmo tempo, consomem confortavelmente 1 A e podem chegar perto de 2,6 A se entrarem em travamento juntos—exatamente o que acontece quando o braço encontra a própria estrutura. Um carregador de celular de 1 A não basta. Dimensione a fonte para todos os seus servomotores entrarem em travamento simultaneamente ou, no mínimo, para todos se moverem, mais um em travamento.

O sintoma de uma fonte subdimensionada é distinto e confuso: os servomotores oscilam, a placa pode reiniciar e tudo parece um problema de I²C ou de código. Não é. Coloque um multímetro em V+ enquanto o braço se move e observe a queda de tensão.

Acrescente um capacitor em paralelo com V+. Escolha algo na faixa de 470–1000 µF, próximo ao terminal. Ele não é capaz de fornecer corrente durante um travamento prolongado—um capacitor de 1000 µF fornecendo 1 A perde um volt a cada milissegundo—mas absorve o pico agudo de corrente no instante em que um servomotor começa, que é o que se acopla à trilha lógica.

Como o PWM é realmente gerado

Entender dois números aqui torna mais fácil diagnosticar qualquer problema em um driver de servomotor.

O chip opera com um oscilador interno de 25 MHz e o divide por um fator de pré-escala:

prescale = round(25000000 / (4096 x frequency)) - 1

Para a frequência de 50 Hz usada por servomotores hobby, isso dá round(25000000 / 204800) - 1 = 121.

Cada período é então dividido em 4096 etapas (12 bits). A 50 Hz, o período é 20 ms, portanto uma etapa é 20 ms / 4096 = 4.88 µs. Isso converte as larguras de pulso que realmente importam nas contagens que você escreve:

Duas consequências decorrem diretamente. Primeiro, você obtém cerca de 205 contagens no curso completo de 180° de um servomotor, o que equivale a pouco menos de uma contagem por grau—a resolução de 12 bits do PCA9685 não é o fator limitante em um servomotor hobby; a zona morta do próprio servomotor é. Segundo, o fator de pré-escala só pode ser alterado enquanto o chip está no modo de suspensão, e é por isso que toda biblioteca alterna MODE1 ao redor de uma mudança de frequência.

O oscilador não é exatamente 25 MHz

Placas reais desviam alguns por cento do valor nominal, e a diferença é consistente em cada placa. Se seus servomotores ficam sistematicamente abaixo do ângulo comandado nas duas extremidades, a solução não é inventar larguras de pulso—é medir e corrigir o relógio:

pwm.begin();
pwm.setOscillatorFrequency(26075000);  // measured, not the 25 MHz nominal
pwm.setPWMFreq(50);

Meça comandando 50 Hz, coloque um osciloscópio ou analisador lógico em qualquer saída e leia o período real. Escale os 25 MHz nominais pela razão entre a frequência comandada e a frequência medida. Faça isso uma vez por placa e anote o número em um comentário.

Código mínimo funcional

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);

// Per-servo calibration. These are NOT universal — measure your own.
const int SERVO_MIN = 150;   // counts at one end stop
const int SERVO_MAX = 600;   // counts at the other

int countsFor(int degrees) {
  return map(constrain(degrees, 0, 180), 0, 180, SERVO_MIN, SERVO_MAX);
}

void setup() {
  pwm.begin();
  pwm.setOscillatorFrequency(25000000);  // replace with your measured value
  pwm.setPWMFreq(50);                    // hobby servos want 50 Hz
  delay(10);
}

void loop() {
  for (int a = 0; a <= 180; a += 5) {    // sweep, don't jump
    pwm.setPWM(0, 0, countsFor(a));
    delay(20);
  }
  for (int a = 180; a >= 0; a -= 5) {
    pwm.setPWM(0, 0, countsFor(a));
    delay(20);
  }
}

As constantes SERVO_MIN/SERVO_MAX são a calibração, e elas variam por servomotor—mesmo entre dois do mesmo modelo vindos do mesmo lote. Encontre-as dando passos lentamente para fora a partir de 307 e pare no instante em que o servomotor zumba sem se mover, o que significa que ele está empurrando contra o próprio batente final e consumindo corrente de travamento sem propósito.

Observe também a varredura, em vez de um salto. setPWM muda a posição comandada instantaneamente, e o servomotor tentará alcançá-la na velocidade máxima—o que, em um braço, significa um movimento violento e um pico de corrente. Dar o comando em etapas é uma forma simples de perfil de movimento e vale a pena usar até em código de teste.

Encadeando placas

Cada placa tem seis contatos de solda, A0 a A5, que fornecem 64 endereços a partir de 0x40. Feche uma combinação diferente em cada placa:

62 placas é o máximo documentado—0x70 é reservado para o endereço de chamada geral I²C, e é por isso que não há os 64. Na prática, o limite chega muito antes: 62 placas equivalem a 992 servomotores, e a fonte necessária para isso é um problema de engenharia muito maior do que o barramento.

Ao encadear, observe que cada placa tem seus próprios resistores de pull-up I²C de 10 kΩ, e eles ficam em paralelo. Dez placas resultam em 1 kΩ, uma carga pesada para um barramento de 5 V. Depois de algumas placas, corte os jumpers de pull-up de todas, exceto uma.

Solução de problemas

PCA9685 ou PWM direto do microcontrolador?

O limite honesto é: um ou dois servomotores, acione-os diretamente. Uma cabeça de sensor de varredura em um robô que desvia de obstáculos não precisa desta placa. Três ou mais, ou qualquer servomotor cuja suavidade importe, e o PCA9685 se paga imediatamente—não por causa da contagem de pinos, mas porque o microcontrolador deixa de ser responsável pela temporização. Um servomotor acionado pela biblioteca Servo treme sempre que o laço demora; um acionado por um PCA9685, não.