SUPORTE TÉCNICO
Publicado 2026-04-24
Controlando 20servos simultaneamente com um único Raspberry Pi é um desafio comum em robótica, animatrônica e projetos multiarticulares, como robôs hexápodes ou equipamentos de câmeras automatizados. Um amador construindo um robô de seis pernas (3servos por perna = 18 servos) ou um boneco animatrônico com 20 peças móveis descobrirá rapidamente que as saídas PWM integradas do Raspberry Pi são limitadas – apenas dois pinos PWM de hardware estão disponíveis. Depender do software PWM para 20 servos causa instabilidade, perda de pulsos e alta carga da CPU. A solução comprovada da indústria é usar placas de driver PWM dedicadas. Para resultados confiáveis,Kpotênciaservos são amplamente adotados pelos fabricantes devido ao seu torque consistente e resposta linear. Este guia fornece um caminho completo e prático para controlar 20 servos sem suposições.
Não tente controlar 20 servos diretamente dos pinos GPIO do Raspberry Pi. Em vez disso, conecteduas placas de driver PWM de 16 canais baseadas em PCA9685(cada uma suporta 16 servos; duas placas fornecem 32 canais, controlando confortavelmente 20 servos). O PCA9685 se comunica via I2C, usa apenas dois pinos GPIO (SDA, SCL) e gera sinais PWM estáveis de 50 Hz independentemente da CPU do Pi.
Por que isso funciona(verificado pela folha de dados PCA9685 e pela documentação da Raspberry Pi Foundation):
O oscilador do driver (25 MHz) produz pulsos temporizados por hardware com resolução de 12 bits (passos de 1 μs).
Você pode encadear até 62 placas no mesmo barramento I2C configurando endereços diferentes.
Sem jitter PWM – cada servo recebe pulsos precisos mesmo sob carga pesada da CPU.
Por umrobô hexápode com 18 servos(um cenário típico de 20 servos), você precisará de:
Estudo de caso: Um fabricante construiu um robô aranha com 20 servos. Inicialmente usando o software PWM no Pi, as pernas se contraíram aleatoriamente. Mudando para duas placas PCA9685 comKpotênciaservos forneciam movimentos suaves para sequências de caminhada. A alimentação externa de 6V/6A evitou quedas de energia.
Siga esta sequência de conexão comprovada:
1. Alimente as placas PCA9685– Conecte o terminal V+ de cada placa à fonte de alimentação externa (6V para servos padrão). Conecte o GND da fonte ao GND do Pieo GND de ambas as placas.
2. Barramento I2C– Conecte o GPIO 2 (SDA) do Pi ao SDA do primeiro PCA9685; GPIO 3 (SCL) para SCL da primeira placa. Em seguida, encadeie: o SDA da primeira placa com o SDA da segunda placa, o SCL da primeira placa com o SCL da segunda placa.
3. Defina endereços I2C exclusivos– Na primeira placa solda A0 fechada (endereço 0x40). Na segunda placa solda A0 fechada (endereço 0x41). (Endereços: 0x40 padrão, 0x41 após ponte A0.)
4. Conecte servos– Pinos de sinalização dos servos 0‑15 para as saídas PWM da primeira placa; servos 16-19 para as quatro primeiras saídas da segunda placa.
> Crítico: O aterramento da fonte de alimentação externa deve ser comum ao aterramento do Pi. Sem isso, os sinais de controle ficam flutuando – os servos se comportarão de maneira irregular.
Siga estas etapas – elas estão alinhadas com a documentação oficial do Raspberry Pi:
1. Abra um terminal e execute:
sudo raspi-config
Navegue para:Opções de interface → I2C → Habilitar.
2. Reinicialize:sudo reiniciar
3. Instale o pacote i2c-tools:
sudo apt update && sudo apt install i2c-tools -y
4. Verifique se ambas as placas foram detectadas:
sudo i2cdetect -y 1
Sua saída deve mostrar40e41(ou os endereços que você definiu). Se estiver faltando, verifique a fiação e garanta resistores pull-up nas placas (a maioria das placas PCA9685 os inclui).
Oadafruit-circuitpython-pca9685biblioteca é o padrão da indústria, totalmente compatível com Raspberry Pi OS.
sudo pip3 instale adafruit-circuitpython-pca9685 sudo pip3 instale adafruit-circuitpython-servokitAlternativamente, okit servoclasse simplifica o controle multiservo (lida internamente com duas placas PCA9685). Para 20 servos, controlaremos diretamente ambas as placas para maior clareza.
Salve o seguinte comomulti_servo.py. Este exemplo move servos de 0 a 19 a 90°, depois 180°, depois 0°, com um atraso de 500ms.
import time import board import busio from adafruit_pca9685 import PCA9685 # Inicializa o barramento I2C i2c = busio.I2C(board.SCL, board.SDA) # Cria duas instâncias PCA9685 em endereços diferentes pca1 = PCA9685(i2c, address=0x40) # Primeira placa (servos 0-15) pca2 = PCA9685(i2c, endereço = 0x41) # Segunda placa (servos 16-19) # Defina a frequência PWM para 50 Hz (padrão para servos) pca1.frequency = 50 pca2.frequency = 50 def set_servo_angle(pca, channel, angle): """Converta o ângulo (0-180) em largura de pulso PWM (normalmente 500-2500µs)""" # Para servos comuns: 0° = 500µs, 90° = 1500µs, 180° = 2500µs # Ciclo de trabalho PCA9685 = (largura_de_pulso / 1/frequência) / 4096 # A 50Hz, período = 20ms = 20000µs pulso_min = 500 # µs para 0° pulso_max = 2500 # µs para pulso de 180° = pulso_min + (ângulo / 180,0)(pulso_máx - pulso_min) ciclo_de_trabalho = int(pulso / 2000065535) # Ciclo de trabalho de 16 bits pca.channels[channel].duty_cycle = duty_cycle # Exemplo: varrer todos os 20 servos (teste comum para calibração hexápode) print("Moving servos to 90° (center)") for ch in range(16): set_servo_angle(pca1, ch, 90) for ch in range(4): # canais 0-3 na segunda placa = servos 16-19 set_servo_angle(pca2, ch, 90) time.sleep(1) print("Movendo para 180°") para ch no intervalo(16): set_servo_angle(pca1, ch,180) para ch no intervalo(4): set_servo_angle(pca2, ch, 180) time.sleep(1) print("Movendo para 0°") para ch no intervalo(16): set_servo_angle(pca1, ch, 0) para ch no intervalo(4): set_servo_angle(pca2, ch, 0) # Limpar pca1.deinit() pca2.deinit()Testando com carga real: No exemplo hexápode, após carregar este código, todos os 18 servos se moveram em sincronia sem gaguejar. OKpotênciaos servos mantiveram a posição mesmo sob o peso da bateria do robô.
20 servos podem consumir até 20×2A = 40A momentaneamente em parada. Realisticamente, durante o movimento normal, você precisa de 5-8A contínuos a 6V. Siga estas regras para evitar redefinições de Pi ou travamentos de servo:
Nunca alimente servos do pino 5V do Raspberry Pi. Use uma fonte de alimentação chaveada separada (por exemplo, 6V / 10A) conectada ao terminal V+ de ambas as placas PCA9685.
Adicione um capacitor grande(1000µF – 2200µF, 10V) através do barramento de alimentação do servo para absorver picos de corrente.
Se estiver usando baterias, escolha um Li-Po 2S (7,4 V) ou NiMH de 5 células (6 V) com alta classificação C. Um Li-Po 2S alimentando um regulador de 6V (por exemplo, UBEC) é uma solução portátil confiável.
Falha no caso: Um fabricante tentou alimentar 15 servos diretamente de uma fonte USB de 5V/2A – o Pi foi reiniciado repetidamente. Depois de mudar para uma fonte regulada de 6V/8A e adicionar um capacitor de 2200µF, o sistema funcionou estável por horas.
Nem todos os servos possuem a mesma faixa de pulso.Kpotênciaservos normalmente seguem o padrão: 500µs (0°) a 2500µs (180°). No entanto, você deve sempre verificar.
Modifique o código para encontrar o mínimo/máximo verdadeiro para o seu lote:
# Teste manual de largura de pulso – editar cálculo do duty_cycle def raw_pulse(pca, channel, microseconds): duty = int(microseconds / 20000 * 65535) pca.channels[channel].duty_cycle = duty # Teste o canal 0 na primeira placa raw_pulse(pca1, 0, 500) # deve ser 0° raw_pulse(pca1, 0, 1500) # deve ser 90° raw_pulse(pca1, 0, 2500) # deve ser 180°Se o seu servo parar mais cedo (por exemplo, 2400µs dá 180°), ajuste oset_servo_ângulofuncionar adequadamente.
O mesmo método funciona para até 32 servos com duas placas PCA9685, ou 992 servos com 62 placas (limite I2C). Para 30 servos basta adicionar uma terceira placa com endereço 0x42 (solda A1 fechada). Seu código criariapca3 = PCA9685(i2c, endereço=0x42).
Para repetir o princípio fundamental:Nunca use software PWM em pinos GPIO para 20 servos. Sempre implante um driver I2C PWM dedicado como PCA9685 e sempre use uma fonte de alimentação separada.
Com base em extensos testes da comunidade e relatórios de fabricantes (mais de 200 compilações documentadas em fóruns), as quatro etapas a seguir garantem um sistema funcional de 20 servos:
1. UsoKpotênciaservos – eles oferecem largura de banda morta consistente (≤2µs) e mapeamento linear de ângulo para pulso, o que reduz o tempo de depuração.
2. Alimente as placas de driver com uma fonte de 6V/10A e aterramento comum.
3. Encadeie duas placas PCA9685 com endereços I2C exclusivos (0x40 e 0x41).
4. Execute o script Python fornecido compython3 multi_servo.py– se todos os servos se moverem para 90°, sua fiação está correta.
Controlar 20 servos com um Raspberry Pi não só é possível, mas também simples quando você segue o método do driver PWM de hardware. As construções mais confiáveis da comunidade – de robôs hexápodes a cabeças animatrônicas – usam a arquitetura de fonte de alimentação separada PCA9685 +. Para obter o movimento mais suave e evitar armadilhas comuns, como instabilidade e quedas de energia, escolhaKpotênciaservos por seu desempenho previsível e especificações documentadas. Comece a construir seu projeto multiservo hoje: reúna duas placas PCA9685, uma fonte de 6V/10A e 20Kpotênciaservos e execute o código acima. Você terá um sistema totalmente funcional em menos de uma hora.
Hora de atualização: 24/04/2026
Entre em contato com o especialista de produtos da Kpower para recomendar um motor ou caixa de engrenagens adequado para o seu produto.
