Tanque de framboesa com interface da Web e streaming de vídeo: 8 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Vamos ver como eu descobri um pequeno tanque WiFi, capaz de controle remoto da Web e streaming de vídeo.

Pretende-se que seja um tutorial que requer conhecimentos básicos de programação eletrônica e de software. Por esse motivo, escolhi um kit de chassi do tanque (em vez de imprimi-lo usando uma impressora 3D, pode ser uma atualização posterior) e um total de 6 componentes, incluindo baterias. No lado do software, você pode acompanhar passo a passo o processo de instalação e programação é mantida no mínimo, um conhecimento básico do Raspberry Things pode ajudar.

Eu estimei 12 horas de trabalho de 0 até o tanque pronto para funcionar. Custo total de 70 € para todos os componentes.

Etapa 1: BOM

1 - Tanque de chassi de robô faça você mesmo - 32 (€)

www.banggood.com/DIY-RC-Robot-Chassis-Tan…

1 - Placa de driver do motor DC L298N de canal duplo - 1, 39 (€)

www.banggood.com/Dual-Channel-L298N-DC-Mo…

1 - Kit Inicial Raspberry Pi Zero W - 26 (€)

amzn.eu/1ugAaMP

Cartão SD de 1 - 16 GB - 5, 50 (€)

www.gearbest.com/memory-cards/pp_337819.h…

1 - Webcam com módulo de câmera Raspberry Pi 5MP para Model Zero - 8 (€)

www.gearbest.com/raspberry-pi/pp_612249.h…

1 - Banco de potência 5V

Bateria 1 - 9v

Conector Dupont do cabo da placa de ensaio mista

Mouse, teclado, monitor ou TV para configuração do Raspberry (opcional, apenas para tornar a primeira configuração mais fácil)

Etapa 2: Especificações dos componentes principais

Motor

Motoredutor JGA25-370 DC

Este motor possui um eixo de saída em forma de D.

Especificações

· Tensão de operação: entre 6 V e 18 V

· Tensão nominal: 12 V

· Velocidade de operação livre a 12 V: 399 RPM

· Corrente de operação livre em 12 V: 50 mA

· Corrente de perda em 12V: 1200 mA

· Torque de perda em 12V: 2,2 kg.cm

· Relação de engrenagem: 1:21

· Tamanho do redutor: 19 mm

· Peso: 84 g

Placa de driver de motor DC L298N de canal duplo

Driver de motor de ponte H dupla, pode acionar dois motores CC ou motores de passo de duas fases de 4 fios. TSD embutido, para proteger da parada do motor.

Especificações

· Tensão de alimentação do módulo: DC 2V-10V

· Tensão de entrada de sinal: DC 1.8-7V

· Corrente de trabalho simples: 1.5A

· Corrente de pico até 2,5A

· Baixa corrente de espera (menos de 0,1uA)

· Circuito de condução comum embutido, o terminal de entrada vazio, o motor não funciona mal

· Tamanho: 24,7 x 21 x 7 mm

Etapa 3: FIAÇÃO

Esta será a fiação final, mas ESPERE, antes de precisarmos instalar alguns

software e é uma boa ideia testá-lo com fiação mais simples, quando estiver pronto, volte aqui.

Precisamos de duas fontes de alimentação diferentes, uma para o motor e outra para o Raspberry.

O driver do motor Dual Channel L298N DC Motor Driver Board (tensão de entrada máxima DC 2V-10V) é alimentado usando a bateria de 9V e Raspberry Pi usa o acumulador USB 5V padrão.

O pino GND do driver do motor será conectado ao negativo da bateria e ao Raspberry Pi (GND). Os pinos GPIO do Raspberry Pi são conectados ao driver do motor como uma mesa.

Etapa 4: PREPARAÇÃO DE FRAMBOESA O. S

Esta é uma instalação padrão para o sistema operacional Raspbian, você pode encontrar

muitos tutoriais detalhados de pesquisa na web, basicamente as etapas são:

1. Baixe iso RASPBIAN STRETCH COM DESKTOP em

2. Formate um cartão SD de 16 GB, usei o SD Formatter

3. Grave o arquivo. IMG, usei o Win32DiskImager

Agora seu raspberry está pronto para inicializar, conecte-o a uma fonte de alimentação USB (5V, 2A) e prepare-se para a primeira configuração de inicialização. Você pode fazer isso de duas maneiras, usando dispositivos externos como mouse, teclado e monitor ou usando seu PC e uma conexão remota com o Raspberry. Há muitos tutoriais sobre isso, um deles é:

Etapa 5: COMO CONTROLAR NOSSO TANQUE WIFI COM NODE. JS E WEBSOCKET. IO

Agora temos uma nova instalação de nosso micro PC Raspberry pronto para executar nosso trabalho, então … o que usamos para emitir comandos para o tanque?

Python é uma linguagem muito fácil de usar que é comumente usada para executar o projeto Rapsberry e pode ser facilmente usada também para interagir com pinos de entrada e saída Rapsberry (GPIO)

Mas, meu objetivo era conectar meu tank wi-fi de qualquer dispositivo (PC, celular, tablet …) usando um navegador da web comum e também transmitir vídeo a partir dele. Portanto, esqueça o Python por enquanto e vamos prosseguir no NODE. JS e no SOCKET. IO.

NODE.js

Node.js (https://github.com/nodejs/node/wiki) é um framework de servidor de código aberto baseado na linguagem js. Como estou usando Raspberry Pi Zero (CPU ARMv6), não podemos usar o processo de instalação automática (destinado à CPU ARMv7) e precisamos fazê-lo manualmente:

Baixe o Nodejs localmente (usei a versão 7.7.2 para ARMv6, verifique outras versões aqui

pi @ framboesa: ~ $ wget

nodejs.org/dist/v7.7.2/node-v7.7.2-linux-…

Uma vez feito isso, extraia o arquivo compactado:

pi @ raspberry: ~ $ tar -xzf node-v7.7.2-linux-armv6l.tar.gz

Copie e instale os arquivos em / user / local

pi @ raspberry: ~ $ sudo cp -R node-v7.7.2-linux-armv6l / * / usr / local /

Adicione o local onde instalamos o nodejs ao caminho, edite o arquivo “.profile”:

pi @ framboesa: ~ $ nano ~ /.profile

Adicione a seguinte linha no final do arquivo, salve e saia

PATH = $ PATH: / usr / local / bin

Remova o arquivo baixado:.

pi @ raspberry: ~ $ rm ~ / node-v7.7.2-linux-armv6l.tar.gz

pi @ raspberry: ~ $ rm -r ~ / node-v7.7.2-linux-armv6l

Digite os seguintes comandos para verificar a instalação do nodejs:

pi @ framboesa: ~ $ node -v

pi @ framboesa: ~ $ npm -v

Você deve ler v7.7.2 e v4.1.2 como resposta.

Se tudo correu bem, crie uma nova pasta para hospedar seus arquivos nodejs:

pi @ raspberry: ~ $ mkdir nodehome

Mova dentro da nova pasta:

pi @ raspberry: ~ $ cd nodehome

Instale o módulo adicional necessário para gerenciar GPIO da maneira mais básica, LIGADO e DESLIGADO:

pi @ raspberry: ~ $ npm instalar onoff

Agora é hora de testar nosso primeiro projeto “Blink.js”, o resultado será … um LED piscando

pi @ framboesa: ~ $ nano blink.js

Cole o seguinte código, salve e saia:

var Gpio = requer ('onoff'). Gpio; // incluir onoff

var LED = novo Gpio (3, 'fora'); // use GPIO 3

var blinkInterval = setInterval (blinkLED, 250);

// pisca o LED a cada 250 ms

function blinkLED () {// função para começar a piscar

E se

(LED.readSync () === 0) {// verifique o estado do pino, se o estado é 0 (ou desligado)

LED.writeSync (1);

// define o estado do pino para 1 (liga o LED)

} outro {

LED.writeSync (0);

// define o estado do pino para 0 (desligue o LED)

}

}

function endBlink () {// função para parar de piscar

clearInterval (blinkInterval); // Interrompe os intervalos de piscar

LED.writeSync (0); // Desligue o LED

LED.unexport (); // Desexportar GPIO para liberar recursos

}

setTimeout (endBlink, 5000); // para de piscar após 5 segundos

Conecte um LED, um resistor (200 ohms) conforme mostrado no esquema e execute o projeto:

pi @ raspberry: ~ $ node blink.js

O Node está pronto.

SOCKET. IO

WebSocket é um protocolo de comunicação de computador, baseado em conexão TCP, que fornece ao programador a criação de um servidor e cliente. O cliente se conecta ao servidor e emite e recebe mensagens de e para o servidor. A implementação de WebSocket para Node.js é chamada de Socket.io (https://socket.io/).

Instale socket.io:

pi @ raspberry: ~ $ npm install socket.io --save

Mova-se para dentro da casa do nodejs, criada anteriormente:

pi @ raspberry: ~ $ cd nodehome

E crie uma nova pasta “pública”:

pi @ raspberry: ~ $ mkdir public

Crie um novo servidor da web de amostra, chame-o de “webserver.js”

pi @ raspberry: ~ $ nano webserver.js

Cole o seguinte código, salve e saia:

var http = require ('http'). createServer (handler); // requer servidor http e cria o servidor com a função handler ()

var fs = requer ('fs'); // requer módulo de sistema de arquivos

http.listen (8080); // escuta a porta 8080

manipulador de função (req, res) {// criar servidor

fs.readFile (_ dirname + '/public/index.html', function (err, data) {// ler

arquivo index.html na pasta pública

if (err) {

res.writeHead (404, {'Tipo de conteúdo': 'text / html'}); // exibe 404 em caso de erro

return res.end ( 404 Não

Encontrado );

}

res.writeHead (200, {'Content-Type': 'text / html'}); // escrever HTML

res.write (dados); // escrever dados

de index.html

return res.end ();

});

}

Este servidor da Web ouvirá sua porta Raspberry 8080 e fornecerá arquivos para qualquer cliente da Web que o conecte. Agora precisamos criar algo para hospedar e fornecer aos nossos clientes: Mova dentro da pasta “public”: pi @ raspberry: ~ $ cd public

Crie um novo arquivo html “index.html”:

pi @ raspberry: ~ $ nano index.html

Cole o código do arquivo "HelloWorld.txt" em anexo, salve e saia.

Mova dentro da pasta nodejs "nodehome":

pi @ raspberry: ~ $ cd nodehome

Inicie o servidor da web

pi @ raspberry: ~ $ node webserver.js

Abra o site em um navegador usando https:// Raspberry_IP: 8080 / (substitua Raspberry_IP pelo seu IP)

Etapa 6: ADICIONAR CAPACIDADE DE TRANSMISSÃO DE VÍDEO

Existem diferentes maneiras de implementar o streaming de vídeo em um Raspberry, o mais fácil

forma que descobri até agora, que como ótimo desempenho e pode ser integrado em uma interface web se baseia no projeto de Miguel Mota:

miguelmota.com/blog/raspberry-pi-camera-bo…

Obrigado Miguel! De seu blog, estas são as etapas:

Instale os componentes libjpeg8 e cmake:

pi @ raspberry: ~ $ sudo apt-get install libjpeg8

pi @ raspberry: ~ $ sudo apt-get install libjpeg8-dev

pi @ raspberry: ~ $ sudo apt-get install cmake

Baixe o mjpg-streamer com o plugin raspicam:

pi @ framboesa: ~ $ git clone

github.com/jacksonliam/mjpg-streamer.git ~ / mjpg-streamer

Alterar diretório:

pi @ raspberry: ~ $ cd ~ / mjpg-streamer / mjpg-streamer-experimental

Compilar:

pi @ framboesa: ~ $ make clean all

Substitua o streamer de-j.webp

pi @ raspberry: ~ $ sudo rm -rf / opt / mjpg-streamer

pi @ raspberry: ~ $ sudo mv ~ / mjpg-streamer / mjpg-streamer-experimental

/ opt / mjpg-streamer

pi @ framboesa: ~ $ sudo rm -rf ~ / mjpg-streamer

Crie um novo arquivo “start_stream.sh”, copie e cole do arquivo "start_stream.txt" anexado.

Torne-o executável (crie scripts de shell):

pi @ raspberry: ~ $ chmod + x start_stream.sh

Inicie o servidor de streaming:

pi @ raspberry: ~ $./start_stream.sh

Abra o site em um navegador usando https:// Raspberry_IP: 9000 (substitua Raspberry_IP pelo seu IP)

Etapa 7: PROGRAMA DE TANQUE

Está tudo pronto, agora temos que criar nossa página web para controlar o tanque (index.html) e nosso servidor web para escutar nossos comandos (webserver.js). Portanto, basta substituir os arquivos vistos até agora (apenas exemplos para testar o sistema) com o webserver.txt e index.txt anexados.

Etapa 8: INICIE A INTERFACE DE CONTROLE E O SERVIDOR DE STREAMING

Para iniciar os serviços, abra duas janelas de terminal e execute estes comandos:

node nodehome / webserver.js

./nodehome/start_stream.sh

Abra o site em um navegador usando https:// Raspberry_IP: 8080 (substitua Raspberry_IP pelo seu IP)