Pan-Tilt Multi Servo Control: 11 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

W tym samouczku dowiemy się, jak sterować wieloma serwami za pomocą Pythona na Raspberry Pi. Naszym celem będzie mechanizm PAN/TILT do pozycjonowania kamery (PiCam).

Tutaj możesz zobaczyć, jak będzie działał nasz ostateczny projekt:

Test pętli sterowania serwosterowaniem:

Krok 1: BoM - zestawienie materiałów

Główne części:

1. Raspberry Pi V3 - 32,00 USD
2. 5 megapikseli 1080p Sensor OV5647 Mini moduł wideo kamery - 13,00 USD
3. TowerPro SG90 9G 180 stopni Micro Servo (2 X) - 4,00 USD
4. Platforma kamery Mini Pan/Tilt Antywibracyjny uchwyt kamery z 2 serwami (*) - 8,00 USD
5. Rezystor 1K ohm (2X) - Opcjonalny
6. Różne: części metalowe, opaski itp. (na wypadek, gdybyś konstruował mechanizm Pan/Tilt)

(*) możesz kupić kompletną platformę Pan/Tilt z serwami lub zbudować własną.

Krok 2: Jak działa PWM

Raspberry Pi nie ma wyjścia analogowego, ale możemy to zasymulować, stosując podejście PWM (modulacja szerokości impulsu). To, co zrobimy, to wygenerowanie sygnału cyfrowego o stałej częstotliwości, w którym zmienimy szerokość ciągu impulsów, co zostanie „przetłumaczone” jako „średni” poziom napięcia wyjściowego, jak pokazano poniżej:

Możemy wykorzystać ten „średni” poziom napięcia do sterowania jasnością LED, na przykład:

Zauważ, że to, co się tutaj liczy, to nie sama częstotliwość, ale „Cykl pracy”, czyli stosunek czasu, w którym puls jest „wysoki”, podzielony przez okres fali. Załóżmy na przykład, że wygenerujemy częstotliwość impulsu 50 Hz na jednym z naszych GPIO Raspberry Pi. Okres (p) będzie odwrotnością częstotliwości lub 20ms (1/f). Jeśli chcemy, aby nasza dioda LED była jasna „połowa”, musimy mieć cykl pracy 50%, co oznacza „impuls”, który będzie „wysoki” przez 10ms.

Ta zasada będzie dla nas bardzo ważna, aby kontrolować naszą pozycję serwa, gdy "Cykl pracy" zdefiniuje pozycję serwa, jak pokazano poniżej:

Serwo

Krok 3: Instalacja Hw

Serwa będą podłączone do zewnętrznego zasilania 5V, a ich pin danych (w moim przypadku ich żółte okablowanie) będzie podłączony do GPIO Raspberry Pi jak poniżej:

• GPIO 17 ==> Serwo przechyłu
• GPIO 27 ==> Pan Serwo

Nie zapomnij połączyć razem GND ==> Raspberry Pi - Serwa - Zewnętrzny zasilacz)

Opcjonalnie możesz mieć rezystor 1K ohm między GPIO Raspberry Pi a pinem wejściowym danych serwera. Chroniłoby to twoje RPi w przypadku problemu z serwomechanizmem.

Krok 4: Kalibracja serw

Pierwszą rzeczą do zrobienia jest potwierdzenie głównych cech serw. W moim przypadku używam Power Pro SG90.

Z jego arkusza danych możemy rozważyć:

• Zasięg: 180o
• Zasilanie: 4,8V (zewnętrzne 5VDC jako zasilacz USB działa dobrze)
• Częstotliwość pracy: 50Hz (okres: 20 ms)
• Szerokość impulsu: od 1ms do 2ms

Teoretycznie serwo będzie na swoim

• Pozycja początkowa (0 stopni) po przyłożeniu impulsu 1 ms do jego terminala danych
• Pozycja neutralna (90 stopni) po przyłożeniu impulsu 1,5 ms do jego zacisku danych
• Pozycja końcowa (180 stopni) po przyłożeniu impulsu 2 ms do jego terminala danych

Aby zaprogramować pozycję serwomechanizmu za pomocą Pythona, bardzo ważne jest, aby znać odpowiedni „cykl pracy” dla powyższych pozycji, zróbmy obliczenia:

• Pozycja początkowa ==> (0 stopni) Szerokość impulsu ==> 1ms ==> Cykl pracy = 1ms/20ms ==> 2,0%
• Pozycja neutralna (90 stopni) Szerokość impulsu 1,5 ms ==> Cykl pracy = 1,5 ms/20 ms ==> 7,5%
• Pozycja końcowa (180 stopni) Szerokość impulsu 2 ms ==> Cykl pracy = 2ms/20ms ==> 10%

Tak więc cykl pracy powinien wahać się w zakresie od 2 do 10%.

Przetestujmy serwa indywidualnie. W tym celu otwórz terminal Raspberry i uruchom edytor powłoki Python 3 jako „sudo” (ponieważ powinieneś być „super użytkownikiem” do obsługi GPIO):

sudo python3

W powłoce Pythona

>>

Zaimportuj moduł RPI. GPIO i nazwij go GPIO:

importuj RPi. GPIO jako GPIO

Określ, których schematów numerowania pinów chcesz użyć (BCM lub BOARD). Zrobiłem ten test z BOARD, więc piny, których użyłem, były fizycznymi pinami (GPIO 17 = Pin 11 i GPIO 27 Pin 13). Łatwo było mi je zidentyfikować i nie popełniać błędów podczas testu (w finalnym programie będę korzystał z BCM). Wybierz jedną ze swoich preferencji:

GPIO.setmode(GPIO. BOARD)

Zdefiniuj pin serwa, którego używasz:

przechylPin = 11

Jeśli zamiast tego użyłeś schematu BCM, ostatnie 2 polecenia powinny zostać zastąpione przez:

GPIO.setmode(GPIO. BCM)

przechyłPin = 17

Teraz musimy określić, że ten pin będzie „wyjściem”

GPIO.setup(tiltPin, GPIO. OUT)

A jaka będzie częstotliwość generowana na tym pinie, która dla naszego serwa będzie wynosić 50Hz:

tilt = GPIO. PWM(tiltPin, 50)

Teraz zacznijmy generować sygnał PWM na pinie z początkowym cyklem pracy (będziemy trzymać go „0”):

pochylenie = start(0)

Teraz możesz wprowadzić różne wartości cyklu pracy, obserwując ruch serwa. Zacznijmy od 2% i zobaczmy co się stanie (podejrzewamy, że serwo ustawi się w „pozycji zerowej”):

tilt. ChangeDutyCycle(2)

W moim przypadku serwo znalazło się w pozycji zerowej, ale kiedy zmieniłem cykl pracy na 3%, zaobserwowałem, że serwo zostało w tej samej pozycji, zaczynając poruszać się z cyklami pracy większymi niż 3%. Tak więc 3% to moja początkowa pozycja (o stopniach). To samo stało się z 10%, moje serwo przekroczyło tę wartość, osiągając koniec na 13%. Tak więc dla tego konkretnego serwa wynik był następujący:

• 0 stopni ==> cykl pracy 3%
• 90 stopni ==> cykl pracy 8%
• 180 stopni ==> cykl pracy 13%

Po zakończeniu testów musisz zatrzymać PWM i wyczyścić GPIO:

pochylenie= stop()

GPIO.oczyszczanie()

Powyższy ekran drukowania terminala pokazuje wynik dla obu moich serwomechanizmów (które mają podobne wyniki). Twój zasięg może być inny.

Krok 5: Tworzenie skryptu w Pythonie

Polecenia PWM, które mają zostać wysłane do naszego serwomechanizmu, są w „cyklach roboczych”, jak widzieliśmy w ostatnim kroku. Ale zwykle musimy użyć "kąta" w stopniach jako parametru do sterowania serwomechanizmem. Musimy więc przekonwertować „kąt”, który jest dla nas bardziej naturalną miarą w cyklu pracy, co jest zrozumiałe dla naszego Pi.

Jak to zrobić? Bardzo prosta! Wiemy, że zakres cyklu pracy wynosi od 3% do 13% i że jest to odpowiednik kątów, które będą mieścić się w zakresie od 0 do 180 stopni. Wiemy również, że te wariacje są liniowe, więc możemy skonstruować proporcjonalny schemat, jak pokazano powyżej. więc przy danym kącie możemy mieć odpowiedni współczynnik wypełnienia:

cykl pracy = kąt/18 + 3

Zachowaj tę formułę. Użyjemy go w następnym kodzie.

Stwórzmy skrypt Pythona do wykonywania testów. Zasadniczo powtórzymy to, co zrobiliśmy wcześniej w Python Shell:

od czasu importuj sen

importuj RPi. GPIO jako GPIO GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) def setServoAngle(serwo, kąt): pwm = GPIO. PWM(serwo, 50) pwm.start(8) dutyCycle = kąt / 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 (serwo, int(sys.argv[2])) GPIO.cleanup()

Rdzeniem powyższego kodu jest funkcja setServoAngle(servo, angle). Ta funkcja otrzymuje jako argumenty, numer GPIO serwa i wartość kąta, do którego serwo musi być ustawione. Gdy dane wejściowe tej funkcji to „kąt”, musimy przeliczyć je na współczynnik wypełnienia w procentach, korzystając z opracowanego wcześniej wzoru.

Kiedy skrypt jest wykonywany, musisz wprowadzić jako parametry serwo GPIO i kąt.

Na przykład:

sudo python3 angleServoCtrl.py 17 45

Powyższe polecenie ustawi serwo podłączone na GPIO 17 z 45 stopniami w "elewacji". Podobne polecenie może być użyte do sterowania Pan Servo (pozycja do 45 stopni w „azymucie”):

kąt sudo PythonaServoCtrl.py 27 45

Plik angleServoCtrl.py można pobrać z mojego GitHub

Krok 6: Mechanizm obrotu i przechyłu

Serwo „Pan” przesunie „poziomo” naszą kamerę („kąt azymutu”), a nasze serwo „Tilt” przesunie ją „w pionie” (kąt elewacji).

Poniższy rysunek pokazuje, jak działa mechanizm Pan/Tilt:

Podczas naszego rozwoju nie będziemy posuwać się do „ekstremalności” i będziemy używać naszego mechanizmu Pan/Tilt tylko od 30 do 150 stopni. Ten zasięg wystarczy do użycia z aparatem.

Krok 7: Mechanizm obrotu i przechyłu - konstrukcja mechaniczna

Zamontujmy teraz nasze 2 serwa jako mechanizm Pan/Tilt. Tutaj możesz zrobić 2 rzeczy. Kup mechanizm platformy Pan-Tilt, jak pokazano na ostatnim kroku, lub zbuduj własną zgodnie z własnymi potrzebami.

Jednym z przykładów może być ten, który zbudowałem, tylko przypinając serwa jeden do drugiego i używając małych metalowych elementów ze starych zabawek, jak pokazano na powyższych zdjęciach.

Krok 8: Elektryczny zespół przechylania/przechylania

Po złożeniu mechanizmu Pan/Tilt postępuj zgodnie ze zdjęciami, aby uzyskać pełne połączenie elektryczne.

1. Wyłącz swoje Pi.
2. Wykonaj wszystkie połączenia elektryczne.
3. Sprawdź to dwukrotnie.
4. Najpierw włącz swoje Pi.
5. Jeśli wszystko jest w porządku, włącz serwa.

W tym samouczku nie będziemy badać, jak skonfigurować kamerę, zostanie to wyjaśnione w następnym samouczku.

Krok 9: Skrypt Pythona

Stwórzmy skrypt Pythona, aby kontrolować oba serwa jednocześnie:

od czasu importuj sen

importuj RPi. GPIO jako GPIO GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) pan = 27 tilt = 17 GPIO.setup(tilt, GPIO. OUT) # biały => TILT GPIO.setup(pan, GPIO. OUT) # gray ==> PAN def setServoAngle(servo, angle): asercja kąta >=30 i kąta 90 (punkt środkowy) ==> 150 setServoAngle(tilt, int(sys.argv[2])) # 30 ==> 90 (punkt środkowy) ==> 150 GPIO.cleanup()

Kiedy skrypt jest wykonywany, musisz wprowadzić jako parametry Kąt panoramy i Kąt nachylenia. Na przykład:

sudo python3 servoCtrl.py 45 120

Powyższe polecenie ustawi mechanizm Pan/Tilt z 45 stopniami w „azymucie” (kąt obrotu) i 120 stopniami „elewacji” (kąt nachylenia). Zwróć uwagę, że jeśli nie zostaną wprowadzone żadne parametry, wartością domyślną będą kąty obrotu i pochylenia ustawione do 90 stopni.

Poniżej możesz zobaczyć kilka testów:

Plik servoCtrl.py można pobrać z mojego GitHub.

Krok 10: Test pętli serwerów

Stwórzmy teraz skrypt Pythona, aby automatycznie przetestować pełen zakres serw:

od czasu importuj sen

importuj RPi. GPIO jako GPIO GPIO.setmode(GPIO. BCM) GPIO.setwarnings(False) pan = 27 tilt = 17 GPIO.setup(tilt, GPIO. OUT) # biały => TILT GPIO.setup(pan, GPIO. OUT) # grey ==> PAN def setServoAngle(servo, angle): asercja kąta >=30 i kąta <= 150 pwm = GPIO. PWM(serwo, 50) pwm.start(8) dutyCycle = kąt / 18. + 3. pwm. ChangeDutyCycle(dutyCycle) sleep(0.3) pwm.stop() if _name_ == '_main_': for i in range (30, 160, 15): setServoAngle(pan, i) setServoAngle(tilt, i) for i in range (150, 30, -15): setServoAngle(pan, i) setServoAngle(tilt, i) setServoAngle(pan, 100) setServoAngle(tilt, 90) GPIO.cleanup()

Program wykona automatycznie pętlę od 30 do 150 stopni w obu kątach.

Poniżej wyniku:

Podłączyłem oscyloskop tylko po to, aby zilustrować teorię PWM, jak wyjaśniono wcześniej.

Powyższy kod servoTest.py można pobrać z mojego GitHub.

Krok 11: Wniosek

Jak zawsze mam nadzieję, że ten projekt pomoże innym odnaleźć drogę do ekscytującego świata elektroniki!

Aby uzyskać szczegółowe informacje i ostateczny kod, odwiedź mój depozyt na GitHub: RPi-Pan-Tilt-Servo-Control

Więcej projektów znajdziesz na moim blogu: MJRoBot.org

Poniżej rzut oka na mój następny samouczek:

Saludo z południa świata!

Do zobaczenia w mojej następnej instrukcji!

Dziękuję Ci, Marcelo