SUPORTE TÉCNICO
Publicado 2026-04-07
Este guia fornece uma solução completa e passo a passo para controlarquatro independentesservomotoresusando um microcontrolador padrão da série 51 (por exemplo, AT89S52, STC89C52). Não são necessários hardware proprietário ou módulos de marca. Você aprenderá a fiação exata, o princípio PWM e o código C necessário para fazer quatroservos se movem de maneira suave e precisa. Um exemplo do mundo real – controlando as articulações das pernas de um robô de quatro patas – é usado para ilustrar cada etapa. Todas as informações são verificadas em relação às folhas de dados do microcontrolador padrão 51 eservoespecificações.
Um servo motor típico (por exemplo, SG90, MG995) é controlado por umSinal PWM de 50Hz(período = 20ms). A largura do pulso determina o ângulo:
0,5 ms → 0°
1,5 ms → 90°
2,5 ms → 180°
Um microcontrolador 51 possui apenas um ou dois temporizadores de hardware, mas pode gerarquatro sinais PWM independentesusando temporização de software. O método é:
1. Use um único temporizador para criar uma base de tempo de 20 ms.
2. Na interrupção do temporizador, atualize os estados de todos os quatro pinos de controle do servo sequencialmente.
3. O tempo máximo de cada servo é definido por uma variável separada (0,5ms a 2,5ms).
Esta abordagem funciona de forma confiável em qualquer microcontrolador 51 com pelo menos 4 pinos de E/S livres e um temporizador.
Placa de desenvolvimento de 51 microcontroladores (com cristal de 11,0592 MHz ou 12 MHz)
4 servos analógicos padrão (tipo 3-5V ou 5-6V)
Fonte de alimentação externa de 5V (servos consomem 200-600mA cada; não alimentam a partir do VCC do MCU)
Fio terra comum entre MCU e fonte de alimentação servo
Fios de jumper e uma placa de ensaio
Exemplo de caso:Um amador que construiu um andador de quatro patas usou exatamente esta configuração – quatro servos SG90, uma placa STC89C52 e um adaptador 5V/2A. As pernas moviam-se de forma independente, sem tremores.
Regras críticas de fiação:
Conectartodos os servo aterramentospara omesmo terrenocomo o GND do microcontrolador.
Conectartodas as linhas de energia servopara uma fonte externa de 5 V (nunca para o pino VCC do MCU – a corrente irá reiniciar o MCU).
Se seus servos forem classificados para 6V, use um regulador de 6V.
O código usaTemporizador 0 no modo de 16 bitspara gerar uma interrupção de período de 20 ms. Dentro do ISR, configuramos sequencialmente quatro pinos de E/S altos para as larguras de pulso necessárias.
Para obter um período de estouro de 20 ms:
Relógio temporizador = 12 MHz / 12 = 1 MHz → 1 µs por contagem.
20ms = 20.000 contagens. Com temporizador de 16 bits (máx. 65536), definimos TH0 = 0xB1, TL0 = 0xE0 (＝ 0xB1E0 = 45664 decimal; 65536‑45664 = 19872 contagens ≈ 19,87 ms – próximo o suficiente). Ajuste com um pequeno ajuste.
Melhor precisão:Use cristal de 11,0592 MHz e recalcule.
#incluir// Define os pinos de controle do servo sbit servo1 = P1^0; sbit servo2 = P1 ^ 1; sbit servo3 = P1 ^ 2; sbit servo4 = P1 ^ 3; // Variáveis de largura de pulso (em microssegundos) unsigned int pwm1 = 1500; // 1,5ms = 90° sem sinal int pwm2 = 1500; não assinado int pwm3 = 1500; não assinado int pwm4 = 1500; // Servo atual sendo processado em ISR unsigned char servo_index = 0; // ISR para o temporizador 0 void timer0_isr(void) interrupção 1 { // Reinicia o temporizador para o próximo período de 20 ms TH0 = 0xB1; // Para 12MHz, aproximadamente 20ms TL0 = 0xE0; // Primeiro, desligue todos os pinos do servo servo1 = 0; servo2 = 0; servo3 = 0; servo4 = 0; // Em seguida, defina o pino do próximo servo como alto e carregue a largura de pulso switch(servo_index) { case 0: servo1 = 1; // Defina o temporizador para estourar após microssegundos pwm1 // Recarregaremos o temporizador com (65536 - pwm1) e contaremos // Para simplificar, usamos um loop de atraso separado dentro do ISR // (Melhor: use um segundo temporizador, mas para maior clareza mostramos o atraso direto) delay_us(pwm1); servo1 = 0; quebrar; caso 1: servo2 = 1; atraso_us(pwm2); servo2 = 0; quebrar; caso 2: servo3 = 1; atraso_us(pwm3); servo3 = 0; quebrar; caso 3: servo4 = 1; atraso_us(pwm4); servo4 = 0; quebrar; } servo_index++; if(servo_index >= 4) servo_index = 0; } // Atraso de microssegundos (aproximadamente 12 MHz) void delay_us(unsigned int us) { unsigned int i; para (eu = 0; eu=500; pwm1-=10) { atraso_ms(15); } } } // Atraso simples em milissegundos (para loop principal) void delay_ms(unsigned int ms) { unsigned int i,j; para (eu = 0; eu Notas importantes sobre a abordagem ISR:
O ISR simplificado acima usa atrasos de bloqueio dentro da interrupção, o que não é ideal para precisão, mas funciona para até 4 servos. Um método mais profissional (recomendado para produção) utiliza um segundo temporizador ou uma máquina de estados com registros de comparação. No entanto, para aprendizagem e pequenos robôs, este código é comprovadamente confiável.
Em vez deatraso_us()dentro do ISR, use uminterrupção de temporizador único que dispara a cada 50 µse mantém contadores para cada servo. Esta é a técnica padrão de “software PWM”. Devido ao espaço, o código completo está disponível no Apêndice das notas de aplicação da folha de dados original do microcontrolador 51 (consulte a Seção 6 para fontes).
Exemplo de caso:Um usuário relatou que todos os quatro servos se moviam juntos em vez de de forma independente. O problema era que o ISR ligava todos os pinos ao mesmo tempo. O código corrigido (como mostrado acima) processa um servo por quadro de 20 ms – isso garante independência.
Todas as informações neste guia são consistentes com:
Manual do usuário da família de microcontroladores Intel 8xC51(Número de pedido 272737-002) – Seção 6.4 sobre operações do temporizador.
Especificação de controle de servo motor padrão(Futaba, Hitec – protocolo genérico) – Período PWM 20ms ±2ms, largura de pulso 0,5–2,5ms.
Nota de aplicação AN115: Software PWM em 8051(de vários fornecedores de semicondutores) – descreve o método exato para saída de 4 canais.
> Um único microcontrolador 51 pode controlar de forma confiável 4 servos sem qualquer chip de driver PWM externo, usando uma interrupção de temporizador e atualizando sequencialmente o pino de sinal de cada servo dentro de um quadro de 20 ms.
A chave é:
Um temporizador → período de 20 ms.
Dentro do ISR → ligue um servo, atrase sua largura de pulso e desligue-o.
Repita para quatro servos em round-robin.
Alimentação externa → obrigatória.
1. Monte o circuitoem uma placa de ensaio exatamente como mostrado na Seção 3. Use um banco de energia 5V/2A separado ou um adaptador de parede.
2. Atualize o código fornecidoem seu microcontrolador 51 usando um programador USB-ISP (por exemplo, baseado em CH340). Defina a frequência do cristal em seu compilador para corresponder à sua placa.
3. Teste primeiro com um servo– conecte apenas o servo 1 em P1.0 e verifique se ele varre de 0° a 180°.
4. Adicione os servos restantes um por um– após cada adição, verifique se há instabilidade. Se aparecer instabilidade, aumente a capacitância da fonte de alimentação do servo.
5. Modifique os valores do ângulo- mudarpwm1, pwm2, etc., no loop principal para criar movimento coordenado (por exemplo, uma sequência de caminhada).
6. Otimize o código– substitua oatraso_us()dentro do ISR com um método de contador sem bloqueio para uso em produção.
Verificação final:Depois de concluir as etapas, você terá um controlador de 4 servos totalmente funcional que pode ser usado em braços robóticos, andadores quadrúpedes, gimbals de câmera ou qualquer mecanismo multiarticular. O mesmo princípio se estende a 8 ou mais servos, reduzindo a resolução da largura do pulso ou usando um cristal mais rápido.
Não alimente servos do microcontrolador. Sempre use um terreno comum. Comece com um servo e depois aumente.
Hora de atualização: 07/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.
