🥇Programmiamo il controllo vocale del drone utilizzando Node.js e ARDrone

In questo tutorial, esploreremo la creazione di un programma per un drone controllato vocalmente utilizzando Node.js e il Web Speech API. Il drone è un Parrot ARDrone 2.0.

Ricordiamo: per tutti i lettori di «Habr» — sconto di 10.000 rubli per l'iscrizione a qualsiasi corso Skillbox con il codice promozionale «Habr».
Skillbox consiglia: Corso pratico «Sviluppatore mobile PRO».

Introduzione

I droni sono straordinari. Mi piace molto divertirsi con il mio drone, registrando foto e video o semplicemente divertendomi. Ma i veicoli aerei senza pilota (UAV) non vengono utilizzati solo per divertimento. Lavorano nel cinema, studiano i ghiacciai, e vengono impiegati da militari e agricoltori.

In questo tutorial, analizzeremo la creazione di un programma che consentirà di controllare il drone utilizzando comandi vocali. Sì, il drone farà quello che gli dici. Alla fine dell'articolo troverai il programma completo e un video di controllo dell'UAV.

Hardware

Abbiamo bisogno di quanto segue:

Parrot ARDrone 2.0;
cavo Ethernet;
un buon microfono.

Lo sviluppo e il controllo saranno effettuati su stazioni di lavoro con Windows/Mac/Ubuntu. Personalmente, ho lavorato con Mac e Ubuntu 18.04.

Software

Scarica l'ultima versione di Node.js da sito ufficiale.

È necessaria anche la ultima versione di Google Chrome.

Esploriamo il drone

Cerchiamo di capire come funziona il Parrot ARDrone. Questo drone ha quattro motori.

I motori opposti lavorano nella stessa direzione. Una coppia ruota in senso orario, l'altra in senso antiorario. Il drone si muove cambiando l'angolo di inclinazione rispetto alla superficie terrestre, modificando la velocità di rotazione dei motori e con alcuni altri movimenti manovrabili.

Come vediamo nel diagramma sopra, la variazione dei diversi parametri porta a un cambiamento nella direzione di movimento del drone. Ad esempio, ridurre o aumentare la velocità di rotazione delle eliche sinistre e destre crea un'inclinazione. Questo permette al drone di volare in avanti o indietro.

Modificando la velocità e la direzione di movimento dei motori, impostiamo gli angoli di inclinazione, consentendo al drone di muoversi in altre direzioni. In realtà, per il progetto attuale non è necessario studiare l'aerodinamica, è sufficiente comprendere i principi di base.

Come funziona il Parrot ARDrone

Il drone funge da punto di accesso Wi-Fi. Per ricevere e inviare comandi al drone, è necessario collegarsi a questo punto. Ci sono molte applicazioni diverse che consentono di controllare i droni. Si presenta più o meno così:

Una volta collegato, apriamo il terminale e digitiamo telnet 192.168.1.1 — questo è l'IP del drone. Per Linux si può utilizzare Linux Busybox.

Architettura dell'applicazione

Il nostro codice sarà suddiviso nei seguenti moduli:

interfaccia utente con API vocali per il riconoscimento della voce;
filtraggio dei comandi e confronto con il modello;
invio dei comandi al drone;
streaming video.

L'API funziona se è disponibile una connessione a Internet. Per garantirlo, aggiungiamo la connessione Ethernet.

È ora di creare l'applicazione!

Codifichiamo

Per iniziare, creiamo una nuova cartella e passiamo ad essa usando il terminale.

Poi creiamo un progetto Node utilizzando i comandi qui sotto.

Iniziamo installando le dipendenze necessarie.

npm install

Supporteremo i seguenti comandi:

decollo;
atterraggio;
su — il drone sale di mezzo metro e si ferma in hover;
giù — scende di mezzo metro e si ferma in hover;
a sinistra — va a sinistra di mezzo metro;
a destra — va a destra di mezzo metro;
gira — ruota in senso orario di 90 gradi;
avanti — va avanti di mezzo metro;
indietro — va indietro di mezzo metro;
fermati.

Ecco il codice che consente di ricevere comandi, filtrarli e controllare il drone.

const express = require('express');
const bodyparser = require('body-parser');
var arDrone = require('ar-drone');
const router = express.Router();
const app = express();
const commands = ['decollare', 'atterrare','su','giù','a sinistra','a destra','girare','avanzare','retromarcia','fermare'];
 
var drone  = arDrone.createClient();
// disabilitare l'emergenza
drone.disableEmergency();
// express
app.use(bodyparser.json());
app.use(express.static(__dirname + '/public'));
 
router.get('/',(req,res) => {
    res.sendFile('index.html');
});
 
router.post('/command',(req,res) => {
    console.log('comando ricevuto ', req.body);
    console.log('comandi esistenti', commands);
    let command = req.body.command.replace(/ /g,'');
    if(commands.indexOf(command) !== -1) {
        switch(command.toUpperCase()) {
            case "DECOLLARE":
                console.log('decollando il drone');
                drone.takeoff();
            break;
            case "ATTERRARE":
                console.log('atterrando il drone');
                drone.land();
            break;
            case "SU":
                console.log('portando il drone su mezzo metro');
                drone.up(0.2);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "GIÙ":
                console.log('portando il drone giù mezzo metro');
                drone.down(0.2);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "A SINISTRA":
                console.log('portando il drone a sinistra 1 metro');
                drone.left(0.1);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },1000);
            break;
            case "A DESTRA":
                console.log('portando il drone a destra 1 metro');
                drone.right(0.1);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },1000);
            break;
            case "GIRARE":
                console.log('girando il drone');
                drone.clockwise(0.4);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "AVANZARE":
                console.log('spostando il drone in avanti di 1 metro');
                drone.front(0.1);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "RETROMARCIA":
                console.log('spostando il drone indietro di 1 metro');
                drone.back(0.1);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "FERMARE":
                drone.stop();
            break;
            default:
            break;    
        }
    }
    res.send('OK');
});
 
app.use('/',router);
 
app.listen(process.env.port || 3000);

Ecco il codice HTML e JavaScript che ascolta l'utente e invia il comando al server Node.

<!DOCTYPE html>
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <title>App per Note Controllate da Voce</title>
        <meta name="description" content="">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/shoelace-css/1.0.0-beta16/shoelace.css">
        <link rel="stylesheet" href="styles.css">
 
    </head>
    <body>
        <div class="container">
 
            <h1>Drone Controllato da Voce</h1>
            <p class="page-description">Una piccola applicazione che ti consente di controllare un drone AR usando la voce</p>
 
            <h3 class="no-browser-support">Spiacente, il tuo browser non supporta l'API Web Speech. Prova a aprire questa demo in Google Chrome.</h3>
 
            <div class="app">
                <h3>Dai il comando</h3>
                <div class="input-single">
                    <textarea id="note-textarea" placeholder="Crea una nuova nota digitando o utilizzando il riconoscimento vocale." rows="6"></textarea>
                </div>    
                <button id="start-record-btn" title="Inizia a Registrare">Inizia il Riconoscimento</button>
                <button id="pause-record-btn" title="Metti in Pausa la Registrazione">Metti in Pausa il Riconoscimento</button>
                <p id="recording-instructions">Premi il <strong>Inizia il Riconoscimento</strong> pulsante e consenti l'accesso.</p>
 
            </div>
 
        </div>
 
        <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
        <script src="script.js"></script>
 
    </body>
</html>

Ecco un altro codice JavaScript per lavorare con i comandi vocali, inviandoli al server Node.

try {
 var SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
 var recognition = new SpeechRecognition();
 }
 catch(e) {
 console.error(e);
 $('.no-browser-support').show();
 $('.app').hide();
 }
// altro codice, si prega di consultare la sorgente GitHub
recognition.onresult = function(event) {
// l'evento è un oggetto SpeechRecognitionEvent.
// Contiene tutte le righe che abbiamo catturato finora.
 // Abbiamo bisogno solo dell'attuale.
 var current = event.resultIndex;
// Ottieni un trascritto di ciò che è stato detto.
var transcript = event.results[current][0].transcript;
// invialo al backend
$.ajax({
 type: 'POST',
 url: '/command/',
 data: JSON.stringify({command: transcript}),
 success: function(data) { console.log(data) },
 contentType: "application/json",
 dataType: 'json'
 });
};

Avviamo l'applicazione

Puoi avviare il programma nel seguente modo (è importante assicurarsi che il drone sia connesso al Wi-Fi e che il cavo Ethernet sia collegato al computer).

Apriamo localhost:3000 nel browser e clicchiamo su Inizia Riconoscimento.

Proviamo a controllare il drone e ci divertiamo.

Streaming video dal drone

Nel progetto creiamo un nuovo file e copiamo lì questo codice:

const http = require("http");
const drone = require("dronestream");
 
const server = http.createServer(function(req, res) {
 
require("fs").createReadStream(__dirname + "/public/video.html").pipe(res);
 });
 
drone.listen(server);
 
server.listen(4000);

Ecco il codice HTML, posizioniamolo all'interno della cartella pubblica.

<!doctype html>
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=utf-8">
 <title>Flusso come modulo</title>
 <script src="/dronestream/nodecopter-client.js" type="text/javascript" charset="utf-8"></script>
 </head>
 <body>
 <h1 id="heading">Flusso video del drone</h1>
 <div id="droneStream" style="width: 640px; height: 360px"> </div>
 
<script type="text/javascript" charset="utf-8">
 
new NodecopterStream(document.getElementById("droneStream"));
 
</script>
 
</body>
</html>

Avviamo e ci connettiamo a localhost:8080 per visualizzare il video dalla camera frontale.

Consigli utili

Controlla questo drone al chiuso.
Indossa sempre un cappuccio protettivo sul drone prima del decollo.
Controlla se la batteria è carica.
Se il drone si comporta in modo strano, tienilo dal basso e capovolgilo. Questa azione passerà il drone in modalità di emergenza e i rotori si fermeranno immediatamente.

Codice pronto e dimostrazione

DIMOSTRAZIONE LIVE

SCARICA

Fatto!

Scrivere codice e poi osservare come la macchina inizia ad ascoltare sarà un piacere! Ora abbiamo capito come insegnare al drone ad ascoltare comandi vocali. In realtà, ci sono molte più possibilità: riconoscimento del volto dell'utente, voli autonomi, riconoscimento dei gesti e molto altro.

Cosa puoi suggerire per migliorare il programma?

Skillbox consiglia:

Corso online pratico «Analista dati Python».

Corso online «Professione sviluppatore frontend».

Corso pratico annuale «Sviluppatore PHP da 0 a PRO».

Fonte: habr.com