Drone autônomo DIY com controle sobre a Internet. Parte 2 sobre software

Esta é uma continuação da história de um drone autônomo. A primeira parte falou sobre hardware, esta falará sobre software. Para começar, um pequeno programa educacional sobre a interação do operador com o helicóptero. Aqui está um layout típico para a maioria dos drones auto-montados:



E aqui está o esquema para drones avançados:



É assim que os drones de brinquedo funcionam, controlados a partir de um smartphone:



Você pode controlar o drone pela Internet (se você tiver um cartão SIM com um endereço IP estático):



Ou então, se o endereço IP for dinâmico:



Para confiabilidade e redundância dos canais de comunicação, a última opção pode ser desenvolvida para esse estado:



A seguir, descreverei o processo de instalação do controlador de vôo Emlid Navio 2 e do microcomputador Raspberry Pi 3.


Porém, com pequenas modificações, essas configurações são adequadas para qualquer controlador de vôo, com o qual você pode se comunicar por meio do protocolo MAVLink em conjunto com qualquer computador em uma família de sistemas operacionais Linux.



Importante! A configuração deve ser feita com a energia desligada nos controladores de velocidade, para que os motores não dêem partida acidentalmente.

Software de controle Drone para PC e tablets

Para controlar o UAV, programas especiais GCS (Ground Control Station) são usados. Mais adiante, no texto, usarei essa abreviação. Gostei do QGroundControl , um GCS multi-plataforma de código aberto (Windows, Linux, MacOS, iOS, Android) que se tornou parte do projeto DroneCode . Mas existem alternativas, gratuitas e comerciais: APM Planner , MissionPlanner , UgCS , LibrePilot , OpenPilot , Tower (DroidPlanner) para Android, MAVPilot (iOS), SidePilot (iOS). Bem como o console MAVProxy .

Instale uma imagem do sistema operacional em um cartão SD

Para operação normal do piloto automático, é altamente recomendável usar cartões SD "rápidos" (classe 10). Os cartões de memória lenta não têm tempo para salvar os registros do piloto automático, mesmo em baixa frequência, como resultado, eles acabam distorcidos ou não são gravados. A evidência disso pode ser um erro " No IO heartbeat ", que pode ser observado no console do MAVLink (como assistir ao console do MAVLink é descrito abaixo). Ao comprar, observe a capacidade de gravar vídeos em 4K: provavelmente será um SD rápido. Infelizmente, descobri isso depois da queda do drone, quando foi necessário analisar os logs e descobrir o motivo. Os logs eram ilegíveis para vários GCS. O motivo para desligar os motores durante o voo acabou sendo banal: esqueci de ajustar a tensão mínima da bateria nas configurações para operação à prova de falhas.

Portanto, faça o download da imagem final do Raspbian Stretch com Ardupilot e ROS pré-instalados do Emlid na página de instruções original . E nós o escrevemos em um cartão de memória usando o Etcher ou qualquer outro programa similar.

Para conectar o Raspberry à sua rede Wi-Fi imediatamente após ligar, você precisa editar o arquivo wpa_supplicant.conf na raiz do cartão SD. Ele deve conter as seguintes linhas:

network={ ssid="_wifi_" psk="_wifi_" } 

Você também pode configurá-lo sem WiFi conectando um computador de placa única ao roteador com um cabo Ethernet. Agora remova o cartão SD do PC, insira-o no Raspberry e ligue a alimentação. Após meio minuto, ele deve aparecer no painel de administração do roteador na página de dispositivos conectados ( nome do host do navio).

Atualizando o kit de distribuição e instalando os pacotes necessários

Abra o cliente SSH e conecte-se ao Raspberry (endereço IP local do navio em vez de RASPBERRY_IP_ADDRESS ):

 ssh pi@RASPBERRY_IP_ADDRESS 

Senha padrão: framboesa . Antes de tudo, é necessário expandir o sistema de arquivos do sistema operacional para todo o volume do cartão SD:

 sudo raspi-config --expand-rootfs 

e reinicie:

 sudo reboot 

Após a reinicialização, conecte-se novamente e atualize a distribuição:

 sudo apt-get update && sudo apt-get dist-upgrade -y 

Instale pacotes adicionais:

 sudo apt-get install autoconf automake libtool pkg-config libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libraspberrypi-dev gstreamer1.0-tools gstreamer1.0-plugins-good gstreamer1.0-plugins-bad 

e compile o wrapper gst-rpicamsrc para o gstreamer e a câmera nativa Raspicam:

 git clone https://github.com/thaytan/gst-rpicamsrc.git rpicamsrc cd rpicamsrc chmod +x autogen.sh ./autogen.sh --prefix=/usr --libdir=/usr/lib/arm-linux-gnueabihf/ make sudo make install 

Verifique se a câmera funciona (o arquivo de vídeo test.h264 é criado):

 gst-launch-1.0 rpicamsrc bitrate=1000000 ! filesink location=test.h264 

Se o gstreamer iniciar, aguarde alguns segundos para que o vídeo seja gravado. Você pode interromper o processo pressionando Ctrl + C. Se houver vídeo, a câmera está funcionando.

Configurar e iniciar o Ardupilot

Os lançamentos de novas versões do Ardupilot estão um pouco atrasados ​​na montagem da Emlid. Se a funcionalidade necessária estiver disponível na versão mais recente, você poderá instalá-la a partir da fonte usando esta instrução .

Os desenvolvedores do Navio adicionaram um utilitário de ferramenta Emlid simples e conveniente aos seus sensores para verificar os sensores e configurar o Ardupilot. Primeiro, verifique se o Raspberry vê o controlador Navio:

 emlidtool info 

Se em resposta a este comando produz algo como:

 Vendor: Emlid Limited Product: Navio 2 Issue: Emlid 2018-06-05 831f3b08594f2da17dccae980a2e3659115ef71f Kernel: 4.14.34-emlid-v7+ RCIO firmware: 0xcaec2284 

significa que ele vê. Verifique o status dos sensores (mostre a lista e o status):

 emlidtool test 

e controladores de controlador PWM no kernel do Linux:

 cat /sys/kernel/rcio/status/alive 

0 = não está funcionando, 1 = está funcionando.

O firmware do controlador PWM é atualizado da seguinte maneira:

 sudo emlidtool rcio update 

Agora configure o Ardupilot:

 sudo emlidtool ardupilot 

Uma GUI de texto com menus passo a passo será aberta no terminal. Selecionamos o helicóptero da versão mais recente, digite arducopter , inicie automaticamente na inicialização ( Na inicialização: habilite ), inicie após a configuração ( Ardupilot: start ).



Saímos pelo item de menu Sair .

Verifique se o Ardupilot foi iniciado:

 sudo systemctl status arducopter 

Observe que o arquivo de inicialização no systemd é chamado arducopter , pois a opção helicóptero foi configurada.

Agora precisamos configurar o Ardupilot para que ele nos envie telemetria. Para fazer isso, edite o arquivo de configuração:

 sudo nano /etc/default/arducopter 

Ele deve conter as seguintes linhas:

 TELEM1="-A udp:127.0.0.1:14550" ARDUPILOT_OPTS="$TELEM1" 

Salve o arquivo ( Ctrl + X e Y ) e reinicie o Ardupilot:

 sudo systemctl daemon-reload sudo systemctl restart arducopter 

Você pode verificar o status do processo Ardupilot com o seguinte comando:

 sudo systemctl status arducopter 

Com essas configurações, o Ardupilot transmitirá a telemetria (pacotes MAVLink ) para a porta UDP local 14550. Em seguida, o script MAVProxy (descrição abaixo) fará a telemetria de lá e a enviará para o GCS ou o script, além de enviar pacotes com comandos na direção oposta.

Em vez do endereço e da porta locais, você pode gravar o endereço IP de um PC ou tablet na rede local e os pacotes serão transmitidos imediatamente para lá.



No entanto, essa abordagem é justificada se os dados de telemetria não forem usados ​​em nenhum outro lugar e o dispositivo com GCS tiver um endereço IP estático. Caso contrário, toda vez que você precisar registrar um novo Ardupilot nas configurações. Para se comunicar com o piloto automático por TCP, vários GCSs com endereços dinâmicos e alguns outros scripts no computador de bordo poderiam simultaneamente, é mais conveniente usar o MAVProxy.



Este script (escrito em Python) pode receber pacotes MAVLink para um endereço UDP local e retransmiti-los para vários endereços IP locais ou remotos, via UDP e TCP. Os pacotes são enviados nas duas direções para o Ardupilot® GCS. Além disso, o MAVProxy é um GCS completo, mas com uma interface de texto.

MAVProxy

O MAVProxy já está instalado na imagem do Navio. Também pode ser instalado em um PC (Windows, Linux, MacOS) para comunicação adicional com o piloto automático no modo de console.

Depois de verificar se o Ardupilot está funcionando, execute o script MAVProxy no Raspberry com este comando:

 mavproxy.py --master=udp:127.0.0.1:14550 

O parâmetro --master = udp: 127.0.0.1: 14550 define a fonte de dados para o script. Esta é a porta UDP local que foi registrada no arquivo de configuração do Ardupilot. Após executar o comando, o MAVProxy se conectará a essa porta e exibirá mensagens do piloto automático, semelhantes às minhas:

 pi@navio:~ $ mavproxy.py --master=udp:127.0.0.1:14550 Connect udp:127.0.0.1:14550 source_system=255 Failed to load module: No module named adsb. Use 'set moddebug 3' in the MAVProxy console to enable traceback Log Directory: Telemetry log: mav.tlog Waiting for heartbeat from 127.0.0.1:14550 MAV> online system 1 STABILIZE> Mode STABILIZE fence breach GPS lock at 0 meters APM: APM:Copter V3.5.5 (88a1ecdd) APM: Frame: UNKNOWN APM: PreArm: RC Roll not configured APM: PreArm: Compass not calibrated APM: PreArm: 3D Accel calibration needed APM: PreArm: check firmware or FRAME_CLASS APM: PreArm: Throttle below Failsafe 

Como o piloto automático ainda não foi calibrado e não está totalmente ajustado, as mensagens também falam eloqüentemente sobre isso. Nesse modo, você pode se comunicar com o piloto automático através de comandos. Se o drone estivesse totalmente ajustado, uma sequência de dois comandos levaria ao arranque dos motores e o drone decolaria a uma altura de 20 m:

 arm throttle takeoff 20 

Um piloto automático não calibrado não voa, mas exibe mensagens com motivos pelos quais não pode fazer isso.

Estabelecendo comunicação com o drone na rede local

Pare o script ( Ctrl + C ) e execute-o novamente desta forma:

 mavproxy.py --master=udp:127.0.0.1:14550 --out=tcpin:0.0.0.0:5762 

Com o parâmetro adicional --out = tcpin: 0.0.0.0: 5762, o MAVProxy escutará na porta 5762 as conexões TCP de entrada do GCS. Assim que o GCS se conectar, os pacotes de dados começarão a se mover entre o drone e o GCS. Vamos tentar conectar a partir de um PC:



Se a conexão for bem-sucedida, o GCS mostrará várias mensagens com uma solicitação para calibrar os sensores e carregar os parâmetros integrados com seus valores atuais:

Calibração de sensores e ajuste dos parâmetros do piloto automático

A calibração do piloto automático pode ser feita em praticamente qualquer GCS. A documentação do Ardupilot descreve em detalhes. Primeiro, definimos o tipo de quadro. Eu tenho um layout padrão de 4 motores, então esse é o Quad X.



O primeiro vôo ainda é melhor realizado no modo manual. Conectamos e calibramos o controle de rádio (receptor e transmissor).



Resta calibrar o acelerômetro e a bússola.



Para que o Ardupilot veja e leve em consideração dados de sensores externos, defina os parâmetros necessários:

Para PX4Flow ( calibração do próprio sensor e atualização de firmware )

FLOW_ENABLE = 1 (Enabled)
FLOW_ADDR = 0 (0 = 042)

Para altímetro a laser VL53L0X ( instrução )

RNGFND_TYPE = 16 (VL53L0X)
RNGFND_ORIENT = 25 ( )
RNGFND_ADDR = 41 (I2C- ). - 0x29, = 41.
RNGFND_SCALING = 1
RNGFND_MIN_CM = 5
RNGFND_MAX_CM = 120
RNGFND_GNDCLEAR = 15 ( , )

Para IRLock ( instruções detalhadas , wiki IR-Lock )

PLND_ENABLED = 1
PLND_TYPE = 2
PLND_BUS = 1

Para sonar de vista frontal ( instrução )

RNGFND2_TYPE = 2 (MaxbotixI2C sonar)
RNGFND2_ORIENT = 0 ( )
RNGFND2_MAX_CM = 700 ( )

Lista completa de opções do Ardupilot.

Agora reinicie o Ardupilot no menu GCS, reconecte-se à placa e abra a janela do MAVLink Inspector para ver os dados dos sensores.



Infelizmente, as leituras do IR-Lock não são visíveis aqui. Para a análise de seu trabalho, você precisará examinar os registros a bordo. Como fazer isso é descrito aqui .

Resta definir as configurações de segurança e você pode iniciar o drone:



Como configurar a suspensão giroscópica e controlar a câmera principal em detalhes Escreverei em um dos seguintes artigos, os principais pontos são descritos aqui .

Transmissão de vídeo

Vamos verificar como a transmissão de vídeo funciona na rede WiFi. Com este comando, você pode executar o vídeo em uma porta TCP no Raspberry usando o utilitário raspivid nativo da câmera Raspicam:

 raspivid -t 0 -hf -fps 25 -w 640 -h 480 -o - | gst-launch-1.0 fdsrc ! h264parse ! rtph264pay config-interval=1 pt=96 ! gdppay ! tcpserversink host=0.0.0.0 port=5001 

Mas este comando faz a mesma coisa, apenas usando o wrapper rpi-camsrc compilado anteriormente para o gstreamer:

 gst-launch-1.0 rpicamsrc sensor-mode=4 ! h264parse ! rtph264pay config-interval=1 pt=96 ! gdppay ! tcpserversink host=0.0.0.0 port=5001 

Nos dois casos, a transmissão h264 está disponível no endereço IP do Raspberry na porta 5001.

Você pode vê-lo executando esse comando no seu PC (o gstreamer deve estar instalado); em vez de RPI_ADDRESS, especifique o endereço Raspberry na rede:

 gst-launch-1.0 -v tcpclientsrc host=RPI_ADDRESS port=5001 ! gdpdepay ! rtph264depay ! avdec_h264 ! videoconvert ! autovideosink sync=false 

Como resultado, a janela com o vídeo deve abrir.

Quase todo GCS possui um reprodutor de vídeo embutido que pode exibir um fluxo de vídeo RTSP. Para criar um servidor RTSP a partir de um Raspberry, você pode usar o console VLC player . Instalação:

 sudo apt-get install vlc 

A transmissão de vídeo começa da seguinte maneira:

 raspivid -o - -t 0 -n -w 320 -h 240 -fps 25 | cvlc -vvv stream:///dev/stdin --sout '#rtp{sdp=rtsp://:8554/live}' :demux=h264 

O vídeo está disponível em (em vez de RPI_ADDRESS , endereço de framboesa):

rtsp://RPI_ADDRESS:8554/live

Configuração do GCS:





O endereço do stream pode ser usado para conectar vários players em dispositivos diferentes, mas como a captura e transmissão de vídeo para Raspberry é um processo muito demorado, é melhor para vários consumidores de vídeo usar um servidor externo (descrição abaixo).

Telemetria pela Internet

Para que o GCS se conecte via Internet a um drone com um endereço IP dinâmico, é necessário um servidor intermediário com um IP estático no qual o script MAVProxy será iniciado. Para esses fins, aproveitei o aluguel de servidores em nuvem de um dos fornecedores conhecidos. Para o MAVProxy, a configuração mais mínima é adequada, mas como usarei o mesmo servidor para retransmitir vídeo, escolhi a opção com um pouco mais de memória (um núcleo e 1 GB de memória, Ubuntu 18.04). Para o atraso mínimo na passagem de dados entre a placa e o GCS, o servidor deve estar localizado na máxima proximidade geográfica do drone e do GCS.



Instale o MAVProxy no servidor. Primeiras dependências:

 sudo apt-get install python-dev python-opencv python-wxgtk3.0 python-pip python-matplotlib python-pygame python-lxml python-yaml 

e então o próprio script através do PIP:

 sudo pip install MAVProxy 

escreva o caminho:

 echo "export PATH=$PATH:$HOME/.local/bin" >> ~/.bashrc 

e execute o script com os seguintes parâmetros:

 mavproxy.py --master=udp:0.0.0.0:15001 --out=tcpin:0.0.0.0:15002 

O MAVProxy escuta na porta 15001 os pacotes de telemetria recebidos do drone via UDP e a porta 15002 a conexão TCP de entrada do GCS.

Execute o MAVProxy no Raspberry com mais um parâmetro, para que a telemetria também seja transmitida para o servidor (em vez de SERVER_IP, o endereço do seu servidor):

 mavproxy.py --master=udp:127.0.0.1:14550 --out=tcpin:0.0.0.0:5762 --out=udpout:SERVER_IP:15001 

Após iniciar o script no computador de bordo, as mensagens do piloto automático serão exibidas no console do servidor. Como mencionado acima, o MAVProxy é um GCS completo com uma interface de texto e, neste estado, já é possível editar parâmetros e controlar o drone através de comandos no console do servidor.

Conecte o GCS no PC ou tablet ao servidor. As configurações de conexão são as mesmas da rede local; somente, em vez do endereço IP do Raspberry, especificamos o endereço do servidor e a porta 15002.



Agora você pode conectar um modem USB 4G ao Raspberry e avaliar o atraso com o qual o horizonte na tela reage.

Vídeo na Internet

Para retransmitir o vídeo, instale o VLC player no servidor:

 sudo apt-get install vlc 

Após a instalação, execute-o como um relé da porta UDP 5001 no canal RTSP SERVER_IP: 8554 / live :

 cvlc -vvv udp://@:5001 --sout '#rtp{sdp=rtsp://:8554/live}' :demux=h264 

A bordo, iniciaremos a transmissão de vídeo da câmera para o servidor via UDP (em vez do endereço do servidor SERVER_IP ):

 gst-launch-1.0 rpicamsrc bitrate=1000000 ! video/x-h264,width=640,height=480,framerate=25/1 ! h264parse ! udpsink host=SERVER_IP port=5001 

O endereço de fluxo agora pode ser usado como fonte de vídeo nas configurações do GCS ou aberto em qualquer player que suporte esse protocolo.

Agora você pode planejar a rota do voo e iniciar o drone pela Internet, tendo sido ativado anteriormente, por exemplo, usando o assistente de telefone.

Obviamente, devido ao tempo de viagem relativamente longo de vídeo e telemetria pela rede, esse método dificilmente é adequado para vôos FPV no modo manual entre obstáculos.



Assuntos para publicações subsequentes:

• Opções para carregar automaticamente o drone na minha casa de pássaros e em qual parei.
• Implementando o GCS baseado na Web usando o MAVProxy, NodeJS, socket.io e um servidor de mídia para gerenciar vários drones simultaneamente.
• Canais de comunicação redundantes e sistemas de resgate por drones
• Visão de máquina e lidares para evitar colisões com obstáculos

Para continuar ...