Servomotor de control amb STM32F4 ARM MCU: 4 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

Hola de nou amics:) Per tant, en aquest projecte controlarem un servomotor amb STM32F4 ARM MCU. En el meu cas, utilitzaré el tauler de descobriment, però si enteneu l’essència del problema, el podreu aplicar per a cada MCU. Tan. comencem:)

Pas 1: Requisits de maquinari i programari

Pel que fa al maquinari, necessitarem:

• Una MCU que és en el meu cas la placa Discovery STM32f4
• Un servomotor comú, com SG90 o qualsevol altre

Pel que fa al programari, necessitarem:

• STM32CubeMX
• Keil uVision

Si teniu tot això, aneu al següent pas:)

Pas 2: Configuració de STM32CubeMX

Com ja sabeu, per controlar un servomotor necessitem senyal PWM. Els requisits en termes de senyal PWM són els següents:

• El període PWM ha de ser de 20 mS
• El temps ha d'estar entre 0,5 mS i 2,5 mS. Quan el temps és de 0,5 mS, el servo girarà 0 graus, 1,5 mS durant 90 graus i 2,5 mS durant 180 graus.

Per tant, hem de configurar PWM i amb aquest propòsit utilitzarem Timer1.

• Primer, seleccioneu TIM1 a la secció Temporitzadors. Aquest pas

• A continuació, des de la secció Mode

  1. Trieu Rellotge intern Aquest pas
  2. PWM Generation CH1 Aquest pas

• A continuació, des de la secció Configuració

  1. Establiu Prescaler a 160 Aquest pas
  2. Estableix el període de comptador a 2000 Aquest pas
  3. Estableix Pulse a 50 Aquest pas
• A més, des de la configuració del rellotge, configureu els rellotges del temporitzador APB1 a 16 MHz. Aquest pas

Ara, parlem una mica d’aquest pas:

La freqüència del rellotge del nostre temporitzador APB1 és de 16 MHz. Per tant, significa que es requereixen 16, 000, 000 paparres per obtenir 1 segon. Tot i això, establim el nostre precaler a 160. És a dir, dividim la nostra freqüència per aquest nombre i reduïm el nombre de paparres fins a 100.000. Per tant, durant 1 segon necessitem 100.000 paparres. Tot i això, necessitem 20 mS de període PWM tal com hem dit abans. Per tant, basant-nos en matemàtiques senzilles, necessitem 2000 paparres per 20 mS. Per tant, establint el Període de comptador a 2000, determinem el període del senyal PWM que és de 20 mS. Ara hem de determinar el número de marca per obtenir temps d’activació de 0,5 mS a 2,5 mS. Podem obtenir aquesta equació a partir de matemàtiques simples i és:

Hora_temps = (Número_marca / 100). Tingueu en compte que és el moment on_ que canvia l'angle del servomotor. Per tant, a sota de la imatge resumeixo aquest pas. Si teniu alguna pregunta, escriviu als comentaris i us respondré el més ràpidament possible.

Imatge de càlculs

Després de fer tots aquests, es genera codi:)

Pas 3: codificació de Keil UVision

Per tant, primer determinem què volem fer? Volem escriure una funció que accepti grau i escriure-la al servo. Llavors, com ho farem? Com hem dit abans, per canviar l’angle hem de canviar el temps puntual. Els nostres angles canvien entre [0, 180] i el nombre de paparres que determina els canvis de temps entre [50, 250]. Per tant, necessitem una funció de mapatge que mapegi l’angle donat al rang de nombre de paparres. Per exemple, per a 0 de 50 graus, per a 180 de 250 i així successivament … Escrivim la nostra funció de mapatge:

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

Aquesta és la nostra funció de mapatge. T'interessa com es deriva? Després llegeix això. Per tant, prenem els nostres intervals i el valor que volem assignar.

Ara, escrivim una funció que accepta l’angle i l’assigna al rang de les paparres:

void servo_write (int angle) {htim1. Instance-> CCR1 = mapa (0, 180, 50, 250, angle); }

Com podeu veure, aquest codi accepta l’angle i el mapeja al rang de nombre de paparres. Aleshores, es dóna el nombre de paparres al registre CCR1 que controla l’angle puntual i així.

Tanmateix, perquè tots aquests funcionin, primer comencem el pwm que es pot fer només amb una línia de codi:

HAL_TIM_PWM_Start (& htim1, TIM_CHANNEL_1);

Per tant, tenim una funció que accepta l’angle i l’escriu al servo. Anem a provar-ho i escrivim la nostra funció d'escombrat que és molt fàcil:

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

Per tant, només compta fins a 180 i després baixa fins a 0 i escriu aquests valors al servo:) Així que, anem a veure el resultat.

Pas 4: el resultat:)

Així doncs, aquest és el final. Si teniu alguna pregunta, pregunteu. Estaré encantat de respondre-hi. Moltes gràcies per llegir i espero que ens veiem al proper projecte:)