Schwenk-Neige-Multi-Servosteuerung - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

In diesem Tutorial erfahren Sie, wie Sie mehrere Servos mit Python auf einem Raspberry Pi steuern. Unser Ziel wird ein PAN/TILT-Mechanismus sein, um eine Kamera (eine PiCam) zu positionieren.

Hier können Sie sehen, wie unser Abschlussprojekt funktionieren wird:

Control Servo Regelkreistest:

Schritt 1: Stückliste - Stückliste

Hauptteile:

1. Raspberry Pi V3 - US$ 32,00
2. 5 Megapixel 1080p Sensor OV5647 Mini Kamera Videomodul - US$ 13.00
3. TowerPro SG90 9G 180 Grad Micro Servo (2 X)- US$ 4.00
4. Mini-Schwenk-/Neige-Kameraplattform Anti-Vibrations-Kamerahalterung mit 2 Servos (*) - US$ 8.00
5. Widerstand 1K Ohm (2X) - Optional
6. Sonstiges: Metallteile, Bänder usw. (falls Sie Ihren Pan/Tilt-Mechanismus konstruieren)

(*) Sie können eine komplette Pan/Tilt-Plattform mit den Servos kaufen oder Ihre eigene bauen.

Schritt 2: Wie PWM funktioniert

Der Raspberry Pi hat keinen analogen Ausgang, aber wir können dies mit einem PWM-Ansatz (Pulsweitenmodulation) simulieren. Was wir tun werden, ist ein digitales Signal mit einer festen Frequenz zu erzeugen, bei dem wir die Impulsfolgebreite ändern, was wie unten gezeigt als "durchschnittlicher" Ausgangsspannungspegel "übersetzt" wird:

Wir können diesen "durchschnittlichen" Spannungspegel verwenden, um beispielsweise eine LED-Helligkeit zu steuern:

Beachten Sie, dass es hier nicht auf die Frequenz selbst ankommt, sondern auf den "Duty Cycle", dh das Verhältnis zwischen der Zeit, in der der Puls "hoch" ist, geteilt durch die Wellenperiode. Angenommen, wir erzeugen auf einem unserer Raspberry Pi GPIOs eine Pulsfrequenz von 50 Hz. Die Periode (p) ist der Kehrwert der Frequenz oder 20 ms (1/f). Wenn wir wollen, dass unsere LED "halb" hell ist, müssen wir einen Duty Cycle von 50% haben, das bedeutet einen "Puls", der für 10ms "High" ist.

Dieses Prinzip wird für uns sehr wichtig sein, um unsere Servoposition zu steuern, sobald der "Duty Cycle" die Servoposition wie unten gezeigt definiert:

Servo

Schritt 3: Installation des Hw

Die Servos werden an eine externe 5-V-Versorgung angeschlossen, wobei ihr Daten-Pin (in meinem Fall ihre gelbe Verdrahtung) wie folgt mit dem Raspberry Pi GPIO verbunden ist:

• GPIO 17 ==> Neigungsservo
• GPIO 27 ==> Pan-Servo

Vergessen Sie nicht, die GNDs miteinander zu verbinden ==> Raspberry Pi - Servos - External Power Supply)

Sie können optional einen Widerstand von 1K Ohm zwischen Raspberry Pi GPIO und Server-Dateneingangspin haben. Dies würde Ihr RPi im Falle eines Servoproblems schützen.

Schritt 4: Servos-Kalibrierung

Das erste, was Sie tun müssen, ist, die Hauptmerkmale Ihrer Servos zu bestätigen. In meinem Fall verwende ich einen Power Pro SG90.

Aus seinem Datenblatt können wir Folgendes berücksichtigen:

• Reichweite: 180o
• Stromversorgung: 4,8V (externe 5VDC als USB-Netzteil funktioniert einwandfrei)
• Arbeitsfrequenz: 50Hz (Periode: 20 ms)
• Pulsbreite: von 1ms bis 2ms

Theoretisch wird das Servo auf seiner

• Anfangsposition (0 Grad), wenn ein Impuls von 1 ms an seinen Datenanschluss angelegt wird
• Neutrale Position (90 Grad), wenn ein Impuls von 1,5 ms an seinen Datenanschluss angelegt wird
• Endposition (180 Grad), wenn ein Impuls von 2 ms an seinen Datenanschluss angelegt wird

Um eine Servoposition mit Python zu programmieren, ist es sehr wichtig, den entsprechenden "Duty Cycle" für die obigen Positionen zu kennen. Lassen Sie uns eine Berechnung durchführen:

• Ausgangsposition ==> (0 Grad) Pulsbreite ==> 1ms ==> Duty Cycle = 1ms/20ms ==> 2,0%
• Neutralstellung (90 Grad) Impulsbreite von 1,5 ms ==> Duty Cycle = 1,5 ms/20 ms ==> 7,5%
• Endposition (180 Grad) Pulsbreite von 2 ms ==> Duty Cycle = 2ms/20ms ==> 10%

Der Duty Cycle sollte also in einem Bereich von 2 bis 10 % variieren.

Lassen Sie uns die Servos einzeln testen. Öffnen Sie dazu Ihr Raspberry-Terminal und starten Sie Ihren Python 3-Shell-Editor als "sudo" (weil Sie ein "Super-Benutzer" sein sollten, um mit GPIOs umzugehen):

sudo python3

Auf Python-Shell

>>

Importieren Sie das RPI. GPIO-Modul und nennen Sie es GPIO:

RPi. GPIO als GPIO importieren

Definieren Sie, welche PIN-Nummerierungsschemata Sie verwenden möchten (BCM oder BOARD). Ich habe diesen Test mit BOARD gemacht, also waren die Pins, die ich verwendet habe, die physischen Pins (GPIO 17 = Pin 11 und GPIO 27 Pin 13). War einfach für mich, sie zu identifizieren und während des Tests keine Fehler zu machen (im endgültigen Programm werde ich BCM verwenden). Wählen Sie eine Ihrer Präferenzen:

GPIO.setmode(GPIO. BOARD)

Definieren Sie den Servo-Pin, den Sie verwenden:

TiltPin = 11

Wenn Sie stattdessen das BCM-Schema verwendet haben, sollten die letzten 2 Befehle ersetzt werden durch:

GPIO.setmode(GPIO. BCM)

TiltPin = 17

Jetzt müssen wir angeben, dass dieser Pin ein "Ausgang" ist.

GPIO.setup(tiltPin, GPIO. OUT)

Und welche Frequenz wird an diesem Pin generiert, die für unser Servo 50 Hz beträgt:

Neigung = GPIO. PWM(tiltPin, 50)

Beginnen wir nun mit der Generierung eines PWM-Signals am Pin mit einem anfänglichen Tastverhältnis (wir werden es bei "0" belassen):

kippen = starten(0)

Jetzt können Sie verschiedene Duty-Cycle-Werte eingeben und die Bewegung Ihres Servos beobachten. Beginnen wir mit 2% und sehen, was passiert (wir gehen davon aus, dass das Servo in die "Nullposition" geht):

Tilt. ChangeDutyCycle(2)

In meinem Fall ging das Servo in die Nullposition, aber als ich das Tastverhältnis auf 3% änderte, beobachtete ich, dass das Servo in der gleichen Position blieb und sich mit Tastverhältnissen von mehr als 3% zu bewegen begann. 3% ist also meine Ausgangsposition (o Grad). Das gleiche passierte mit 10%, mein Servo ging über diesen Wert und übertraf sein Ende mit 13%. Für dieses spezielle Servo war das Ergebnis:

• 0 Grad ==> Tastverhältnis von 3%
• 90 Grad ==> Tastverhältnis von 8%
• 180 Grad ==> Tastverhältnis von 13%

Nachdem Sie Ihre Tests abgeschlossen haben, müssen Sie die PWM stoppen und die GPIOs bereinigen:

Neigung = Stopp ()

GPIO.cleanup()

Der obige Terminal-Druckbildschirm zeigt das Ergebnis für meine beiden Servos (mit ähnlichen Ergebnissen). Ihre Reichweite kann unterschiedlich sein.

Schritt 5: Erstellen eines Python-Skripts

Die an unser Servo zu sendenden PWM-Befehle sind in "Duty Cycles", wie wir im letzten Schritt gesehen haben. Aber normalerweise müssen wir "Winkel" in Grad als Parameter verwenden, um ein Servo zu steuern. Wir müssen also den "Winkel" umrechnen, der für uns eine natürlichere Messung im Arbeitszyklus ist, als für unseren Pi verständlich.

Wie es geht? Sehr einfach! Wir wissen, dass der Arbeitszyklusbereich von 3% bis 13% reicht und dass dies Winkeln von 0 bis 180 Grad entspricht. Außerdem wissen wir, dass diese Variationen linear sind, sodass wir wie oben gezeigt ein proportionales Schema erstellen können. Bei einem gegebenen Winkel können wir also einen entsprechenden Arbeitszyklus haben:

Tastverhältnis = Winkel/18 + 3

Behalten Sie diese Formel bei. Wir werden es im nächsten Code verwenden.

Lassen Sie uns ein Python-Skript erstellen, um die Tests auszuführen. Grundsätzlich werden wir wiederholen, was wir zuvor in Python Shell getan haben:

ab zeit importieren schlaf

RPi. GPIO als GPIO importieren GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) def setServoAngle(servo, angle): pwm = GPIO. PWM(servo, 50) pwm.start(8) dutyCycle = angle / 18. + 3. pwm. ChangeDutyCycle(dutyCycle) sleep(0.3) pwm.stop() if _name_ == '_main_': import sys servo = int(sys.argv[1]) GPIO.setup(servo, GPIO. OUT) setServoAngle (servo, int(sys.argv[2])) GPIO.cleanup()

Der Kern des obigen Codes ist die Funktion setServoAngle(servo, angle). Diese Funktion empfängt als Argumente eine Servo-GPIO-Nummer und einen Winkelwert, an dem das Servo positioniert werden muss. Sobald die Eingabe dieser Funktion "Winkel" ist, müssen wir sie mit der zuvor entwickelten Formel in einen Arbeitszyklus in Prozent umwandeln.

Wenn das Skript ausgeführt wird, müssen Sie als Parameter Servo-GPIO und Winkel eingeben.

Zum Beispiel:

sudo python3 angleServoCtrl.py 17 45

Der obige Befehl positioniert das an GPIO 17 angeschlossene Servo mit 45 Grad in "Elevation". Ein ähnlicher Befehl könnte für die Pan-Servo-Steuerung verwendet werden (Position auf 45 Grad im "Azimut"):

sudo python angleServoCtrl.py 27 45

Die Datei angleServoCtrl.py kann von meinem GitHub heruntergeladen werden

Schritt 6: Der Pan-Tilt-Mechanismus

Das "Pan"-Servo bewegt unsere Kamera "horizontal" ("Azimutwinkel") und unser "Tilt"-Servo bewegt sie "vertikal" (Elevationswinkel).

Das folgende Bild zeigt, wie der Pan/Tilt-Mechanismus funktioniert:

Bei unserer Entwicklung gehen wir nicht ins "Extreme" und nutzen unseren Pan/Tilt-Mechanismus nur von 30 bis 150 Grad. Dieser Bereich reicht aus, um mit einer Kamera verwendet zu werden.

Schritt 7: Der Pan-Tilt-Mechanismus - Mechanische Konstruktion

Lassen Sie uns nun unsere 2 Servos als Pan / Tilt-Mechanismus zusammenbauen. Sie können hier 2 Dinge tun. Kaufen Sie einen Pan-Tilt-Plattformmechanismus wie im letzten Schritt gezeigt oder bauen Sie Ihren eigenen nach Ihren Bedürfnissen.

Ein Beispiel kann das sein, das ich gebaut habe, nur die Servos aneinander zu schnallen und kleine Metallstücke aus alten Spielzeugen zu verwenden, wie auf den Fotos oben gezeigt.

Schritt 8: Elektrische Schwenk-/Neigebaugruppe

Nachdem Sie Ihren Schwenk-/Neigemechanismus zusammengebaut haben, folgen Sie den Fotos für den vollständigen elektrischen Anschluss.

1. Schalten Sie Ihren Pi aus.
2. Alle elektrischen Anschlüsse vornehmen.
3. Überprüfen Sie es.
4. Schalten Sie zuerst Ihren Pi ein.
5. Wenn alles in Ordnung ist, schalten Sie Ihre Servos ein.

Wir werden in diesem Tutorial nicht untersuchen, wie die Kamera eingerichtet wird, dies wird im nächsten Tutorial erklärt.

Schritt 9: Das Python-Skript

Lassen Sie uns ein Python-Skript erstellen, um beide Servos gleichzeitig zu steuern:

ab zeit importieren schlaf

RPi. GPIO als GPIO importieren GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) pan = 27 Tilt = 17 GPIO.setup(tilt, GPIO. OUT) # white => TILT GPIO.setup(pan, GPIO. OUT) # grau ==> PAN def setServoAngle(servo, angle): Winkel >=30 und Winkel 90 (Mittelpunkt) bestätigen ==> 150 setServoAngle(tilt, int(sys.argv[2])) # 30 ==> 90 (Mittelpunkt) ==> 150 GPIO.cleanup()

Wenn das Skript ausgeführt wird, müssen Sie als Parameter Pan angle und Tilt angle eingeben. Zum Beispiel:

sudo python3 servoCtrl.py 45 120

Der obige Befehl positioniert den Pan/Tilt-Mechanismus mit 45 Grad im "Azimut" (Pan-Winkel) und 120 Grad "Elevation" (Tilt Angle). Beachten Sie, dass, wenn keine Parameter eingegeben werden, die Standardeinstellung sowohl für den Schwenk- als auch für den Neigewinkel auf 90 Grad eingestellt ist.

Unten sehen Sie einige Tests:

Die Datei servoCtrl.py kann von meinem GitHub heruntergeladen werden.

Schritt 10: Schleifentest von Servern

Lassen Sie uns nun ein Python-Skript erstellen, um die gesamte Palette von Servos automatisch zu testen:

ab zeit importieren schlaf

RPi. GPIO als GPIO importieren GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) pan = 27 Tilt = 17 GPIO.setup(tilt, GPIO. OUT) # white => TILT GPIO.setup(pan, GPIO. OUT) # grau ==> PAN def setServoAngle(servo, angle): assert angle >=30 and angle <= 150 pwm = GPIO. PWM(servo, 50) pwm.start(8) dutyCycle = angle / 18. + 3. pwm. ChangeDutyCycle(dutyCycle) sleep(0.3) pwm.stop() if _name_ == '_main_': für i im Bereich (30, 160, 15): setServoAngle(pan, i) setServoAngle(tilt, i) für i in Bereich (150, 30, -15): setServoAngle(pan, i) setServoAngle(tilt, i) setServoAngle(pan, 100) setServoAngle(tilt, 90) GPIO.cleanup()

Das Programm führt automatisch eine Schleife von 30 bis 150 Grad in beiden Winkeln aus.

Unten das Ergebnis:

Ich habe ein Oszilloskop nur angeschlossen, um die PWM-Theorie wie zuvor erläutert zu veranschaulichen.

Der obige Code servoTest.py kann von meinem GitHub heruntergeladen werden.

Schritt 11: Fazit

Wie immer hoffe ich, dass dieses Projekt anderen helfen kann, ihren Weg in die spannende Welt der Elektronik zu finden!

Für Details und den endgültigen Code besuchen Sie bitte mein GitHub-Depot: RPi-Pan-Tilt-Servo-Control

Für weitere Projekte besuchen Sie bitte meinen Blog: MJRoBot.org

Unten ein Einblick in mein nächstes Tutorial:

Saludos aus dem Süden der Welt!

Wir sehen uns in meinem nächsten instructable!

Dankeschön, Marcelo