Servomotorsteuerung mit STM32F4 ARM MCU - Gunook

2025 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2025-01-23 12:52

Hallo nochmal Freunde:) Also, in diesem Projekt werden wir einen Servomotor mit STM32F4 ARM MCU steuern. In meinem Fall werde ich Discovery Board verwenden, aber wenn Sie das Wesentliche des Problems verstehen, können Sie es für jede MCU anwenden. So. Lass uns anfangen:)

Schritt 1: Hardware- und Softwareanforderungen

Als Hardware benötigen wir:

• Eine MCU, die in meinem Fall ein STM32f4-Discovery-Board ist
• Ein üblicher Servomotor, wie SG90 oder ein anderer

Als Software benötigen wir:

• STM32CubeMX
• Keil uVision

Wenn Sie all dies haben, springen Sie zum nächsten Schritt:)

Schritt 2: STM32CubeMX-Konfiguration

Wie Sie wissen, benötigen wir zur Steuerung eines Servomotors ein PWM-Signal. Die Anforderungen an das PWM-Signal sind wie folgt:

• PWM-Periode muss 20 mS. betragen
• Die Einschaltzeit muss zwischen 0,5 mS und 2,5 mS liegen. Wenn die Einschaltzeit 0,5 mS beträgt, dreht sich das Servo um 0 Grad, 1,5 mS für 90 Grad und 2,5 mS für 180 Grad.

Wir müssen also PWM konfigurieren und verwenden zu diesem Zweck Timer1.

• Wählen Sie zuerst TIM1 aus dem Abschnitt Timer. Dieser Schritt

• Dann aus dem Modus-Abschnitt

  1. Wählen Sie die interne Uhr Dieser Schritt
  2. PWM-Generierung CH1 Dieser Schritt

• Dann aus dem Abschnitt Konfiguration

  1. Prescaler auf 160 setzen Dieser Schritt
  2. Zählerperiode auf 2000 setzen Dieser Schritt
  3. Puls auf 50 setzen Dieser Schritt
• Außerdem können Sie in der Taktkonfiguration die Takte des APB1-Timers auf 16 MHz einstellen. Dieser Schritt

Lassen Sie uns nun ein wenig über diesen Schritt sprechen:

Die Frequenz unserer APB1 Timer-Uhr beträgt 16 MHz. Das bedeutet also, dass 16.000.000 Ticks erforderlich sind, um 1 Sekunde zu erhalten. Allerdings haben wir unseren Prescaler auf 160 gesetzt. Das heißt, wir teilen unsere Frequenz durch diese Zahl und reduzieren die Anzahl der Ticks auf 100.000. Für 1 Sekunde brauchen wir also 100.000 Ticks. Wir benötigen jedoch, wie bereits erwähnt, 20 ms PWM-Periode. Nach einfacher Mathematik brauchen wir also 2000 Ticks für 20 mS. Indem wir Counter Period auf 2000 setzen, bestimmen wir die Periode des PWM-Signals, die 20 ms beträgt. Jetzt müssen wir die Tick-Nummer bestimmen, um die Einschaltzeiten von 0,5 mS bis 2,5 mS zu erreichen. Wir können diese Gleichung aus einfacher Mathematik erhalten und sie lautet:

On_Time = (Tick_Number / 100). Beachten Sie, dass dies die on_time ist, die den Winkel des Servomotors ändert. Also, unter dem Bild fasse ich diesen Schritt zusammen. Wenn Sie Fragen haben, schreiben Sie in die Kommentare und ich werde so schnell wie möglich antworten.

Bild der Berechnungen

Nachdem Sie all dies getan haben, generieren Sie Code:)

Schritt 3: Keil UVision-Codierung

Also, lassen Sie uns zuerst bestimmen, was wir tun wollen? Wir wollen eine Funktion schreiben, die Grad akzeptiert und in das Servo schreiben. Also, wie werden wir das machen? Wie bereits erwähnt, müssen wir die Pünktlichkeit ändern, um den Winkel zu ändern. Unsere Winkel ändern sich zwischen [0, 180] und unsere Anzahl der Ticks, die die Zeitänderungen bestimmt, zwischen [50, 250]. Wir brauchen also eine Abbildungsfunktion, die den gegebenen Winkel auf den Bereich der Anzahl von Ticks abbildet. Zum Beispiel für 0 Grad 50 Ticks, für 180 Grad 250 Ticks usw. Schreiben wir also unsere Mapping-Funktion:

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

Dies ist unsere Mapping-Funktion. Interessiert Sie, wie es abgeleitet wird? Dann lies das. Wir nehmen also unsere Reichweiten und den Wert, den wir abbilden möchten.

Lassen Sie uns nun eine Funktion schreiben, die den Winkel akzeptiert und ihn dem Bereich der Ticks zuordnet:

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

Wie Sie sehen, akzeptiert dieser Code Winkel und ordnet ihn dem Bereich der Anzahl von Ticks zu. Anschließend wird die Anzahl der Ticks an das CCR1-Register übergeben, das die Einschaltzeit und damit den Winkel steuert.

Damit all dies funktioniert, starten wir jedoch zuerst das pwm, was mit nur einer Codezeile erledigt werden kann:

HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);

Wir haben also eine Funktion, die Winkel akzeptiert und in das Servo schreibt. Lassen Sie es uns testen und unsere Sweep-Funktion schreiben, die sehr einfach ist:

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

Also zähle einfach bis 180 hoch und dann runter bis 0 und schreibe diese Werte in das Servo:) Also, lass uns das Ergebnis sehen!

Schritt 4: Das Ergebnis:)

Das ist also das Ende. Wenn Sie Fragen haben, fragen Sie bitte. Gerne beantworte ich sie. Vielen Dank fürs Lesen und hoffe, ich sehe Sie im nächsten Projekt:)