Drone Raspberry Pi a controllo vocale Alexa con IoT e AWS: 6 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Ciao! Mi chiamo Armaan. Sono un ragazzo di 13 anni del Massachusetts. Questo tutorial mostra, come puoi dedurre dal titolo, come costruire un Raspberry Pi Drone. Questo prototipo dimostra come si stanno evolvendo i droni e anche quanto grande ruolo potrebbero svolgere in futuro. Posso sicuramente vedermi svegliarmi tra 10 anni e chiedere a un drone di prepararmi la colazione. Il drone utilizza Amazon Alexa, Amazon Web Services, IoT (Internet of Things) e, soprattutto, un Raspberry Pi per funzionare. Ha lo scopo di dimostrare e informare sui droni e su come stanno migliorando ogni giorno. Spero che tu abbia successo e impari a conoscere i droni nel processo. Buona fortuna e grazie per la lettura. -Armaan

Forniture

Per costruire il prototipo ci sono varie esigenze hardware e software. Ho utilizzato un tutorial online di The Drone Dojo per costruire il drone e ho integrato le tecnologie elencate. Per il drone puoi trovare l'elenco delle parti proprio qui:

Elenco delle parti del drone

Requisiti software:

• Servizi Web Amazon
• Un computer portatile
• Software per la pianificazione delle missioni
• Acquaforte Balena
• Scheda MicroSD con file Raspbian trovata qui
• Amazon Alexa, fisico o virtuale

Passaggio 1: raccolta e comprensione delle parti

Ogni parte menzionata nella lista di fornitura è necessaria, così come una chiara comprensione di ogni parte. Puoi trovare le parti online e una volta raccolte, continua a leggere. Una playlist di The Drone Dojo per una piena comprensione delle parti può essere trovata qui. Una spiegazione di 4 minuti sul mio canale youtube può essere trovata qui. Quando si tratta di droni, le uniche parti, nonostante ciò che la maggior parte delle persone pensa, non sono solo motori ed eliche. Di seguito sono riportati gli scopi di base di ciascuna parte.

Il Raspberry Pi con Emlid Navio2

Questa parte è praticamente un processore centrale e il punto principale del drone. Il Raspberry Pi agisce come la CPU di un computer che invia comandi al Navio2 da eseguire tramite PWM (segnali di modulazione della larghezza di impulso) ad altre parti del drone

2. Gli ESC (regolatori elettronici di velocità)

Queste parti gialle si trovano sotto il telaio. Sono 4 collegati al Navio, uno per ogni motore. Dopo aver ricevuto i segnali PWM, ruotano i motori e iniziano il volo.

3. Motori

I motori non hanno bisogno di troppe spiegazioni perché probabilmente li conosci. Ruotano e fanno girare le eliche per creare spinta.

4. Eliche

Le eliche creano la spinta per far volare il drone. Girano nella stessa direzione dei motori per sollevare il veicolo.

5. La batteria e il modulo di alimentazione

La batteria LiPo alimenta l'intero drone attraverso il telaio utilizzando il modulo di alimentazione. Fornisce circa 15-20 minuti di volo e funge da fonte di alimentazione.

6. Il GPS

Il GPS comunica con i satelliti per determinare la posizione del drone. Determina altitudine, latitudine e longitudine. Può essere utilizzato per Geofencing, waypoint e anche per spostarsi in determinate posizioni o direzioni.

7. Il modulo di telemetria

Il modulo di telemetria collega il nostro drone ad una stazione di controllo a terra, nel nostro caso Mission Planner, da monitorare.

8. Il controller e il modulo RC insieme all'encoder PPM

Il controller RC utilizza la radio per trasmettere segnali e comandi al modulo RC per pilotare manualmente il drone. L'encoder PPM traduce questi segnali per l'elaborazione e l'esecuzione di Navio + RPI.

9. La cornice

Questa cornice rossa e bianca funge da base o piattaforma per le altre parti da posizionare. Il telaio è aerodinamico e leggero, quindi perfetto per il nostro drone.

Ora con la conoscenza di ogni parte, possiamo finalmente costruire il drone! Avanti al passo successivo!

Passaggio 2: assemblaggio del drone

Questo passaggio è probabilmente il più difficile in termini di sforzo fisico. Raccomando di avere un'altra persona per l'aiuto o di provare a usare la mano d'aiuto nell'elenco delle parti. Il processo è troppo lungo per essere dimostrato qui, quindi fornirò un altro link che ho usato da The Drone Dojo.

Costruire un drone Raspberry Pi

Ancora una volta, poiché non entrerò nei dettagli, evidenzierò solo le basi di ogni passaggio.

1. Organizza le tue forniture - Raccogli i nostri materiali e assicurati che siano facilmente accessibili

2. Pianifica la tua costruzione: organizza le tue parti sul telaio per creare un progetto di ciò che costruirai

3. Lavoro di saldatura - Questo è il lavoro che è un po' difficile da fare da soli. È necessario saldare i connettori a proiettile d'oro forniti con i motori agli ESC. Successivamente, è necessario prendere la parte inferiore del telaio e saldare gli ESC al telaio inferiore o alla scheda di distribuzione dell'alimentazione. Il modulo batteria sarà anche saldato sulla scheda di distribuzione dell'alimentazione

4. Installazione del telaio - È quindi necessario avvitare la parte superiore del telaio insieme ai bracci. Puoi quindi attaccare il Raspberry Pi sopra come preferisci. (Ho usato del nastro adesivo). Quindi puoi fissare gli ESC alle braccia con fascette. Ora abbiamo quasi finito.

5. Associazione del controller RC al ricevitore - Prova a seguire le istruzioni nella playlist sopra per associare il controller RC utilizzando un ESC.

6. Finalizzazione delle parti sul telaio - Nastro adesivo o cinghia sul modulo di telemetria sul telaio. Nastro adesivo anche l'encoder PPM su un braccio. Ora puoi collegare gli ESC e l'encoder PPM a Navio.

7. Supporto GPS + batteria - Assemblare il supporto GPS con le varie viti e pezzi. Usando le fascette, attacca il GPS al telaio. Non ho necessariamente usato il supporto GPS a causa della sua fragilità, ma dipende da te. Successivamente, è possibile inserire la batteria tra Power Dist. Tavola. Ho anche legato e fissato con nastro adesivo il modulo di alimentazione al telaio. Ora il tuo hardware è praticamente configurato. Ora per la parte che stavamo aspettando!

8. Installazione delle eliche!!! - È possibile serrare le eliche utilizzando la tabella indicata nella playlist. Quindi puoi collegare gli ESC ai motori e abbiamo finalmente finito di costruire il drone.

Il software è il prossimo, quindi avanti!

Passaggio 3: configurazione di Raspberry Pi e GCS (Mission Planner)

Di nuovo, puoi trovare istruzioni più dettagliate nella playlist dall'ultimo passaggio. Tuttavia, probabilmente sai come configurare RasPi. Ma questa volta, lo facciamo senza testa. Usa Balena Etcher per masterizzare il sistema operativo dal sito Web Navio OS nella scheda MicroSD. Mentre è collegato al tuo computer, vai nel supplicant wpa usando notepad ++. Successivamente, inserisci l'ssid e la password per il Raspberry Pi per connettersi al tuo WiFi. Quindi devi aggiungere un file chiamato SSH. Questo può avvenire tramite la riga di comando o un altro metodo. Ora possiamo SSH. Puoi usare il prompt dei comandi o Putty. Ho usato il prompt dei comandi e ho digitato "ssh pi@navio" per connettermi nel mio caso, oppure puoi trovare l'indirizzo IP e ssh in quel modo. Dopo la connessione, usa questo video per impostare e configurare Navio. Per impostare la telemetria devi prima fare una modifica sul Raspberry Pi. Segui questo per apportare la modifica e prova a connetterti a Mission Planner. Se la telemetria non funziona, puoi annullare la modifica e connetterti utilizzando una connessione UDB inserendo il tuo IP GCS (Ground Control Station come laptop). Una volta connesso a Mission Planner, puoi utilizzare la procedura guidata di configurazione per calibrare tutte le parti del drone. Se hai bisogno di aiuto fai nuovamente riferimento alla playlist. Di solito, ogni volta che si imposta, c'è quasi sempre un errore. La risoluzione dei problemi è una delle parti più importanti di questo progetto. Non posso davvero aiutarti perché non sono a conoscenza dei tuoi errori, ma la maggior parte degli errori può essere risolta con l'aiuto di Internet. Dopo che tutto è pronto, il drone è pronto per volare! Puoi impostare il controller RC e le modalità di volo su Mission Planner. Prova a tenere la levetta sinistra in basso a destra per cinque secondi per armare il drone. Non consiglio di volare senza guardare un tutorial perché il drone è molto fragile e facile da rompere. Per me, la prima volta che l'ho volato, ho rotto il supporto GPS e alcune eliche. Se non hai bisogno del controllo vocale, puoi fermarti qui. Per conoscere AWS e programmare il drone continua!

Passaggio 4: programmare il drone per volare con Python

Prima di entrare in AWS, dovremmo prima capire come programmare il drone per volare. Dopo la configurazione iniziale, l'integrazione del controllo vocale non dovrebbe essere troppo difficile. La prima cosa che possiamo provare a farcene un'idea è fare un semplice programma di decollo e atterraggio. Dopo aver configurato il Raspberry Pi, possiamo accedervi nuovamente tramite SSH. Puoi guardare di nuovo la playlist o seguire le mie istruzioni.

1. Per prima cosa scarichiamo il codice sorgente di ArduPilot in una directory sul Raspberry Pi

mkdir src

Quindi, ottieni i file da GitHub usando git clone

git clone -b Copter-3.6.11

Ora passiamo a /src/ardupilot

cd src

cd ardupilot

Ora inizializziamo i file sorgente

aggiornamento del sottomodulo git --init --recursive

2. Successivamente, dobbiamo compilare il firmware sul Raspberry Pi

Assicurati di accedere a /src/ardupilot/ con cd prima di eseguire i passaggi successivi

Quindi per cofigurare specificamente su Navio usando

./waf configure --board=navio2

Quindi puoi compilare con

./waf --targets bin/arducopter

3. Ora possiamo installare il codice sorgente su Navio

Per prima cosa navighiamo nella directory giusta.

cd/etc/systemd/system

Quindi modifica il file

sudo vi arducoppter.service

Dove dice ExecStart, inserisci quanto segue invece di quello che c'è già

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

Ora, per mettere in azione il codice sorgente di ardupilot, possiamo usare

sudo systemctl demone-reload

Allora possiamo ripartire con

sudo systemctl riavvia arducoppter

Con l'ultimo passaggio, abbiamo finalmente finito di configurare ArduPilot sul nostro drone

4. Installazione di DroneKit

DroneKit è il software che utilizzeremo per programmare il volo del drone. Per capire parte del codice puoi trovare la documentazione qui. Per prima cosa dobbiamo installare il pacchetto sul nostro drone prima di scrivere uno script.

Possiamo installare il pacchetto Python con

pip install dronekit==2.9.1

Questa potrebbe essere o non essere la versione più recente, ma è quella che ho usato io così posso aiutare con la risoluzione dei problemi.

Per verificare se installato, possiamo fare un

pip congelare | grep dronekit

Ora siamo finalmente pronti per creare il nostro primo script Python

5. takeoff_and_land.py

AVVERTIMENTO! Suggerisco di stabilire una conoscenza di base di Python, in modo da poter imparare e comprendere il codice. Se vuoi scrivere tu stesso il programma segui questo video.

##Prima creiamo una directory per memorizzare questo codice

cd dk ##Se vuoi farlo da solo, usa vi takeoff_and_land.py ##per creare un programma

Altrimenti, puoi dare un'occhiata o utilizzare il file allegato e utilizzare un protocollo di trasferimento file. Possiamo provare questo programma in seguito. Prima di tutto chiarire che è un file python che dobbiamo usare

chmod +x takeoff_and_land.py

Quindi, per provare a utilizzare il seguente codice per eseguire

python takeoff_and_land.py --connect 127.0.0.1:14550

Anche a me la prima volta non ha funzionato. Se c'è un timeout del collegamento, non preoccuparti, c'è qualcosa che puoi fare. Apri un altro prompt e ssh. Puoi provare a installare qualcosa chiamato mavproxy e provare a eseguirlo. Successivamente, puoi eseguire entrambi contemporaneamente. Questo dovrebbe aiutare a connettere il drone. Fatto ciò, ho una sfida per te. Prova a capire cosa fa l'altro programma (set_velocity_body.py) e come farlo funzionare. Se lo fai, buon lavoro.

6. Avanti!

Ora possiamo usare questa conoscenza per controllare la voce del nostro drone. Il controllo del drone di Alexa utilizza molte di queste funzionalità e altro ancora. Buona fortuna e avanti!

Passaggio 5: utilizzo di Amazon Alexa e Amazon Web Services per integrare il controllo vocale

Questo passaggio è uno dei meno documentati. Ciò significa che sarà il più difficile da risolvere. Solo per farlo funzionare mi ci è voluto circa un mese, forse di più. La cosa più importante qui è essere pazienti. Questa funzione, se implementata nella vita reale, può cambiare la vita. Puoi semplicemente dire ad Alexa di farti la spesa invece di andare da solo. Immaginalo! Quindi, senza ulteriori indugi, entriamo nel merito!

1. Registrazione del Raspberry Pi come una cosa su AWS IoT

Per utilizzare IoT (Internet of Things), abbiamo bisogno di una cosa. Quindi dobbiamo prima accedere alla Console AWS per utilizzare AWS IoT. Quindi vai a IoT Core. Una volta lì, dovresti fare clic su Gestisci e quindi creare una cosa. Dopo aver aggiunto un nome, per la connessione, abbiamo bisogno di un certificato. Consiglierei di fare clic su Certificazione con un clic. Quindi, dopo aver visto la schermata del certificato, assicurati di scaricare ogni singola chiave, inclusa la CA radice. Quindi puoi andare e finire la creazione della cosa. Quindi dobbiamo creare una politica. Torna all'IoT Core. Quindi fare clic su Proteggi e fare clic su criteri. Quindi premi crea criterio. È quindi possibile creare un nome e aggiungere risorse. Sotto azione, digita iot* e digita * sotto risorsa e premi consenti l'effetto. Quindi torna alla tua cosa e vai al tuo certificato. Una volta qui, fai clic su politiche. Puoi quindi allegare la tua polizza per la cosa ed è tutto pronto!

2. Configurazione del codice su Raspberry Pi e interazione con IoT

Per questa parte, avrai bisogno di un client SFTP (ho usato WinSCP) per il trasferimento di file. Al momento della connessione al nostro Raspberry Pi, avremo bisogno delle chiavi del certificato a portata di mano. Devi trasferire i file chiave sul Raspberry Pi. Dovresti anche installare pip AWSIoTPythonSDK sul Raspberry Pi. Quindi accedi alla directory dk sul Raspberry Pi. Utilizzi il file Alexa Drone Control che ho fornito per comunicare con IoT. Per utilizzare questo file ho utilizzato uno script Shell per l'avvio. Mostrerò il codice di seguito poiché non riesco a caricare il file per qualche motivo. Se il programma non riceve i messaggi da AWS IoT durante il test, non preoccuparti! Potrebbe essere colpa mia poiché il file di controllo del drone Alexa potrebbe non essere adatto alla tua cosa. Quindi, per risolverlo, torna ad AWS IoT e premi impara nel pannello di sinistra. Segui le istruzioni e potresti dover riavviare. Mi dispiace. Una volta che il tuo IoT inizia a funzionare con il programma sul RasPi, puoi integrare il codice dronekit dal file Alexa Drone Control che ho fornito. Successivamente, usa lo script Shell che ho fornito con i tuoi certificati e Rest API Endpoint da IoT.

# stop script on errorsset -e # Verifica se esiste un file CA root, in caso contrario scarica se [! -f./root-CA.crt]; quindi printf "\nDownload in corso AWS IoT Root CA certificate from AWS…\n" curl https://www.amazontrust.com/repository/AmazonRoot…> > root-CA.crt fi # install AWS Device SDK for Python se non è già installato Se [! -d./aws-iot-device-sdk-python]; quindi printf "\nInstalling AWS SDK…\n" git clone https://www.amazontrust.com/repository/AmazonRoot…> pushd aws-iot-device-sdk-python python setup.py install popd fi

# esegui l'app di esempio pub/sub utilizzando i certificati scaricati nel pacchetto

printf "\nEsecuzione dell'applicazione di esempio pub/sub…\n" python dk/AlexaDroneControl.py --connect 127.0.0.1:14550 -e "Your IoT ARN" -r root-CA.crt -c PiGroundStation01.cert.pem -k PiGroundStation01.chiave.privata

Questo non funzionerà per tutti voi perché i nomi sono diversi. Invece delle chiavi che ho usato sostituisci con i nomi delle tue chiavi quando trasferisci il file. Assicurati di uscire da dk prima di trasferire il file! Questo dovrebbe essere tutto ciò che devi fare per ora.

3. Costruisci la tua abilità Alexa

Questo passaggio sembra molto più difficile di quanto non sia in realtà. Innanzitutto, dobbiamo accedere alla console per sviluppatori Alexa. Quindi, premi semplicemente crea abilità. Quando ti viene chiesto di scegliere un modello per la tua abilità, premi su personalizzato. Quando ti viene chiesto di scegliere un metodo, seleziona il tuo provisioning. Puoi chiamarlo come vuoi. Non è richiesto alcun modello, quindi scegli di iniziare da zero. Successivamente, dopo aver creato la tua abilità, dovresti arrivare alla schermata del generatore di abilità con una lista di controllo sulla destra. Da qui, possiamo iniziare a costruire la nostra abilità. Il primo della lista di controllo è il nome di invocazione. Questo è ciò che dirai ad Alexa di invocare la tua abilità. Per me, ho appena messo il mio nome d'invocazione come drone. Ora possiamo andare ai nostri intenti, espressioni e slot. Qui puoi eseguire comandi per il drone come salire di 1 metro o andare a destra o in basso. Il mio funziona davvero solo con un metro per ora. Puoi fare clic sull'editor JSON nella parte inferiore del pannello di sinistra. Puoi quindi incollare il seguente codice al suo interno.

{ "interactionModel": { "languageModel": { "invocationName": "drone", "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": "Direction", "type": "Direction" }, { "nome": "Distanza", "tipo": "NUMERO. AMAZON" }, { "nome": "Unità", "tipo": "Unità" }], "campioni": ["Vai {Direzione} {Distanza} {Unità}", "Vai {Distanza} {Unità} {Direzione}"] }, { "name": "CommandIntent", "slots": [{ "name": "Task", "type": "Task" }], "samples": ["Comando drone su {Task}"] }, { "name": "TurnIntent", "slots": [{ "name": "Direction", "type": " Direzione" }, { "nome": "Rotazione", "tipo": "NUMERO. AMAZON" }], "campioni": ["Ruota {Direzione} {Rotazione} gradi"] }], "tipi": [{ "nome": "Direzione", "valori": [{ "nome": { "valore": "Diritto", "sinonimi": ["Avanti ards", "Avanti"] } }, { "nome": { "valore": "Indietro", "sinonimi": ["Indietro", "Indietro"] } }, { "nome": { "valore": "Destra" } }, { "nome": { "valore": "sinistra" } }, { "nome": { "valore": "Giù" } }, { "nome": { "valore": "Su " } }] }, { "nome": "Unità", "valori": [{ "nome": { "valore": "Metri", "sinonimi": ["Metro"] } }, { "nome": { "value": "Yards", "synonyms": ["Yard"] } }, { "name": { "value": "Feet", "synonyms": ["Piede"] } }] }, { "name": "Compito", "values": [{ "name": { "value": "Land" } }, { "name": { "value": "Hold" } }, { "name": { "valore": "Resta" } }, { "nome": { "valore": "RTL", "sinonimi": ["Torna al lancio"] } }] }] } } }

Dopo aver incollato il codice nell'editor JSON, puoi fare clic sul terzo passaggio dell'elenco di controllo e questo creerà il tuo modello di interazione per te. Con questo passaggio, per ora avrai finito. Puoi lasciare vuoto lo slot dell'endpoint per ora!

Passaggio 4: creazione della funzione Lambda

Ora, questo passaggio è quello che dovrai capire da solo. Ti dirò come collegarlo all'Alexa Skill, ma dovrai codificarlo tu stesso. Quindi, prima vai alla console di gestione AWS. Quindi, vai a Lambda. Puoi quindi creare una funzione nominandola come vuoi. Assicurati di crearlo da zero e crea il runtime con il linguaggio di programmazione che desideri. Ho usato Node.js. Per aggiungere l'Alexa Skill, aggiungi un trigger e seleziona Alexa Skills Kit (ASK). Copia il tuo Lambda ARN e torna all'Alexa Skill. Ora vai all'endpoint. Puoi incollare il tuo ARN, salvare e creare un nuovo modello. Quindi, prendi l'Alexa Skill ID e incollalo nella sezione trigger dove ti chiede sul Lambda. Quindi, scorri verso il basso su Lambda e trova le impostazioni di base e imposta il timeout di 10 secondi. Ora sta a te trovare il codice. Per suggerimenti, puoi visitare i siti Web di seguito.

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

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

e puoi usare il file che ho allegato, ma è incompleto e non funzionerà.

/** * Controlla il tuo quadricottero APM/Pixhawk con la tua voce, utilizzando Amazon Alexa, Lambda, 2lemetry MQTT.*/ var awsIot = require('aws-iot-device-sdk'); var config = require("./config"); var deviceName = "EchoDroneControl"; // questo dispositivo è in realtà il controller var mqtt_config = { "keyPath": config.privateKey, "certPath": config.certificate, "caPath": config.rootCA, "host": config.host, "port": 8883, "clientId": "Lambda-" + deviceName, //+ "-Lambda-" + (new Date().getTime()), "region":"us-east-1", "debug":true }; var ctx = nullo; var client = nullo; // Instrada la richiesta in entrata in base al tipo (LaunchRequest, IntentRequest, ecc.) Il corpo JSON della richiesta è fornito nel parametro dell'evento. exports.handler = function (event, context) { try { console.log("event.session.application.applicationId=" + event.session.application.applicationId); ctx = contesto; if (event.session.application.applicationId !== app_id) { ctx.fail("ID applicazione non valido"); } client = awsIot.device(mqtt_config); client.on("connect", function(){ console.log("Connected to AWS IoT"); // callback(); });

if (event.session.new) {

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.success(); } } catch (e) { console.log("ECCEZIONE nel gestore: " + e); ctx.fail("Eccezione: " + e); } }; /** * Chiamato all'avvio della sessione. */ function onSessionStarted(sessionStartedRequest, session) { console.log("onSessionStarted requestId=" + sessionStartedRequest.requestId + ", sessionId=" + session.sessionId); }

/**

* Chiamato quando l'utente avvia l'abilità senza specificare cosa vuole. */ function onLaunch(launchRequest, session, callback) { console.log("onLaunch requestId=" + launchRequest.requestId + ", sessionId=" + session.sessionId); // Invio al lancio della tua abilità. getWelcomeResponse(richiamata); } /** * Chiamato quando l'utente specifica un intento per questa abilità. */ 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; // Invia ai gestori di intent della tua abilità if ("GoIntent" === intentName) { doGoIntent(intent, session); } else if ("CommandIntent" === intentName) { doCommandIntent(intent, session); } else if ("TurnIntent" === intentName) { doTurnIntent(intento, sessione); } else if ("HelpIntent" === intentName) { getWelcomeResponse(); } else { throw "Intento non valido"; } } /** * Chiamato quando l'utente termina la sessione. * Non viene chiamato quando la competenza restituisce shouldEndSession=true. */ function onSessionEnded(sessionEndedRequest, session) { console.log("onSessionEnded requestId=" + sessionEndedRequest.requestId + ", sessionId=" + session.sessionId); // Aggiungi qui la logica di pulizia } // ------------------------------ Funzioni che controllano il comportamento dell'abilità -------------------- --- function getWelcomeResponse() { // Se volessimo inizializzare la sessione per avere degli attributi, potremmo aggiungerli qui. var sessionAttributes = {}; var cardTitle = "Benvenuto"; var speechOutput = "Benvenuto nel DRONE CONTROL. "; // TODO: il drone è online o offline? Se online, è ARMATO? var repromptText = "Drone pronto per il comando."; var dovrebbeEndSession = false; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } /** * gestisce l'intento GO. */ function doGoIntent(intent, session, callback) { // var cardTitle = "Drone GO…"; var repromptText = ""; var sessionAttributes = {}; var dovrebbeEndSession = false; var speechOutput = ""; var direzione = intent.slots. Direction.value; var distanza = intent.slots. Distance.value; var unit = intent.slots. Unit.value; var validDirections = ["avanti", "avanti", "indietro", "indietro", "destra", "sinistra", "su", "giù", "dritto", "avanti", "dritto"]; var validUnits = ["piede", "piedi", "metro", "metri", "iarda", "iarde"]; repromptText = "Dimmi quanto lontano devo andare e in quale direzione."; var fallire = falso; // convalida gli input if (!(parseInt(distance) >= 1)) { speechOutput = "Non sono riuscito a capire la distanza che vuoi che percorri. "; fallire = vero; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } if (validDirections.indexOf(direction) == -1) { speechOutput = "Non sono riuscito a capire la direzione in cui vuoi che viaggi. "; fallire = vero; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } if (validUnits.indexOf(unit) == -1) { speechOutput = "Non sono riuscito a capire l'unità in cui vuoi che viaggi. "; fallire = vero; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } if (!fail) { var cardTitle = "Drone in marcia " + direzione + " " + distanza + " " + unità; speechOutput = "Andando " + direzione + " " + distanza + " " + unità; mqttPublish(intent, sessionAttributes, cardTitle, speechOutput, repromptText, shouldEndSession); } }

function doCommandIntent(intent, session, callback) {

// var cardTitle = "COMANDO Drone…"; var repromptText = null; var sessionAttributes = {}; var dovrebbeEndSession = false; var speechOutput = ""; repromptText = "Dimmi qual è il comando per il drone. "; var task = intent.slots. Task.value; var validTasks = ["launch", "land", "r. t. l.", "hold", "stay", "stop", "return to launch", "abort"]; if (validTasks.indexOf(task) == -1) { speechOutput = "Non ho capito il comando. "; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } else { var cardTitle = "Esecuzione comando drone" + task; speechOutput = "Comando in esecuzione " + task; mqttPublish(intent, sessionAttributes, cardTitle, speechOutput, repromptText, shouldEndSession); } }

function doTurnIntent(intento, sessione, callback) {

// var cardTitle = "Drone Turn…"; var repromptText = null; var sessionAttributes = {}; var dovrebbeEndSession = false; var speechOutput = ""; repromptText = "Dimmi come vuoi girare il drone. "; var direzione = intent.slots. Direction.value; var validDirections = ["right", "left", "around"]; if (validDirections.indexOf(direction) == -1) { speechOutput = "Non sono riuscito a capire la direzione della svolta. "; ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); } else { var cardTitle = "Drone che gira " + direzione; speechOutput = "Svolta " + direzione; mqttPublish(intent, sessionAttributes, cardTitle, speechOutput, repromptText, shouldEndSession); } }

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

{var strIntent = JSON.stringify(intent); console.log("mqttPublish: INTENT text = " + strIntent); // client.publish("ikw1zr46p50f81z/drone/echo", strIntent, false); client.publish(config.topic, strIntent, false); cliente.fine(); client.on("close", (function() { console.log("MQTT CLIENT CLOSE - pensa che sia fatto, con successo. "); ctx.succeed(buildResponse(sessionAttributes, buildSpeechletResponse(cardTitle, speechOutput, repromptText, shouldEndSession))); })); client.on("errore", (funzione (errore, concesso) { console.log("ERRORE CLIENT MQTT!! " + errore); })); }

// --------------- Aiutanti che costruiscono tutte le risposte ---------

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, response: speechletResponse } }