🥇 Programando o controle de voz do drone usando Node.js e ARDrone

Neste tutorial, vamos explorar a criação de um programa para um drone com controle de voz usando Node.js e Web Speech API. O drone é o Parrot ARDrone 2.0.

Lembramos: para todos os leitores do «Habr» — desconto de 10.000 rublos na inscrição em qualquer curso Skillbox com o código promocional «Habr».
A Skillbox recomenda: Curso Prático ‘Desenvolvedor Móvel PRO’.

Introdução

Drones são fascinantes. Eu adoro brincar com meu drone, capturando fotos e vídeos ou simplesmente me divertindo. Mas os veículos aéreos não tripulados (VANTs) não são usados apenas para entretenimento. Eles trabalham no cinema, estudam geleiras, são usados por militares e na agricultura.

Neste tutorial, vamos aprender a criar um programa que permita controlar o drone usando comandos de voz. Sim, o drone fará o que você ordenar. No final do artigo, haverá um programa pronto e um vídeo de controle do VANT.

Hardware

Precisamos do seguinte:

Parrot ARDrone 2.0;
Cabo Ethernet;
um bom microfone.

O desenvolvimento e o controle serão feitos em estações de trabalho com Windows/Mac/Ubuntu. Pessoalmente, trabalhei com Mac e Ubuntu 18.04.

Software

Baixe a versão mais recente do Node.js no site oficial.

Você também precisará da versão mais recente do Google Chrome..

Entendendo o drone

Vamos tentar entender como funciona o Parrot ARDrone. Esse drone possui quatro motores.

Os motores opostos funcionam na mesma direção. Um par gira no sentido horário, o outro no sentido anti-horário. O drone se move mudando o ângulo de inclinação em relação ao solo, alterando a velocidade de rotação dos motores e realizando alguns outros movimentos manobráveis.

Como podemos ver no diagrama acima, a alteração de diferentes parâmetros resulta na mudança de direção do drone. Por exemplo, reduzir ou aumentar a velocidade de rotação dos rotores esquerdo e direito cria um ângulo de inclinação. Isso permite que o drone voe para frente ou para trás.

Alterando a velocidade e a direção dos motores, definimos os ângulos de inclinação que permitem ao drone se mover em diferentes direções. Para o projeto atual, não é necessário estudar a aerodinâmica, basta entender os princípios básicos.

Como funciona o Parrot ARDrone

O drone atua como um ponto de acesso Wi-Fi. Para enviar e receber comandos ao drone, é necessário conectar-se a esse ponto. Existem muitos aplicativos diferentes que permitem controlar drones. Eles se parecem aproximadamente com isto:

Assim que o drone estiver conectado, abra o terminal e digite telnet 192.168.1.1 — este é o IP do drone. Para Linux, pode-se usar Linux Busybox.

Arquitetura do aplicativo

O nosso código será dividido nos seguintes módulos:

interface do usuário com API de voz para detecção de voz;
filtragem de comandos e correspondência com o padrão;
envio de comandos para o drone;
transmissão de vídeo ao vivo.

A API funciona com a condição de uma conexão à internet. Para garantir isso, adicionamos uma conexão via Ethernet.

É hora de criar o aplicativo!

Vamos codificar

Para começar, criaremos uma nova pasta e mudaremos para ela através do terminal.

Em seguida, criamos um projeto Node, usando os comandos abaixo.

Primeiro, instalamos as dependências necessárias.

npm install

Vamos suportar os seguintes comandos:

decolar;
pousar;
para cima — o drone sobe meio metro e paira;
para baixo — desce meio metro e paira;
para a esquerda — vai para a esquerda meio metro;
para a direita — vai para a direita meio metro;
giro — gira no sentido horário em 90 graus;
para frente — vai para frente meio metro;
para trás — vai para trás meio metro;
parar.

Aqui está o código que permite receber comandos, filtrá-los e controlar o drone.

const express = require('express');
const bodyparser = require('body-parser');
var arDrone = require('ar-drone');
const router = express.Router();
const app = express();
const commands = ['takeoff', 'land','up','down','goleft','goright','turn','goforward','gobackward','stop'];
 
var drone  = arDrone.createClient();
// desativar emergência
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 recebido ', req.body);
    console.log('comandos existentes', commands);
    let command = req.body.command.replace(/ /g,'');
    if(commands.indexOf(command) !== -1) {
        switch(command.toUpperCase()) {
            case "TAKEOFF":
                console.log('decolando o drone');
                drone.takeoff();
            break;
            case "LAND":
                console.log('aterrissando o drone');
                drone.land();
            break;
            case "UP":
                console.log('elevando o drone meio metro');
                drone.up(0.2);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "DOWN":
                console.log('descendo o drone meio metro');
                drone.down(0.2);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "GOLEFT":
                console.log('movendo o drone para a esquerda 1 metro');
                drone.left(0.1);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },1000);
            break;
            case "GORIGHT":
                console.log('movendo o drone para a direita 1 metro');
                drone.right(0.1);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },1000);
            break;
            case "TURN":
                console.log('girando o drone');
                drone.clockwise(0.4);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "GOFORWARD":
                console.log('movendo o drone para frente 1 metro');
                drone.front(0.1);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "GOBACKWARD":
                console.log('movendo o drone para trás 1 metro');
                drone.back(0.1);
                setTimeout(() => {
                    drone.stop();
                    clearTimeout();
                },2000);
            break;
            case "STOP":
                drone.stop();
            break;
            default:
            break;    
        }
    }
    res.send('OK');
});
 
app.use('/',router);
 
app.listen(process.env.port || 3000);

Aqui está o código HTML e JavaScript que escuta o usuário e envia comandos para o servidor Node.

<!DOCTYPE html>
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <title>Aplicativo de Notas Controlado por Voz</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 Controlado por Voz</h1>
            <p class="page-description">Um aplicativo pequeno que permite controlar um drone AR usando a voz</p>
 
            <h3 class="no-browser-support">Desculpe, seu navegador não suporta a API de Fala da Web. Tente abrir esta demonstração no Google Chrome.</h3>
 
            <div class="app">
                <h3>Dê o comando</h3>
                <div class="input-single">
                    <textarea id="note-textarea" placeholder="Crie uma nova nota digitando ou usando o reconhecimento de voz." rows="6"></textarea>
                </div>    
                <button id="start-record-btn" title="Iniciar Gravação">Iniciar Reconhecimento</button>
                <button id="pause-record-btn" title="Pausar Gravação">Pausar Reconhecimento</button>
                <p id="recording-instructions">Pressione o <strong>Iniciar Reconhecimento</strong> botão e permita o acesso.</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>

E aqui está o código JavaScript para trabalhar com comandos de voz, enviando-os para o servidor Node.

tente {
 var SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
 var recognition = new SpeechRecognition();
 }
 catch(e) {
 console.error(e);
 $('.no-browser-support').show();
 $('.app').hide();
 }
// outro código, consulte a fonte do GitHub
recognition.onresult = function(event) {
// event é um objeto SpeechRecognitionEvent.
// Ele contém todas as linhas que capturamos até agora.
 // Precisamos apenas da atual.
 var current = event.resultIndex;
// Obtenha uma transcrição do que foi dito.
var transcript = event.results[current][0].transcript;
// envie para o backend
$.ajax({
 type: 'POST',
 url: '\/command\/',
 data: JSON.stringify({command: transcript}),
 success: function(data) { console.log(data) },
 contentType: "application\/json",
 dataType: 'json'
 });
};

Iniciamos o aplicativo

O programa pode ser iniciado da seguinte forma (é importante garantir que o drone esteja conectado ao Wi-Fi e que o cabo Ethernet esteja conectado ao computador).

Abrimos localhost:3000 no navegador e clicamos em Iniciar Reconhecimento.

Tentamos controlar o drone e nos divertimos.

Transmissão de vídeo do drone

No projeto, criamos um novo arquivo e copiamos este código:

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);

E aqui está o código HTML, que colocamos na pasta public.

<!doctype html>
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=utf-8">
 <title>Transmissão como módulo</title>
 <script src="/dronestream/nodecopter-client.js" type="text/javascript" charset="utf-8"></script>
 </head>
 <body>
 <h1 id="heading">Transmissão de vídeo de 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>

Iniciamos e nos conectamos a localhost:8080 para assistir ao vídeo da câmera frontal.

Dicas úteis

Controle este drone em ambientes fechados.
Sempre coloque o protetor no drone antes de decolar.
Verifique se a bateria está carregada.
Se o drone se comportar de forma estranha, segure-o pela parte inferior e vire-o. Esta ação colocará o drone em modo de emergência, e os rotores pararão imediatamente.

Código completo e demonstração

DEMO AO VIVO

BAIXAR

Conseguimos!

Escrever código e depois ver a máquina começar a obedecer será um prazer! Agora entendemos como ensinar o drone a ouvir comandos de voz. Na verdade, há muito mais possibilidades: reconhecimento de rosto do usuário, voos autônomos, reconhecimento de gestos e muito mais.

O que você pode sugerir para melhorar o programa?

A Skillbox recomenda:

Curso Online Aplicado Analista de Dados Python.

Curso online «Profissão desenvolvedor frontend».

Curso prático de um ano "Desenvolvedor PHP do zero ao PRO".

Fonte: habr.com