SUPORTE TÉCNICO
Publicado 2026-04-01
Este guia fornece uma explicação prática e completa do código de modulação por largura de pulso (PWM) para controlarservomotores. Se você estiver procurando o código exato, as instruções de fiação e os princípios de tempo para fazer umservomova para um ângulo preciso, você veio ao lugar certo. Este artigo se concentra no padrão universalmente aceito paraservocontrole - o sinal PWM de 50 Hz com largura de pulso entre 1 ms e 2 ms - e fornece exemplos de código funcional que são independentes de hardware, garantindo que você possa aplicá-los a qualquer plataforma de microcontrolador.
Basicamente, controlar um servo analógico padrão não envolve enviar pacotes de dados complexos, mas gerar um pulso elétrico específico e repetido. O circuito interno do servo interpreta a largura deste pulso para determinar a posição alvo do seu eixo de saída.
O sinal de controle padrão é definido por dois parâmetros principais:
1. Período (Frequência):O sinal se repete a cada 20 milissegundos (ms). Isso equivale a uma frequência de 50 Hz (1/0,02 s = 50 Hz).
2. Largura de pulso (ciclo de trabalho):A duração em que o sinal é alto (lógica 1) nesse período de 20 ms. Este valor é mapeado diretamente para o ângulo do servo.
O mapeamento entre a largura e o ângulo do pulso é a informação crítica. Para a grande maioria dos servos padrão, a relação é linear e segue esta especificação padrão da indústria:
Pulso de 1,0 ms:Gira o servo para 0 graus (totalmente no sentido anti-horário).
Pulso de 1,5 ms:Gira o servo em 90 graus (posição central).
Pulso de 2,0 ms:Gira o servo em 180 graus (totalmente no sentido horário).
Embora muitos servos sigam esse padrão, é essencial verificar a faixa exata para seu modelo específico, pois alguns servos de alto torque ou especializados podem ter pontos finais ligeiramente diferentes (por exemplo, 0,9 ms a 2,1 ms). Os exemplos de código abaixo são estruturados para permitir fácil ajuste dessas constantes de largura de pulso mínima e máxima.
A lógica do código é consistente em todas as plataformas: inicialize um temporizador/contador para gerar um sinal de 50 Hz e então module o "on-time" desse sinal para definir o ângulo do servo. O pseudocódigo a seguir demonstra a lógica central, que você pode adaptar a qualquer ambiente de programação.
// --- Constantes de configuração --- #define PWM_FREQUENCY_HZ 50 #define PERIOD_MS (1000 / PWM_FREQUENCY_HZ) // Calcula para 20 ms #define PULSE_MIN_MS 1.0 // Largura de pulso para 0 graus #define PULSE_MAX_MS 2.0 // Largura de pulso para 180 graus #define ANGLE_MIN 0 #define ANGLE_MAX 180 // --- Função para mapear um ângulo para uma largura de pulso --- float angleToPulseWidth(int angle_degrees) { // Restringir o ângulo a um intervalo válido if (angle_degrees ANGLE_MAX) angle_degrees = ANGLE_MAX; // Mapeamento linear da faixa de ângulo para a faixa de largura de pulso float pulse_width = PULSE_MIN_MS + ( (float)(angle_degrees - ANGLE_MIN) / (ANGLE_MAX - ANGLE_MIN) )(PULSE_MAX_MS - PULSE_MIN_MS); retornar largura_de_pulso; } // --- Conceito do Loop de Controle Principal --- // Em uma implementação real, o seguinte seria tratado por um temporizador de hardware. // 1. Defina o pino de saída para ALTO. // 2. Aguarde (atraso) pela largura de pulso calculada (por exemplo, 1,5 ms). // 3. Defina o pino de saída como LOW. // 4. Aguarde o restante do período de 20 ms (PERIOD_MS - pulse_width).Para tornar isso imediatamente acionável, aqui estão implementações concretas para duas das plataformas de desenvolvimento mais comuns. Os princípios permanecem idênticos, demonstrando a portabilidade do padrão de 50 Hz, 1-2 ms.
Este é o ponto de entrada mais comum para hobbyistas. O ArduínoServobiblioteca abstrai a complexidade do temporizador de hardware, fornecendo uma interface limpa. Este exemplo é baseado na prática padrão de conectar o fio de sinal do servo a um pino digital compatível com PWM.
#incluir// Cria um objeto servo Servo myServo; // Define o pino conectado ao fio de sinal do servo const int servoPin = 9; void setup() { // Anexe o objeto servo ao pino // A biblioteca configura automaticamente o sinal de 50 Hz myServo.attach(servoPin); // --- Cenário comum: centralize o servo na inicialização --- // Em muitas aplicações robóticas, é crucial partir de uma posição conhecida e // segura para evitar tensão mecânica. Centralizar em 90 graus // é uma prática recomendada universal. meuServo.write(90); // Move para a posição central delay(1000); // Permita que o tempo alcance a posição } void loop() { // Varre de 0 a 180 graus for (int angle = 0; angle = 0; angle--) { myServo.write(angle); atraso(15); } } Nota: Oescrever()A função converte automaticamente o ângulo (0-180) para a largura de pulso correta (1-2 ms).
Em um Raspberry Pi, você normalmente gera o sinal PWM em software, o que requer tempo preciso. ORPi.GPIOA biblioteca fornece uma interface PWM apoiada por hardware em pinos específicos para sinais mais precisos. Este exemplo reflete a abordagem padrão para controle de servo único em um computador de placa única baseado em Linux.
importe RPi.GPIO como tempo de importação GPIO # Definições de pinos servo_pin = 18 # Use um pino que suporte PWM de hardware, como GPIO 18 GPIO.setmode (GPIO.BCM) GPIO.setup (servo_pin, GPIO.OUT) # Configuração PWM: frequência de 50 Hz pwm = GPIO.PWM (servo_pin, 50) pwm.start (0) # Comece com 0% de ciclo de trabalho def set_angle(angle): """Converter um ângulo (0-180) em um ciclo de trabalho para um sinal de 50 Hz.""" # Restringir ângulo ângulo = max(0, min(180, ângulo)) # Mapear ângulo (0-180) para largura de pulso (1-2 ms) # Para um período de 20 ms (50 Hz), ciclo de trabalho = (pulse_width_ms / 20) 100 pulse_width_ms = 1,0 + (ângulo / 180,0)1.0 # Mapeia para 1,0-2,0 ms duty_cycle = (pulse_width_ms / 20,0)100.0 pwm.ChangeDutyCycle(duty_cycle) # --- Cenário comum: Calibrando um novo servo --- # Ao integrar um servo pela primeira vez, é fundamental verificar seus verdadeiros # limites mecânicos. O código abaixo demonstra uma rotina de calibração segura. try: # Testa a posição central print("Movendo para 90 graus...") set_angle(90) time.sleep(2) # Testa a posição de 0 graus (pulso de 1,0 ms) print("Movendo para 0 graus...") set_angle(0) time.sleep(2) # Testa a posição de 180 graus (pulso de 2,0 ms) print("Movendo para 180 graus...") set_angle(180) time.sleep(2) # Retorna ao centro print("Retornando ao centro.") set_angle(90) time.sleep(1) exceto KeyboardInterrupt: print("Parado pelo usuário") finalmente: pwm.stop() GPIO.cleanup()Nota: Este método utiliza cálculo do ciclo de trabalho. Para um sinal de 50 Hz, um pulso de 1 ms corresponde a um ciclo de trabalho de (1/20)100 = 5%. Um pulso de 2 ms é (2/20)100 = 10%.
Mesmo com o código correto, vários problemas relacionados ao hardware podem impedir o funcionamento de um servo. Compreender esses cenários comuns ajudará você a diagnosticar e resolver problemas rapidamente.
1. Fonte de alimentação insuficiente:Este é o problema mais frequente. Um servo típico pode consumir 200-500 mA quando em movimento e correntes de bloqueio ainda mais altas. As portas USB do microcontrolador (normalmente 500 mA) são frequentemente insuficientes, especialmente para múltiplos servos.
Solução:Use uma fonte de alimentação externa dedicada (por exemplo, 5 V de uma bateria ou de uma fonte de bancada regulada). Certifique-se de que o aterramento (GND) do microcontrolador esteja conectado ao aterramento da fonte de alimentação externa.
2. Valores de tempo incorretos:Se o servo tremer, vibrar ou não se mover em toda a faixa, os limites de largura de pulso provavelmente não correspondem à especificação do servo.
Solução:Consulte a folha de dados do servo para obter a faixa exata de largura de pulso. Uma variação comum é de 0,9 ms a 2,1 ms. Ajuste oPULSE_MIN_MSePULSE_MAX_MSconstantes em seu código de acordo.
3. Desvio de frequência no software PWM:Em plataformas como o Raspberry Pi sem pinos PWM de hardware dedicados, o PWM gerado por software pode sofrer inconsistências de tempo devido à multitarefa do sistema operacional.
Solução:Para aplicações críticas ou de alta velocidade, use uma placa servocontroladora dedicada (como uma PCA9685) que transfere a temporização para um chip de hardware dedicado, garantindo geração estável de 50 Hz.
Para acionar com sucesso um servo com código PWM, lembre-se destes três princípios básicos:
1. Padronize o sinal:Procure sempre gerar um sinal preciso de 50 Hz. A largura do pulso é a única variável que controla a posição.
2. Mapear ângulos para pulsos:Use o mapeamento linear de 1,0 ms (0°) a 2,0 ms (180°) como linha de base. Esta fórmula funciona para mais de 90% dos servos padrão.
3. Priorize o poder:Verifique se sua fonte de alimentação pode fornecer a corrente necessária. Um servo que se contorce de forma irregular é quase sempre um problema de energia, não um problema de código.
Etapa de ação:Comece com o código de varredura simples na plataforma escolhida usando um único servo. Assim que a varredura funcionar, substitua os ângulos codificados por entradas de sensores, valores de joystick ou posições calculadas para integrar o servo em seu projeto maior. Ao aderir ao padrão de 50 Hz e verificar sua fonte de alimentação, você cria uma base robusta para qualquer aplicação de controle de movimento.
Hora de atualização: 01/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.
