Controle de servo motor com STM32F4 ARM MCU: 4 etapas

2025 Autor: John Day | [email protected]. Última modificação: 2025-01-23 15:03

Olá novamente, amigos:) Então, neste projeto iremos controlar um servo motor com STM32F4 ARM MCU. No meu caso, usarei a placa de descoberta, mas se você entender a essência do problema, poderá aplicá-la a cada MCU. Então. vamos começar:)

Etapa 1: Requisitos de Hardware e Software

Em termos de hardware, precisaremos de:

• Um MCU que é, no meu caso, placa STM32f4 Discovery
• Um servo motor comum, como SG90 ou qualquer outro

Em termos de software, precisaremos de:

• STM32CubeMX
• Keil uVision

Se você tiver tudo isso, pule para a próxima etapa:)

Etapa 2: Configuração STM32CubeMX

Como você sabe, para controlar um servo motor, precisamos do sinal PWM. Os requisitos em termos de sinal PWM são os seguintes:

• O período PWM deve ser de 20 ms
• O tempo de ativação deve estar entre 0,5 ms a 2,5 ms. Quando o tempo é de 0,5 ms, o servo girará 0 graus, 1,5 ms para 90 graus e 2,5 ms para 180 graus.

Então, precisamos configurar o PWM e para isso usaremos o Timer1.

• Primeiro, selecione TIM1 na seção Timers. Esta etapa

• Então, na seção Modo

  1. Escolha o relógio interno nesta etapa
  2. Geração PWM CH1 Esta etapa

• Então, na seção Configuração

  1. Defina Prescaler para 160 Esta etapa
  2. Defina o período do contador para 2.000 nesta etapa
  3. Defina o pulso para 50 nesta etapa
• Além disso, em Configuração do relógio, defina os relógios do temporizador APB1 para 16 MHz. Esta etapa

Agora, vamos falar um pouco sobre esta etapa:

A frequência do relógio do nosso temporizador APB1 é de 16 MHz. Portanto, isso significa que são necessários 16.000.000 tiques para obter 1 segundo. No entanto, definimos nosso prescaler para 160. Isso significa que dividimos nossa frequência por esse número e diminuímos o número de tiques para 100.000. Portanto, por 1 segundo precisamos de 100.000 tiques. No entanto, precisamos de 20 ms de período de PWM, como afirmamos antes. Portanto, com base em matemática simples, precisamos de 2.000 ticks para 20 ms. Portanto, definindo o Período do Contador para 2000, determinamos o período do sinal PWM que é 20 ms. Agora precisamos determinar o número do tick para obter tempos de ativação de 0,5 ms a 2,5 ms. Podemos obter essa equação de matemática simples e é:

On_Time = (Tick_Number / 100). Lembre-se de que este é o on_time que altera o ângulo do servo motor. Então, abaixo da imagem eu sumarizo esta etapa. Se você tiver alguma dúvida escreva nos comentários e eu responderei o mais rápido possível.

Imagem de cálculos

Depois de fazer tudo isso, gere código:)

Etapa 3: Codificação Keil UVision

Então, vamos primeiro determinar o que queremos fazer? Queremos escrever uma função que aceite grau e escrevê-la no servo. Então, como faremos isso? Como dissemos antes, para mudar o ângulo, precisamos mudar o tempo de ativação. Nossos ângulos mudam entre [0, 180] e nosso número de ticks que determina as mudanças de tempo entre [50, 250]. Portanto, precisamos de uma função de mapeamento que mapeie o ângulo dado para a faixa de número de tiques. Por exemplo, para 0 grau 50 marcações, para 180 graus 250 marcações e assim por diante … Então, vamos escrever nossa função de mapeamento:

int map (int st1, int fn1, int st2, int fn2, int value) {return (1.0 * (value-st1)) / ((fn1-st1) * 1.0) * (fn2-st2) + st2; }

Esta é a nossa função de mapeamento. Você está interessado em como ele é derivado? Então leia isso. Então, pegamos nossos intervalos e o valor que queremos mapear.

Agora, vamos escrever uma função que aceite ângulo e o mapeie para o intervalo de tiques:

vazio servo_write (ângulo interno) {htim1. Instance-> CCR1 = map (0, 180, 50, 250, ângulo); }

Como você pode ver, este código aceita ângulo e o mapeia para o intervalo de número de tiques. Em seguida, o número de tiques é dado ao registrador CCR1 que controla o tempo de ativação e, portanto, o ângulo.

No entanto, para que tudo isso funcione, primeiro iniciamos o pwm, o que pode ser feito por apenas uma linha de código:

HAL_TIM_PWM_Start (& htim1, TIM_CHANNEL_1);

Então, temos uma função que aceita ângulo e escreve no servo. Vamos testar e escrever nossa função de varredura, que é muito fácil:

void servo_sweep (void) {para (int i = 0; i <= 180; i ++) {servo_write (i); HAL_Delay (10); } para (int i = 180; i> = 0; i--) {servo_write (i); HAL_Delay (10); }}

Então, basta contar até 180 e então descer até 0 e escrever esses valores no servo:) Então, vamos ver o resultado!

Etapa 4: o resultado:)

Então, esse é o fim. Se você tiver alguma dúvida, pergunte. Terei o maior prazer em respondê-las. Muito obrigado pela leitura e espero vê-lo no próximo projeto:)