Dron Raspberry Pi sterowany głosem Alexa z IoT i AWS: 6 kroków (ze zdjęciami)

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

Cześć! Nazywam się Armaan. Jestem 13-latkiem z Massachusetts. Ten samouczek pokazuje, jak można wywnioskować z tytułu, jak zbudować drona Raspberry Pi. Ten prototyp pokazuje, w jaki sposób drony ewoluują, a także jak dużą rolę mogą odegrać w przyszłości. Zdecydowanie widzę siebie, jak budzę się za 10 lat i proszę drona o śniadanie dla mnie. Dron wykorzystuje Amazon Alexa, Amazon Web Services, IoT (Internet of Things) i, co najważniejsze, Raspberry Pi. Ma za zadanie zademonstrować i poinformować o dronach oraz o tym, jak poprawiają się na co dzień. Mam nadzieję, że odniesiesz sukces i przy okazji dowiesz się o dronach. Powodzenia i dzięki za przeczytanie. -Armaan

Kieszonkowe dzieci

Do zbudowania prototypu potrzebne są różne sprzętowe i programowe potrzeby. Skorzystałem z samouczka online autorstwa The Drone Dojo, aby zbudować drona i zintegrować wymienione technologie. W przypadku drona listę części można znaleźć tutaj:

Lista części do drona

Wymagania Systemowe:

• Usługi internetowe Amazon
• Laptop
• Oprogramowanie do planowania misji
• Balena Etcher
• Karta MicroSD z plikiem Raspbian znajduje się tutaj
• Amazon Alexa, fizyczna lub wirtualna

Krok 1: Zbieranie i zrozumienie części

Każda część wymieniona na liście dostaw jest niezbędna, podobnie jak jasne zrozumienie każdej części. Możesz znaleźć części online i po zebraniu kontynuuj czytanie. Playlistę The Drone Dojo, aby w pełni zrozumieć poszczególne części, można znaleźć tutaj. 4-minutowe wyjaśnienie na moim kanale youtube można znaleźć tutaj. Jeśli chodzi o drony, jedyne części, wbrew temu, co większość ludzi myśli, to nie tylko silniki i śmigła. Poniżej znajdują się podstawowe cele każdej części.

Raspberry Pi z Emlid Navio2

Ta część jest w zasadzie centralnym procesorem i głównym punktem drona. Raspberry Pi działa jak procesor komputera, który wysyła polecenia do Navio2 w celu wykonania przez PWM (sygnały modulacji szerokości impulsu) do innych części drona

2. ESC (elektroniczne regulatory prędkości)

Te żółte części znajdują się pod ramą. Są 4 podłączone do Navio, po jednym dla każdego silnika. Po otrzymaniu sygnałów PWM obracają silniki i rozpoczynają lot.

3. Silniki

Silniki nie wymagają zbyt wielu wyjaśnień, ponieważ prawdopodobnie je znasz. Obracają się i kręcą śmigła, aby wytworzyć ciąg.

4. Śmigła

Śmigła tworzą ciąg, dzięki któremu dron może latać. Obracają się w tym samym kierunku co silniki do podnoszenia pojazdu.

5. Moduł baterii i zasilania

Akumulator LiPo zasila cały dron przez ramę za pomocą modułu zasilania. Daje około 15-20 minut czasu lotu i działa jako źródło zasilania.

6. GPS

GPS komunikuje się z satelitami w celu określenia pozycji drona. Określa wysokość, szerokość i długość geograficzną. Może być używany do Geofencing, waypointów, a także do poruszania się w określonych pozycjach lub kierunkach.

7. Moduł telemetrii

Moduł telemetryczny łączy naszego drona z naziemną stacją kontroli, w naszym przypadku Mission Planner, która ma być monitorowana.

8. Kontroler i moduł RC wraz z enkoderem PPM

Kontroler RC wykorzystuje radio do przesyłania sygnałów i poleceń do modułu RC w celu ręcznego sterowania dronem. Enkoder PPM tłumaczy te sygnały w celu przetworzenia i wykonania przez Navio + RPI.

9. Rama

Ta czerwono-biała rama działa jako podstawa lub platforma do umieszczenia innych części. Rama jest aerodynamiczna i lekka, dlatego idealnie nadaje się do budowy naszego drona.

Teraz ze znajomością każdej części możemy wreszcie zbudować drona! Ruszaj do następnego kroku!

Krok 2: Montaż drona

Ten krok jest prawdopodobnie najtrudniejszy pod względem wysiłku fizycznego. Polecam zaprosić do pomocy inną osobę lub spróbować użyć pomocnej dłoni w wykazie części. Proces jest zbyt długi, aby go tutaj zademonstrować, więc podam kolejny link, z którego korzystałem w The Drone Dojo.

Budowanie drona Raspberry Pi

Ponownie, ponieważ nie będę się zagłębiał w szczegóły, po prostu podkreślę podstawy każdego kroku.

1. Uporządkuj swoje materiały - zbierz nasze materiały i upewnij się, że są łatwo dostępne

2. Zaplanuj swoją konstrukcję - ułóż części na ramie, aby stworzyć plan tego, co zbudujesz

3. Praca lutownicza - jest to praca, którą trochę trudno wykonać w pojedynkę. Do ESC należy przylutować złote złącza pocisków, które są dołączone do silników. Następnie należy wziąć dolną część ramy i przylutować ESC do dolnej ramy lub tablicy rozdzielczej. Moduł baterii zostanie również przylutowany do tablicy rozdzielczej zasilania

4. Ustawienie ramy – Następnie należy przykręcić górną część ramy wraz z ramionami. Następnie możesz przymocować Raspberry Pi na wierzchu w dowolny sposób (użyłem taśmy klejącej). Następnie możesz przymocować ESC do ramion za pomocą zamków błyskawicznych. Teraz prawie skończyliśmy.

5. Wiązanie kontrolera RC z odbiornikiem - Spróbuj wykonać instrukcje z powyższej listy odtwarzania, aby powiązać kontroler RC za pomocą ESC.

6. Finalizowanie części na ramie - taśma izolacyjna lub pasek na module telemetrycznym na ramie. Przyklej również enkoder PPM do ramienia. Teraz możesz podłączyć enkoder ESC i PPM do Navio.

7. Uchwyt GPS + bateria - Złóż uchwyt GPS za pomocą różnych śrub i elementów. Przymocuj GPS do ramy za pomocą opasek błyskawicznych. Niekoniecznie używałem uchwytu GPS ze względu na jego kruchość, ale to zależy od Ciebie. Następnie możesz włożyć baterię między Power Dist. Deska. Przymocowałem i przykleiłem również moduł zasilania do ramy. Teraz twój sprzęt jest już prawie skonfigurowany. Teraz część, na którą czekaliśmy!

8. Montaż śmigieł!!! - Możesz dokręcić śmigła, korzystając z wykresu wymienionego na liście odtwarzania. Następnie możesz podłączyć ESC do silników i wreszcie zakończyliśmy budowę drona.

Następne oprogramowanie, więc dalej!

Krok 3: Konfiguracja Raspberry Pi i GCS (Mission Planner)

Ponownie, możesz znaleźć bardziej szczegółowe instrukcje na liście odtwarzania z ostatniego kroku. Jednak prawdopodobnie wiesz, jak skonfigurować RasPi. Ale tym razem robimy to bez głowy. Użyj Balena Etcher, aby wypalić system operacyjny ze strony internetowej Navio OS na kartę MicroSD. Po podłączeniu do komputera przejdź do suplikanta wpa za pomocą notatnika ++. Następnie wprowadź identyfikator SSid i hasło, aby Raspberry Pi połączyć się z Wi-Fi. Następnie musisz dodać plik o nazwie SSH. Może to być za pomocą wiersza poleceń lub innej metody. Teraz możemy SSH. Możesz użyć wiersza polecenia lub Putty. Użyłem wiersza poleceń i wpisałem "ssh pi@navio", aby się połączyć w moim przypadku, lub możesz znaleźć adres IP i ssh w ten sposób. Po połączeniu użyj tego filmu, aby skonfigurować i skonfigurować Navio. Aby skonfigurować telemetrię, musisz najpierw dokonać edycji na Raspberry Pi. Postępuj zgodnie z tym, aby dokonać edycji i spróbuj połączyć się z Mission Planner. Jeśli telemetria nie działa, możesz cofnąć edycję i połączyć się za pomocą połączenia UDB, wprowadzając adres IP GCS (naziemnej stacji kontroli, takiej jak laptop). Po połączeniu z Mission Planner możesz użyć kreatora konfiguracji, aby skalibrować wszystkie części drona. Jeśli potrzebujesz pomocy, zapoznaj się ponownie z listą odtwarzania. Zwykle podczas konfiguracji prawie zawsze pojawia się błąd. Rozwiązywanie problemów to jedna z największych części tego projektu. Naprawdę nie mogę ci pomóc, ponieważ nie znam twoich błędów, ale większość błędów można naprawić za pomocą Internetu. Gdy wszystko jest gotowe, dron jest gotowy do lotu! Możesz skonfigurować kontroler RC i tryby lotu w Mission Planner. Spróbuj przytrzymać lewy drążek w prawym dolnym rogu przez pięć sekund, aby uzbroić drona. Nie polecam latania bez zapoznania się z samouczkiem, ponieważ dron jest bardzo delikatny i łatwy do złamania. Dla mnie przy pierwszym locie zepsułem montaż GPS i kilka śmigieł. Jeśli nie potrzebujesz sterowania głosowego, możesz zatrzymać się tutaj. Aby dowiedzieć się więcej o AWS i programowaniu drona, kontynuuj!

Krok 4: Programowanie drona do latania z Pythonem

Zanim przejdziemy do AWS, powinniśmy najpierw zrozumieć, jak zaprogramować drona do latania. Po wstępnej konfiguracji integracja sterowania głosowego nie powinna być zbyt trudna. Pierwszą rzeczą, jaką możemy spróbować zrozumieć, jest wykonanie prostego programu startu i lądowania. Po skonfigurowaniu Raspberry Pi możemy ponownie SSH do niego. Możesz ponownie spojrzeć na playlistę lub postępować zgodnie z moją instrukcją.

1. Najpierw pobierzmy kod źródłowy ArduPilot z katalogu na Raspberry Pi

mkdir src

Następnie pobierz pliki z GitHub za pomocą git clone

git clone -b Copter-3.6.11

Przejdźmy teraz do /src/ardupilot

cd src

cd ardupilot

Teraz zainicjujmy pliki źródłowe

aktualizacja submodułu git --init --recursive

2. Następnie musimy skompilować firmware na Raspberry Pi

Pamiętaj, aby przejść do /src/ardupilot/ za pomocą cd przed wykonaniem kolejnych kroków

Następnie, aby skonfigurować specjalnie do Navio za pomocą

./waf configure --board=navio2

Następnie możesz skompilować za pomocą

./waf --targets bin/arducopter

3. Możemy teraz zainstalować kod źródłowy w Navio

Najpierw przejdźmy do właściwego katalogu.

cd/etc/systemd/system

Następnie edytuj plik

sudo vi arducopter.service

Tam, gdzie jest napisane ExecStart, wstaw następujące zamiast tego, co już tam jest

ExecStart=/bin/sh -c "/home/pi/src/arducopter/build/navio2/bin/arducopter ${ARDUPILOT_OPTS}"

Teraz, aby wprowadzić kod źródłowy ardupilota do działania, możemy użyć

sudo systemctl demon-reload

Następnie możemy ponownie uruchomić za pomocą

sudo systemctl restart arducoptera

W ostatnim kroku w końcu zakończyliśmy konfigurowanie ArduPilota na naszym dronie

4. Instalacja DroneKit

DroneKit to oprogramowanie, którego użyjemy do zaprogramowania drona do latania. Aby zrozumieć część kodu, możesz znaleźć dokumentację tutaj. Najpierw musimy zainstalować pakiet na naszym dronie przed napisaniem skryptu.

Możemy zainstalować pakiet Pythona za pomocą

pip zainstaluj dronekit==2.9.1

Może to być najnowsza wersja, ale nie musi, ale jest to ta, z której korzystałem, więc mogę pomóc w rozwiązywaniu problemów.

Aby sprawdzić, czy jest zainstalowany, możemy zrobić

zamrożenie pipsa | grep dronekit

Teraz jesteśmy w końcu gotowi do stworzenia naszego pierwszego skryptu Pythona

5. start_i_land.py

OSTRZEŻENIE! Proponuję ustalić podstawowe zrozumienie Pythona, abyś mógł nauczyć się i zrozumieć kod. Jeśli chcesz samodzielnie napisać program, śledź ten film.

##Najpierw nie twórzmy katalogu do przechowywania tego kodu

cd dk ##Jeśli chcesz zrobić to sam, użyj vi takeoff_and_land.py ##, aby stworzyć program

W przeciwnym razie możesz spojrzeć lub użyć załączonego pliku i użyć protokołu przesyłania plików. Później możemy wypróbować ten program. Najpierw wyjaśnij, że jest to plik Pythona, którego musimy użyć

chmod +x start_and_land.py

Następnie spróbuj użyć następującego kodu do uruchomienia

python start_and_land.py --podłącz 127.0.0.1:14550

Za pierwszym razem też mi się to nie udało. W przypadku przekroczenia limitu czasu łącza nie martw się, możesz coś zrobić. Otwórz kolejny monit i ssh. Możesz spróbować zainstalować coś zwanego mavproxy i spróbować go uruchomić. Następnie możesz uruchomić oba jednocześnie. Powinno to pomóc w podłączeniu drona. Gdy to zrobię, mam dla ciebie wyzwanie. Spróbuj dowiedzieć się, co robi inny program (set_velocity_body.py) i jak sprawić, by działał. Jeśli tak, dobra robota.

6. Dalej!

Teraz możemy wykorzystać tę wiedzę, aby sterować głosem naszego drona. Sterowanie dronem Alexa wykorzystuje wiele z tych funkcji i nie tylko. Powodzenia i dalej!

Krok 5: Używanie Amazon Alexa i Amazon Web Services do integracji sterowania głosowego

Ten krok jest jednym z mniej udokumentowanych. Oznacza to, że najtrudniejsze będzie rozwiązanie problemu. Samo doprowadzenie go do pracy zajęło mi około miesiąca, może więcej. Najważniejszą rzeczą tutaj jest cierpliwość. Ta funkcja, jeśli zostanie zaimplementowana w prawdziwym życiu, może zmienić życie. Możesz po prostu powiedzieć Alexie, żeby kupiła dla ciebie zakupy, zamiast iść sama. Wyobraź sobie, że! Więc bez zbędnych ceregieli przejdźmy do tego!

1. Rejestracja Raspberry Pi jako rzeczy w AWS IoT

Aby korzystać z Internetu Rzeczy (Internet of Things), potrzebujemy czegoś. Więc najpierw musimy zalogować się do AWS Console, aby korzystać z AWS IoT. Następnie przejdź do IoT Core. Tam powinieneś kliknąć Zarządzaj, a następnie utworzyć rzecz. Po dodaniu nazwy do połączenia potrzebujemy certyfikatu. Polecam kliknięcie certyfikacji One-click. Następnie po wyświetleniu ekranu certyfikatu pobierz każdy klucz, w tym główny urząd certyfikacji. Wtedy możesz iść i dokończyć tworzenie rzeczy. Następnie musimy stworzyć politykę. Wróć do IoT Core. Następnie kliknij bezpieczne i kliknij zasady. Następnie naciśnij Utwórz politykę. Następnie możesz utworzyć nazwę i dodać zasoby. Pod akcją wpisz iot* i wpisz * pod zasóbem i naciśnij zezwól na efekt. Następnie wróć do swojej rzeczy i przejdź do swojego certyfikatu. W tym miejscu kliknij zasady. Następnie możesz dołączyć swoją polisę i wszystko gotowe!

2. Konfigurowanie kodu na Raspberry Pi i interakcja z IoT

W tej części będziesz potrzebować klienta SFTP (użyłem WinSCP) do przesyłania plików. Po połączeniu się z naszym Raspberry Pi będziemy musieli mieć pod ręką klucze certyfikatu. Musisz przenieść pliki kluczy do Raspberry Pi. Powinieneś także pip zainstalować AWSIoTPythonSDK na Raspberry Pi. Następnie przejdź do katalogu dk na Raspberry Pi. Używasz pliku Alexa Drone Control, który podałem do komunikacji z IoT. Aby użyć tego pliku, użyłem skryptu powłoki do uruchomienia. Pokażę poniższy kod, ponieważ z jakiegoś powodu nie mogę przesłać pliku. Jeśli program nie odbiera wiadomości z AWS IoT podczas testowania, nie martw się! To może być moja wina, ponieważ plik kontrolny drona Alexa może nie pasować do twojej rzeczy. Aby to naprawić, wróć do AWS IoT i naciśnij nauka na lewym panelu. Postępuj zgodnie z instrukcjami i może być konieczne ponowne uruchomienie. Przepraszam za to. Gdy Twój IoT zacznie pracować z programem na RasPi, możesz zintegrować kod dronekita z podanego przeze mnie pliku Alexa Drone Control. Następnie użyj skryptu Shell, który podałem wraz z certyfikatami i Rest API Endpoint z IoT.

# zatrzymaj skrypt na błędach -e # Sprawdź, czy istnieje plik głównego CA, pobierz jeśli nie, jeśli [! -f./root-CA.crt]; then printf "\nPobieranie certyfikatu AWS IoT Root CA z AWS…\n" curl https://www.amazontrust.com/repository/AmazonRoot…> > root-CA.crt fi # zainstaluj AWS Device SDK for Python, jeśli nie jest jeszcze zainstalowany Jeśli [! -d./aws-iot-device-sdk-python]; następnie printf "\nInstalowanie AWS SDK…\n" git clone https://www.amazontrust.com/repository/AmazonRoot…> pushd aws-iot-device-sdk-python python setup.py install popd fi

# uruchom przykładową aplikację pub/sub przy użyciu certyfikatów pobranych w pakiecie

printf "\nUruchamianie przykładowej aplikacji pub/sub…\n" python dk/AlexaDroneControl.py --connect 127.0.0.1:14550 -e "Twój IoT ARN" -r root-CA.crt -c PiGroundStation01.cert.pem -k PiGroundStation01.klucz.prywatny

To nie zadziała dla was wszystkich, ponieważ imiona są różne. Zamiast kluczy, których użyłem, zastąp ich nazwami kluczy podczas przesyłania pliku. Pamiętaj, aby wyjść z dk przed przesłaniem pliku! To powinno być na razie wszystko, co musisz zrobić.

3. Budowanie umiejętności Alexa

Ten krok wydaje się o wiele trudniejszy niż jest w rzeczywistości. Najpierw musimy zalogować się do konsoli Alexa Developer. Następnie po prostu naciśnij Stwórz umiejętność. Kiedy prosi o wybranie modelu dla twoich umiejętności, po prostu naciśnij custom. Gdy poprosi o wybór metody, kliknij zaprowiantuj własną. Możesz go nazwać, jak chcesz. Żaden szablon nie jest wymagany, więc wybierz zacznij od zera. Następnie, po utworzeniu umiejętności, powinieneś pojawić się na ekranie Konstruktora umiejętności z listą kontrolną po prawej stronie. Od tego momentu możemy zacząć budować nasze umiejętności. Pierwsza na liście kontrolnej jest nazwa wywołania. To właśnie powiesz Alexie, aby przywołała twoje umiejętności. Dla mnie po prostu wpisałem moją inwokację jako dron. Teraz możemy przejść do naszych intencji, wypowiedzi i slotów. Tutaj możesz wydawać polecenia dla drona, takie jak wchodzenie o 1 metr w górę lub w prawo lub w dół. Mój na razie działa tylko na jednym metrze. Możesz kliknąć Edytor JSON na dole lewego panelu. Następnie możesz wkleić do niego następujący kod.

{ "interactionModel": { "languageModel": { "invocationName": "dron", "intents": [{ "name": "AMAZON. FallbackIntent", "samples": }, { "name": "AMAZON. CancelIntent", "samples": }, { "name": "AMAZON. HelpIntent", "samples": }, { "name": "AMAZON. StopIntent", "samples": }, { "name": "AMAZON. NavigateHomeIntent", "samples": }, { "name": "GoIntent", "slots": [{ "name": "Kierunek", "type": "Kierunek" }, { "name": "Distance", "type": "AMAZON. NUMBER" }, { "name": "Unit", "type": "Unit" }], "samples": ["Jedź {Kierunek} {Odległość} {Jednostka}", "Jedź {Odległość} {Jednostka} {Kierunek}"] }, { "name": "CommandIntent", "slots": [{ "name": "Zadanie", "type": "Zadanie" }], "samples": ["Pokaż drona do {Zadanie}"] }, { "name": "TurnIntent", "slots": [{ "name": "Kierunek", "type": " Kierunek" }, { "name": "Obrót", "type": "AMAZON. NUMBER" }], "samples": ["Skręt {Kierunek} {Obrót} stopni"] }], "types": [{ "nazwa": "Kierunek", "wartości": [{ "nazwa": { "wartość": "Prosto", "synonimy": ["Do przodu ards", "Do przodu"] } }, { "name": { "value": "Wstecz", "synonimy": ["Wstecz", "Wstecz"] } }, { "name": { "value": "W prawo" } }, { "name": { "value": "W lewo" } }, { "name": { "value": "Down" } }, { "name": { "value": "Up " } }] }, { "nazwa": "Jednostka", "wartości": [{ "nazwa": { "wartość": "Mierniki", "synonimy": ["Licznik"] } }, { "nazwa": { "value": "Jards", "synonyms": ["Yard"] } }, { "name": { "value": "Feet", "synonyms": ["Stopa"] } }] }, { "name": "Zadanie", "values": [{ "name": { "value": "Land" } }, { "name": { "value": "Hold" } }, { "name": { "value": "Pobyt" } }, { "name": { "value": "RTL", "synonimy": ["Powrót do uruchomienia"] } }] }] } } }

Po wklejeniu kodu do edytora JSON możesz kliknąć trzeci krok listy kontrolnej, a zbuduje on dla Ciebie model interakcji. Na tym etapie na razie skończysz. Na razie możesz zostawić puste miejsce w punkcie końcowym!

Krok 4: Budowanie funkcji lambda

Teraz ten krok jest tym, który będziesz musiał sam wymyślić. Powiem ci, jak podłączyć go do umiejętności Alexa, ale będziesz musiał sam to zakodować. Więc najpierw przejdź do konsoli zarządzania AWS. Następnie przejdź do Lambdy. Następnie możesz utworzyć funkcję, nadając jej dowolną nazwę. Upewnij się, że napisałeś go od zera i skonfiguruj środowisko wykonawcze w dowolnym języku programowania. Użyłem Node.js. Aby dodać umiejętność Alexa, dodaj wyzwalacz i wybierz zestaw umiejętności Alexa (ASK). Skopiuj swój Lambda ARN i wróć do umiejętności Alexa. Teraz przejdź do punktu końcowego. Możesz wkleić swój ARN, zapisać i zbudować nowy model. Następnie weź identyfikator umiejętności Alexa i wklej go w sekcji wyzwalacza, gdzie prosi cię o Lambda. Następnie przewiń w dół Lambdę i znajdź podstawowe ustawienia i ustaw limit czasu 10 sekund. Teraz do Ciebie należy ustalenie kodu. Wskazówki znajdziesz na poniższych stronach internetowych.

github.com/aws/aws-iot-device-sdk-js

www.hackster.io/veggiebenz/voice-controlle…

i możesz użyć pliku, który załączyłem, ale jest niekompletny i nie zadziała.

/** * Kontroluj swój quadkopter APM / Pixhawk za pomocą głosu, używając Amazon Alexa, Lambda, 2lemetry MQTT.*/ var awsIot = require('aws-iot-device-sdk'); var config = wymagaj("./config"); var deviceName = "EchoDroneControl"; // to urządzenie jest tak naprawdę kontrolerem var mqtt_config = { "keyPath": config.privateKey, "certPath": config.certificate, "caPath": config.rootCA, "host": config.host, "port": 8883, "clientId": "Lambda-" + deviceName, //+ "-Lambda-" + (nowy Date().getTime()), "region":"us-east-1", "debug":true }; zmienna ctx = null; var klient = null; // Kieruj przychodzące żądanie na podstawie typu (LaunchRequest, IntentRequest itp.) Treść JSON żądania jest podana w parametrze zdarzenia. exports.handler = function (zdarzenie, kontekst) { try { console.log("event.session.application.applicationId=" + event.session.application.applicationId); ctx = kontekst; if (event.session.application.applicationId !== app_id) { ctx.fail("Nieprawidłowy identyfikator aplikacji"); } klient = awsIot.device(mqtt_config); client.on("connect", function(){ console.log("Połączono z AWS IoT"); // callback(); });

if (wydarzenie.sesja.nowa) {

onSessionStarted({requestId: event.request.requestId}, event.session); } if (event.request.type === "LaunchRequest") { onLaunch(event.request, event.session); } else if (event.request.type === "IntentRequest") { onIntent(event.request, event.session); } else if (event.request.type === "SessionEndedRequest") { onSessionEnded(event.request, event.session); ctx.sukces(); } } catch (e) { console.log("WYJĄTEK w handler'u: " + e); ctx.fail("Wyjątek: " + e); } }; /** * Wywoływane po rozpoczęciu sesji. */ function onSessionStarted(sessionStartedRequest, session) { console.log("onSessionStarted requestId=" + sessionStartedRequest.requestId + ", sessionId=" + session.sessionId); }

/**

* Wywoływane, gdy użytkownik uruchamia umiejętność bez określenia, czego chce. */ function onLaunch(launchRequest, session, callback) { console.log("onLaunch requestId=" + launchRequest.requestId + ", sessionId=" + session.sessionId); // Wyślij do uruchomienia umiejętności. getWelcomeResponse(wywołanie zwrotne); } /** * Wywoływane, gdy użytkownik określi zamiar dla tej umiejętności. */ function onIntent(intentRequest, session) { //, callback) { console.log("onIntent requestId=" + intentRequest.requestId + ", sessionId=" + session.sessionId); var intent = intentRequest.intent, intentName = intentRequest.intent.name; console.log("REQUEST to string=" + JSON.stringify(intentRequest)); var callback = null; // Wyślij do programów obsługi intencji umiejętności if ("GoIntent" === intentName) { doGoIntent(intent, session); } else if ("CommandIntent" === intentName) { doCommandIntent(zamiar, sesja); } else if ("TurnIntent" === intentName) { doTurnIntent(zamiar, sesja); } else if ("HelpIntent" === intentName) { getWelcomeResponse(); } else { throw "Nieprawidłowy zamiar"; } } /** * Wywoływane, gdy użytkownik kończy sesję. * Nie jest wywoływana, gdy umiejętność powraca shouldEndSession=true. */ function onSessionEnded(sessionEndedRequest, session) { console.log("onSessionEnded requestId=" + sessionEndedRequest.requestId + ", sessionId=" + session.sessionId); // Dodaj tutaj logikę czyszczenia } // --------------- Funkcje kontrolujące zachowanie umiejętności -------------------- --- function getWelcomeResponse() { // Jeśli chcielibyśmy zainicjować sesję tak, aby miała jakieś atrybuty, moglibyśmy dodać je tutaj. var sessionAttributes = {}; var cardTitle = "Witamy"; var speechOutput = "Witamy w KONTROLI DRONÓW."; // DO ZROBIENIA: czy dron jest online czy offline? Jeśli jest online, czy jest UZBROJONY? var repromptText = "Dron gotowy do polecenia."; var shouldEndSession = false; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } /** * obsługuje intencję GO. */ function doGoIntent(intent, session, callback) { // var cardTitle = "Dron GO…"; var repromptText = ""; var sessionAttributes = {}; var shouldEndSession = false; var speechOutput = ""; var direction = intent.slots. Direction.value; var odległość = intent.slots. Distance.value; var jednostka = intent.slots. Unit.value; var validDirections = ["do przodu", "do przodu", "do tyłu", "wstecz", "w prawo", "w lewo", "w górę", "w dół", "na wprost", "naprzód", "na wprost"]; var validUnits = ["stopa", "stopy", "metr", "metry", "jard", "jardy"]; repromptText = "Powiedz mi, jak daleko mam iść iw jakim kierunku."; var niepowodzenie = fałsz; // sprawdź poprawność danych wejściowych if (!(parseInt(distance) >= 1)) { speechOutput = "Nie mogłem zrozumieć odległości, którą mam przebyć."; niepowodzenie = prawda; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } if (validDirections.indexOf(direction) == -1) { speechOutput = "Nie mogłem zrozumieć kierunku, w którym mam podróżować."; niepowodzenie = prawda; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } if (validUnits.indexOf(unit) == -1) { speechOutput = "Nie mogłem zrozumieć jednostki, którą mam podróżować."; niepowodzenie = prawda; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } if (!fail) { var cardTitle = "Dron leci " + kierunek + " " + odległość + " " + jednostka; speechOutput = "Jadę " + kierunek + " " + odległość + " " + jednostka; mqttPublish(intent, sessionAttributes, cardTitle, speechOutput, repromptText, shouldEndSession); } }

function doCommandIntent(zamiar, sesja, wywołanie zwrotne) {

// var cardTitle = "POLECENIE drona…"; var tekst monitu = null; var sessionAttributes = {}; var shouldEndSession = false; var speechOutput = ""; repromptText = "Powiedz mi, jakie jest polecenie dla drona."; var zadanie = intent.slots. Task.value; var validTasks = ["uruchom", "ląd", "r. t. l.", "przytrzymaj", "zostań", "stop", "powrót do uruchomienia", "przerwij"]; if (validTasks.indexOf(task) == -1) { speechOutput = "Nie mogłem zrozumieć polecenia."; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } else { var cardTitle = "Wykonywanie polecenia drona" + zadanie; speechOutput = "Wykonywanie polecenia " + zadanie; mqttPublish(intent, sessionAttributes, cardTitle, speechOutput, repromptText, shouldEndSession); } }

function doTurnIntent(zamiar, sesja, wywołanie zwrotne) {

// var cardTitle = "Skręt drona…"; var tekst monitu = null; var sessionAttributes = {}; var shouldEndSession = false; var speechOutput = ""; repromptText = "Powiedz mi, jak chcesz obrócić drona."; var direction = intent.slots. Direction.value; var validDirections = ["prawo", "lewo", "wokół"]; if (validDirections.indexOf(direction) == -1) { speechOutput = "Nie mogłem zrozumieć kierunku skrętu."; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } else { var cardTitle = "Skręt drona " + kierunek; speechOutput = "Obracanie " + kierunek; mqttPublish(intent, sessionAttributes, cardTitle, speechOutput, repromptText, shouldEndSession); } }

funkcja mqttPublish(intent, sessionAttributes, cardTitle, speechOutput, repromptText, shouldEndSession)

{ var strIntent = JSON.stringify(zamiar); console.log("mqttPublish: INTENT text = " + strIntent); // client.publish("ikw1zr46p50f81z/dron/echo", strIntent, false); client.publish(config.topic, strIntent, false); klient.end(); client.on("zamknij", (function() { console.log("MQTT KLIENT ZAMKNIJ - uważa, że to zrobione, pomyślnie. "); ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); })); client.on("error", (function (err, przyznane) { console.log("BŁĄD KLIENTA MQTT!! " + błąd; })); }

// --------------- Pomocnicy tworzący wszystkie odpowiedzi -----------------------

function buildSpeechletResponse(title, output, repromptText, shouldEndSession) { return { outputSpeech: { type: "PlainText", text: output }, card: { type: "Simple", title: title, content: output }, reprompt: { outputSpeech: { type: "PlainText", text: repromptText } }, shouldEndSession: shouldEndSession } } function buildResponse(sessionAttributes, speechletResponse) { return { version: "1.0", sessionAttributes: sessionAttributes, odpowiedź: speechletResponse } }