Przeszukaj forum

Raport mniejszości Oglądaliście kiedyś ten film? Główny bohater posługiwał się tam futurystycznym (przynajmniej jak na tamte czasy) interfejsem, którym sterował przy pomocy gestów. Fragment, który mam na myśli, możecie obejrzeć na Youtube. Osiągnięcie takiego poziomu zaawansowania wymaga oczywiście lat pracy, ale możemy spróbować skonstruować urządzenie, które będzie namiastką opisanego powyżej interfejsu. Koncepcja Zbudujemy urządzenie typu pan-tilt, czyli platformę obracającą się w dwóch osiach, sterowaną serwami. Sterowanie odbywać się będzie zdalnie, poprzez przechylanie telefonu komórkowego - platforma będzie próbowała naśladować gesty wykonywane przy pomocy telefonu. Platforma Na początku sama platforma - zdecydowałem się zaprojektować własną od zera, bazując na projekcie znalezionym na Thingiverse. Obrót w osi poziomej jest zmniejszony przez zębatkę - pozwala ona mniej więcej na 1/3 oryginalnego zakresu ruchu, ale za to jest on bardziej płynny. Obrót wokół osi pionowej jest natomiast nieograniczony. Pewnym kłopotem okazały się zębatki - przygotowanie dobrego koła zębatego wbrew pozorom wcale nie jest tak prostym zadaniem, jakim mogłoby się wydawać. Co więcej, nie ma również zbyt dużo narzędzi pozwalających na wygenerowanie prawidłowych kół zębatych. Po długich poszukiwaniach udało mi się jednak odnaleźć odpowiednie narzędzie - umożliwia ono konstruowanie kół zewnętrznych, wewnętrznych oraz listew zębatych: Gear Bakery. Wygenerowane koła zębate zapisywane są jako pliki .dxf, a te można już bez problemu wciągnąć do Fusion 360. Założyłem, że platforma będzie obracana zwykłymi, małymi serwami modelarskimi. Docelowo planowałem postawić na niej co najwyżej sportową kamerkę, więc moment rzędu 1.8 kg*cm jest tu całkowicie wystarczający. Pozostało wymodelowanie i wydrukowanie części, z których złożyłem potem platformę. Kontroler Tym razem potrzebowałem trochę więcej mocy obliczeniowej niż w wypadku prostszych projektów - w końcu musiałem postawić serwer odbierający dane po UDP - zdecydowałem się więc na Raspberry Pi. Serwer napisałem w Pythonie, bo język ten jest stosunkowo wysokopoziomowy i mocno separuje programistę od warstwy systemu i sprzętu: mogłem dzięki temu skupić się na istocie zadania, a nie na detalach implementacyjnych. Raspberry ma jednak pewną wadę - nie za dobrze radzi sobie z generowaniem sygnału PWM - sprzętowo może robić to tylko na jednym pinie. Co gorsza, standardowa biblioteka RPi.GPIO pozwala jedynie na programowe generowanie PWM - nie dawało to zbyt dobrych efektów. Na szczęście problem ten można bardzo elegancko obejść. Firma Adafruit przygotowała bowiem cwany układzik, który pozwala na sterowanie przy pomocy PWM aż dwunastoma niezależnymi urządzeniami, natomiast komunikacja tego układu z Raspberry odbywa się już po moim ulubionym protokole, czyli I2C. Układ ten rozwiązał jeszcze jeden problem, którego istnienie uświadomiłem sobie tak naprawdę w momencie, gdy właśnie zniknął. Serwa trzeba przecież jakoś zasilić, a nie można podłączyć ich do pinu 5V Raspberry - mają przecież znacznie większe zapotrzebowanie prądowe. PCA9685 w tym celu wyprowadza jednak szybkozłączkę, do której można podpiąć zewnętrzne zasilanie. Za każdym razem, gdy potrzebuję gdzieś 5V, zwykle robię mały przekręt: korzystam z kontrolera silnika bezszczotkowego, do którego przylutowałem wtyczkę T-Dean. Oprócz tego - co oczywiste - że ESC służy do sterowania silnikiem, obniża on również napięcie do 5V i przekazuje przewodami, które normalnie podłącza się do odbiornika RC. W pierwotnym zamyśle mechanizm ten nosił nazwę BEC - Battery Eliminator Circuit - i pozwalał w łatwy sposób zasilić odbiornik RC bez użycia dodatkowego akumulatora. Tymczasem wystarczy ominąć pin sterowania i mamy mały, wygodny, mobilny zasilacz na 5V. Konfiguracja Raspberry Aby mój skrypt w Pythonie uruchomił się, konieczne jest doinstalowanie biblioteki Adafruit pozwalającej na sterowanie kontrolerem PCA9685. Na początku trzeba oczywiście włączyć szynę I2C; robimy to w oknie konfiguracji Raspberry. Potem upewniamy się, że zainstalowane są następujące pakiety: sudo apt-get install python-smbus sudo apt-get install i2c-tools Po zainstalowaniu i2c-tools możemy użyć programiku i2cdetect, żeby sprawdzić, czy Raspberry prawidłowo wykrył kontroler PCA9685: ~ $ sudo ic2detect -y 1 0 1 2 3 4 5 6 7 8 9 a b c d e f 00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: 40 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 70: 70 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- Teraz możemy ściągnąć i zainstalować bibliotekę do Pythona. sudo apt-get install build-essential python-dev cd ~ git clone https://github.com/adafruit/Adafruit_Python_PCA9685.git cd Adafruit_Python_PCA9685 sudo python setup.py install Uruchamiamy Do uruchomienia całego urządzenia potrzebujemy dwóch kawałków kodu, jednego mniejszego, drugiego większego. Tym mniejszym jest serwer w Pythonie, który steruje serwami. Możecie go ściągnąć z mojego repozytorium albo po prostu przekleić, bo jego kod jest stosunkowo krótki: # -*- coding: utf-8 -*- import socket import sys import time import Adafruit_PCA9685 # Częstotliwość sterowania PWM FREQUENCY = 50 # Czas jednego cyklu CYCLE_TIME = 1 / float(FREQUENCY) # Procentowy czas cyklu dla położenia minimalnego SERVO_MIN_PERCENT = 0.00055 / CYCLE_TIME # Procentowy czas cyklu dla położenia maksymalnego SERVO_MAX_PERCENT = 0.00245 / CYCLE_TIME # Wartość minimalna dla 4096 kroków SERVO_MIN = int(4096 * SERVO_MIN_PERCENT) # Wartość maksymalna dla 4096 kroków SERVO_MAX = int(4096 * SERVO_MAX_PERCENT) # Tworzymy obiekt pwm (przyjmie domyślnie adres 0x40) pwm = Adafruit_PCA9685.PCA9685() pwm.set_pwm_freq(FREQUENCY) def setAngle(channel, angle): pwm.set_pwm(channel, 0, int(SERVO_MIN + (float(angle) / 180.0) * (SERVO_MAX - SERVO_MIN))) def processCommand(command): angles = command.split("|") angles = list(map(lambda x: max(-90, min(90, -int(x.strip()))) + 90, angles)) print("P: {0}, Y: {1}".format(angles[0], angles[2])) setAngle(14, int(angles[0] / 10) * 10) setAngle(15, int(angles[2] / 10) * 10) def main(): # Create TCP/IP socket sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # Bind the socket to the port server_address = ('', 10000) sock.bind(server_address) print("Waiting for data...") buffer = "" try: while True: data, addr = sock.recvfrom(32); buffer = buffer + data commandEnd = buffer.find(";") if (commandEnd != -1): command = buffer[0:commandEnd] buffer = buffer[commandEnd+1:] processCommand(command) except KeyboardInterrupt: print('Ctrl+C received, closing...') # Start program main() Drugi program jest już większy - to aplikacja na Androida, która pozwala na podłączenie się do serwera i przesyłanie informacji o orientacji telefonu. Ta również dostępna jest w moim repozytorium, tylko tym razem trzeba kod już ściągnąć i przebudować w Android Studio. Efekt Końcowy efekt na zdjęciu będzie wyglądał marnie, dlatego przygotowałem krótki filmik prezentujący, jak uruchomić cały projekt i jakie są efekty jego działania: Wnioski Serwa są bardzo wygodne w montażu i obsłudze, ale niestety również mało precyzyjne. Do takiego prostego projektu nadają się świetnie, ale w warunkach produkcyjnych trzeba byłoby wymienić je na ciche i dokładne silniki bezszczotkowe - takie, jakie są używane w gimbalach. Platforma reaguje na specyficzne ułożenie komórki; dzieje się tak dlatego, że komórka obrót wokół osi pionowej wysyła jako odchylenie od północy (0 stopni to północ). Tymczasem platforma "nie wie", w którą stronę jest zwrócona. Aby projekt był bardziej uniwersalny, można zastosować jedno z dwóch rozwiązań: dodać czujnik orientacji do platformy i kompensować różnice albo zapamiętać ułożenie komórki podczas łączenia do serwera i uznać je za pozycję "zerową". Mojemu projektowi daleko oczywiście do zaprezentowanego rozwiązania w "Raporcie mniejszości", ale nie ukrywam, że dał mi sporo frajdy. Można wykorzystać go jako bazę do zdalnego sterowania położeniem kamery lub na przykład ramienia robota.