Sistema Portátil de Câmera de Vigilância Remota

Componentes e Materiais

SparkFun Arduino Pro Mini 328 – 5V/16MHz	1
Pneu + Motor DC com Redutor + Suporte	1
Driver de Motor Dual H-Bridge L298 SparkFun	1
Raspberry Pi 3 Model B	1
Módulo Câmera Raspberry Pi	1

Ferramentas e Máquinas Necessárias

Adaptador USB para Serial FTDI FT232RL

Arduino IDE

Furadeira

Serra de Lâmina Fina

Chaves de Fenda

Ferro de Solda (genérico)

Cortador de Fios

Sobre o Projeto

Este projeto interessante, mas complicado, cobrirá coisas desde o design e construção de um robô, até configurações avançadas no Linux (Raspberry Pi) para construir um aplicativo Android e controlar o robô.

Dito isso, é mais ambicioso que os projetos médios, mas acho que você terá muito o que aprender examinando algumas ideias aqui ou até replicando o projeto inteiro.

Primeiro, construiremos o robô usando acrílico, chapas plásticas, motores DC com redutores e vários componentes eletrônicos. O dispositivo será capaz de mover independentemente as duas rodas dianteiras e poderá usar seu farol. Então, vamos configurar o Raspberry Pi alimentando o robô e configurar o projeto e instalar várias dependências. Depois, vamos construir e instalar um app Android e usá-lo para controlar o robô remotamente usando a câmera e uma conexão WiFi.

As tecnologias e conceitos que exploraremos aqui:

Plataformas de desenvolvimento: Arduino, Raspberry Pi, Android
Eletrônica: H-bridge, usando transistor para acionar carga grande, sensores infravermelhos
Linux: usando Docker, Docker Compose, configurando serviços com systemctl, streaming de vídeo
Programação: Aplicações Android, Python, linguagem Arduino, comunicação serial, MQTT

Passo 1: Coisas Necessárias

Sistema Portátil de Câmera de Vigilância Remota

Peças:

Chapa de acrílico
Chapa plástica (também pode usar chapa de acrílico aqui)
Cola
Pneu + Motor DC com redutor + suporte. Pequenas porcas e parafusos, espaçadores hexagonais de metal
2x roda omnidirecional
Pequena lanterna LED (será transformada em farol)
Arduino Pro Mini 328p
2x sensor de obstáculo infravermelho
PCB
Transistor NPN (para acionar o farol)
Regulador L7805CV 5V
H-bridge L298
Resistor 220 Ohms
Conector USB macho
Conector Micro USB macho
Vários fios
Regulador 3.3V (para comunicação entre Arduino e Raspberry Pi)
Conectores PCB macho e fêmea
Interruptor Liga/Desliga
Conector XT-60 fêmea LiPo
Bateria LiPo 2S 1300 mAh com conector XT-60
Power bank 5V
Raspberry Pi 3
Cartão Raspberry Pi
Case Raspberry Pi
Câmera Raspberry Pi

Ferramentas:

Adaptador USB para serial FTDI FT232RL para programar o Arduino Pro Mini
Arduino IDE
Furadeira
Serra de lâmina fina
Chaves de fenda
Ferro de solda
Cortador de fios

Habilidades:

Soldagem, confira este tutorial
Programação básica Arduino, este tutorial pode ser útil
Configuração de serviços Linux, instalação de pacotes

Passo 2: Construindo a Plataforma do Robô

O robô que vamos construir terá as seguintes especificações:

Terá tração nas rodas dianteiras por dois motores DC separados
As rodas traseiras devem poder mover-se em qualquer direção 360 graus
A direção será controlada variando a velocidade nas rodas dianteiras, então nenhum mecanismo de direção separado é necessário; também o robô poderá girar no próprio eixo
Terá luzes na parte superior
Deve ter espaço suficiente para eletrônica, baterias, e um case Raspberry Pi com câmera
Alguns cm de folga do solo são necessários para superar pequenos obstáculos

Não esqueça de verificar as imagens para detalhes importantes e dicas de construção.

Vamos construir o robô a partir de acrílico ou plástico rígido, usei ambos mas você pode escolher o que quiser.

A placa base será 18 x 13 cm. Na placa base, os motores DC serão fixados com suportes metálicos, porcas e parafusos. O H-bridge será montado no meio da placa voltado para o chão. As rodas traseiras serão fixadas usando espaçadores hexagonais metálicos de 2 cm (um lado macho, um lado fêmea).

Um furo grande perto do H-bridge é necessário para conectar a eletrônica no lado superior.

A parte superior do robô consistirá em duas placas em formato "L", uma será 12 x 13 cm e a outra 6,5 x 13 cm. As placas plásticas serão coladas juntas. Estas placas fornecerão cobertura para a eletrônica, um local para montar o farol e um suporte para o case do Raspberry Pi. A parte superior será fixada à parte inferior usando espaçadores hexagonais metálicos de 6 cm.

Passo 3: Construindo a Eletrônica

Pinout (Arduino):

Farol LED: D3
Motor Esquerdo: PWM (D5), EN1, EN2 (A4, A5)
Motor Direito: PWM (D6), EN1, EN2 (A3, A2)
Sensores Infravermelhos: Frente (A0), Trás (A1)
Pinos comunicação Raspberry Pi: Tx: D11, Rx: D10

Construindo a PCB, Montagem

1. No passo anterior já acomodamos o H-bridge no lado do chão do robô. Também precisaremos instalar os dois sensores infravermelhos, um na frente e um atrás. Vamos montá-los no chassi usando uma pequena chapa metálica. A chapa metálica será em formato "L", e terá dois furos. Usando porcas e parafusos, vamos instalá-la no chassi. Os sensores ficarão no meio do chassi, um na frente e um atrás.

2. Próxima a parte do farol, usei uma lanterna LED de 5 volts para isso. Cortei o farol expondo apenas a parte da "cabeça" e soldei dois fios para alimentá-lo. Então colei o farol no meio da parte superior do robô e furei um buraco perto do farol para passar os cabos e soldei um pequeno conector fêmea de dois fios nele.

3. Montando o case do Raspberry Pi. Você precisará de um Raspberry Pi, uma câmera Pi, cartão de memória de pelo menos 4 GB, um conector de câmera Pi. Insira o cartão com o último Raspbian instalado, então pegue o conector da câmera Pi, insira-o cuidadosamente no Raspberry Pi, então insira na câmera, então feche o case.

Se você não sabe como instalar o sistema operacional Raspbian, verifique este link.

Para mais informações sobre como instalar a câmera e habilitá-la, verifique este artigo oficial.

4. Construindo a PCB com os componentes eletrônicos principais. Anexei os esquemáticos Fritzing em formato fzz e como imagem. Você pode usá-lo como referência de como construir a eletrônica.

Passos de Soldagem:

a. Corte os conectores PCB fêmea, há dois conectores de 12 pinos para o microcontrolador e dois conectores de 5 pinos, há dois conectores de 3 pinos para os sensores IR, um conector de 6 pinos para o H-bridge e um conector de pino para comunicação Raspberry Pi (terra, TX, RX)

b. Após todos os conectores serem cortados, devem ser soldados no verso da PCB

c. Solde o conector KF301-2P

d. Solde o transistor NPN e o resistor correspondente à sua base

e. Solde o regulador L7805CV 5V

f. Solde o regulador de 3.3 volts na linha TX do Arduino para Raspberry Pi

g. Solde os pinos machos no Arduino Pro Mini

h. Solde todos os fios finos vermelho(+), preto(-), e branco(sinal) de acordo com o esquemático Fritzing

i. Solde um conector macho na protoboard para o farol

5. Conectores

a. Construa um conector do power bank 5V USB para o Raspberry Pi e Arduino, você precisará de um conector USB macho tipo A, um conector micro USB macho, fios preto e vermelho, tubo termorretrátil e um conector protoboard fêmea-fêmea. Primeiro corte o conector fêmea-fêmea em duas partes, estas partes irão nos pinos macho negativo e positivo do Arduino. O conector USB tipo A enviará energia para o Arduino e também para o Raspberry Pi usando um conector micro USB. Verifique as imagens para dicas de soldagem USB.

b. Construa o conector para a bateria LiPo para a placa eletrônica, você precisará de um conector XT-60 fêmea LiPo, fios vermelho e preto, tubo termorretrátil e um pequeno interruptor capaz de lidar com 10A. O fio preto será conectado diretamente do XT-60 à placa eletrônica (conector parafuso KF301-2P), o fio vermelho será conectado através do pequeno interruptor

c. Conecte os dois sensores IR do robô aos conectores fêmea correspondentes na PCB usando conectores protoboard fêmea-macho

d. Conecte o H-bridge aos conectores fêmea de 6 pinos na PCB usando conectores protoboard macho-fêmea

e. Conecte os terminais positivo e negativo dos motores ao H-bridge

f. Conecte a alimentação principal do H-bridge ao conector parafuso KF301-2P na PCB

6. Antes de colocar o Arduino na PCB, verifique tudo usando uma lupa e um multímetro

Passo 4: Código Arduino

Primeiro preciso responder uma pergunta importante: Por que uma camada intermediária Arduino tem que existir e não conectar diretamente o Pi à eletrônica?

É mais modular, você pode reutilizar o robô Arduino em outro projeto sem o Pi
Por segurança, é mais barato substituir um Arduino Pro Mini de $3 do que substituir um Pi ($35)
Um Arduino não é interrompido pelo sistema operacional como o Pi, então é mais eficiente implementar controles PWM para os motores, fazer polling dos sensores frontal e traseiro algumas vezes por segundo
Se um erro ocorrer no script Python, o robô pode rodar para sempre drenando as baterias e provavelmente danificando-o ou pegando fogo se não supervisionado, em um sketch Arduino uma proteção é mais confiável porque não depende de um sistema operacional
É mais fácil depurar um sistema desacoplado

Ok, então cobri a parte do Porquê, vou explicar o sketch Arduino um pouco. Basicamente faz duas coisas:

1. Recebe comandos de motor e luz da linha serial e aciona os motores ou alterna a luz

Por exemplo:

"M:-25:16;" significa (-25 esquerda), e (16 potência), traduz para motor esquerdo 17% e motor direito 32%, direção frente
"M:44:19;" significa (44 direita) e (19 potência) traduz para: motor esquerdo 38%, motor direito 5% e direção frente
"L:1;" significa luzes ligadas e "L:0" luzes desligadas

2. Faz polling dos sensores infravermelhos da frente e traseira do robô e envia dados de distância pela linha serial

Primeiro você precisará baixar e instalar esta biblioteca:

O código principal está localizado no repositório GitHub aqui, ou você pode copiar e colar abaixo.

Carregue o código no Arduino usando um adaptador FTDI. Agora você pode dar comandos ao robô para vê-lo funcionar, para isso basta conectar a segunda linha serial e enviar comandos de motor ou luz através dela. Uma forma de fazer isso é usando um módulo Bluetooth como HC-05 e conectá-lo a um telefone usando um aplicativo Bluetooth. Então dê comandos seriais como "L:1"

// source for TextMotorCommandsInterpretter: "https://github.com/danionescu0/arduino/tree/master/libraries/TextMotorCommandsInterpretter"
#include <SoftwareSerial.h>
#include <TextMotorCommandsInterpretter.h>

const char MOTOR_COMMAND = 'M';
const char LIGHT_COMMAND = 'L';

/**
 * quanto tempo o comando de motor terá efeito em ms
 * um comando de motor entrante durará no máximo maxDurationForMottorCommand
 * se não for reiniciado por outro comando de motor
 */
const long maxDurationForMottorCommand = 300;
// ajuste este valor para limitar velocidade do robô
const byte maxPwmValue = 230;

// Quanto tempo entre transmissões sucessivas de distância em ms
const long transmitingInterval = 500;

const int maxObstacleDetection = 1000; // leitura analógica max detecção
const int minObstacleDetection = 500;  // leitura analógica min detecção

const byte FLASH_PIN = 3;
const byte RIGHT_MOTOR_PWM_PIN = 5;
const byte RIGHT_MOTOR_EN1_PIN = A4;
const byte RIGHT_MOTOR_EN2_PIN = A5;
const byte LEFT_MOTOR_PWM_PIN = 6;
const byte LEFT_MOTOR_EN1_PIN = A3;
const byte LEFT_MOTOR_EN2_PIN = A2;
const byte FRONT_DISTANCE_SENSOR = A0;
const byte BACK_DISTANCE_SENSOR = A1;

SoftwareSerial masterComm(11, 10); // RX, TX
TextMotorCommandsInterpretter motorCommandsInterpretter(-50, 50, -50, 50);

String currentCommand;
long lastCheckedTime;
long lastTransmitTime;
boolean inMotion = false;

void setup() {
  Serial.begin(9600);
  masterComm.begin(9600);
  masterComm.setTimeout(10);
  pinMode(FLASH_PIN, OUTPUT);
  pinMode(LEFT_MOTOR_PWM_PIN, OUTPUT);
  pinMode(LEFT_MOTOR_EN1_PIN, OUTPUT);
  pinMode(LEFT_MOTOR_EN2_PIN, OUTPUT);
  pinMode(RIGHT_MOTOR_PWM_PIN, OUTPUT);
  pinMode(RIGHT_MOTOR_EN1_PIN, OUTPUT);
  pinMode(RIGHT_MOTOR_EN2_PIN, OUTPUT);
  lastCheckedTime = millis();
  lastTransmitTime = millis();
}

void loop() {
  if (masterComm.available() > 0) {
    currentCommand = masterComm.readString();
    processCommand();
  }
  if (inMotion && millis() - lastCheckedTime > maxDurationForMottorCommand) {
    stopMotors();
  }
  if (millis() - lastTransmitTime > transmitingInterval) {
    lastTransmitTime = millis();
    masterComm.print(getObstacleData());
    Serial.print(analogRead(BACK_DISTANCE_SENSOR));Serial.print("---");
    Serial.println(getObstacleData());
  }
  /* FOR DEBUG
  motorCommandsInterpretter.analizeText("M:-14:40;");
  Serial.write("Left==");Serial.println(motorCommandsInterpretter.getPercentLeft());
  Serial.write("Right==");Serial.println(motorCommandsInterpretter.getPercentRight());
  delay(10000);
  */
}

String getObstacleData() {
  int frontDistance = analogRead(FRONT_DISTANCE_SENSOR);
  int backDistace = analogRead(BACK_DISTANCE_SENSOR);
  frontDistance = map(frontDistance, maxObstacleDetection, minObstacleDetection, 0, 10);
  backDistace = map(backDistace, maxObstacleDetection, minObstacleDetection, 0, 10);
  return String("F=" + String(frontDistance) + ":B=" + String(backDistace) + ";");
}

void processCommand() {
  switch (currentCommand.charAt(0)) {
    case (MOTOR_COMMAND):
      steerCar();
      break;
    case (LIGHT_COMMAND):
      toggleLight(currentCommand.charAt(2));
      break;
  }
}

void steerCar() {
  motorCommandsInterpretter.analizeText(currentCommand);
  float percentLeftMotor = motorCommandsInterpretter.getPercentLeft();
  float percentRightMotor = motorCommandsInterpretter.getPercentRight();
  Serial.write("Left=");Serial.println(percentLeftMotor);
  Serial.write("Right=");Serial.println(percentRightMotor);
  setMotorsDirection(motorCommandsInterpretter.getDirection());
  analogWrite(LEFT_MOTOR_PWM_PIN, percentLeftMotor * maxPwmValue);
  analogWrite(RIGHT_MOTOR_PWM_PIN, percentRightMotor * maxPwmValue);
  inMotion = true;
  lastCheckedTime = millis();
}

void setMotorsDirection(boolean forward) {
  if (forward) {
    digitalWrite(LEFT_MOTOR_EN1_PIN, HIGH);
    digitalWrite(LEFT_MOTOR_EN2_PIN, LOW);
    digitalWrite(RIGHT_MOTOR_EN1_PIN, HIGH);
    digitalWrite(RIGHT_MOTOR_EN2_PIN, LOW);
  } else {
    digitalWrite(LEFT_MOTOR_EN1_PIN, LOW);
    digitalWrite(LEFT_MOTOR_EN2_PIN, HIGH);
    digitalWrite(RIGHT_MOTOR_EN1_PIN, LOW);
    digitalWrite(RIGHT_MOTOR_EN2_PIN, HIGH);
  }
}

void stopMotors() {
  Serial.println("Stopping motors");
  analogWrite(LEFT_MOTOR_PWM_PIN, 0);
  analogWrite(RIGHT_MOTOR_PWM_PIN, 0);
  inMotion = false;
}

void toggleLight(char command) {
  Serial.println("Toggle light");
  if (command == '1') {
    digitalWrite(FLASH_PIN, HIGH);
  } else {
    digitalWrite(FLASH_PIN, LOW);
  }
}

Passo 5: Instalando e Configurando o Projeto Raspberry Pi e Dependências

Como funciona:

a. O app Android mostra o streaming uv4l dentro de uma webview. O processo uv4l roda no Raspberry Pi, captura entrada de vídeo da câmera e faz streaming. É uma ferramenta incrível com muitos recursos.

b. Usando controles dentro do app Android, comandos de luz e motores são enviados ao servidor MQTT.

c. O servidor Python dentro do container Docker no Raspberry Pi escuta comandos MQTT e os passa usando interface serial para o Arduino. A placa Arduino controla os motores e as luzes.

d. O Arduino detecta distâncias na frente e atrás do robô e envia os dados através da interface serial para o servidor Python, o Python os encaminha para o MQTT e eles são captados pela interface Android e mostrados ao usuário.

Primeiro você precisará de um Raspbian totalmente instalado e configurado no Raspberry Pi, e a câmera precisa ser fisicamente conectada e configurada. Também toda a configuração será feita via SSH, então é bom ter isso configurado.

Não podemos cobrir todas as coisas básicas aqui, mas tente estes links se necessário:

Se você não sabe como instalar o sistema operacional Raspbian, verifique este link. Para mais informações sobre como instalar a câmera e habilitá-la, verifique este artigo oficial.

Para como configurar SSH no Raspbian, verifique isto.

Se você deseja controlar seu robô usando o app Android de fora do WiFi, deve considerar port forwarding no seu roteador WiFi, caso contrário você ficará restrito a usar seus endereços IP locais dentro do seu WiFi.

Para descobrir seu endereço IP local no Raspberry Pi use "ifconfig":

ifconfig ......... eth0 Link encap:Ethernet HWaddr b8:27:eb:16:e7:ff inet6 addr: fe80::ff00:f22f:9258:b92b/64 Scope:Link UP BROADCAST MULTICAST MTU:1500 Metric:1 RX packets:0 errors:0 dropped:0 overruns:0 frame:0 TX packets:0 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:0 (0.0 B) TX bytes:0 (0.0 B) ........ wlan0 Link encap:Ethernet HWaddr 00:c1:41:00:10:f6 inet addr:192.168.0.102 Bcast:192.168.0.255 Mask:255.255.255.0 inet6 addr: fe80::e1f4:5112:9cb2:3839/64 Scope:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:1678396 errors:0 dropped:0 overruns:0 frame:0 TX packets:381859 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes:259428527 (247.4 MiB) TX bytes:187573084 (178.8 MiB) .....

Estamos interessados no wlan0 inet addr, no nosso caso "192.168.0.102"

As portas a serem encaminhadas (padrões) são: 9090 para uv4l e 1883 para mosquitto. Você pode encaminhar estas portas para as mesmas portas de saída se não forem banidas pelo firewall do provedor de internet ou outras portas.

Port forwarding é algo feito diferentemente em cada roteador, aqui estão alguns tutoriais: este, e você também pode tentar buscar no google "port forwarding seu_modelo_roteador" para ver resultados mais relevantes.

Pré-requisitos

a. Instale git usando linha de comando

b. Clone o projeto GitHub na pasta home:

A localização da pasta é importante porque no docker-compose.yml a localização é hardcoded como: /home/pi/robot-camera-platform:/root/debug Se você precisar mudar a localização, por favor mude o valor no docker-compose também

git clone https://github.com/danionescu0/robot-camera-platform.git

c. Desative o console serial do Pi, se você não sabe como fazer isso, verifique este link

Instalar Streaming UV4L

chmod +x uv4l/install.sh
chmod +x uv4l/start.sh
sh ./uv4l/install.sh

Se isso falhar ou você precisar descobrir mais detalhes sobre uv4l, verifique este tutorial.

Configuração

a. Editando uv4l/start.sh você pode configurar os seguintes aspectos do streaming de vídeo: senha, porta, taxa de quadros, largura, altura, rotação e alguns outros aspectos menores

b. Edite config.py e substitua senha com sua própria senha que você definiu no servidor mosquitto

c. Edite docker-container/mosquitto/Dockerfile e substitua esta linha

RUN mosquitto_passwd -b /etc/mosquitto/pwfile user sua_senha

com seu próprio usuário e senha para mosquitto

d. Edite config.py e substitua porta serial e baud rate com os seus, recomendo manter o baud rate. Se quiser mudar, não esqueça de editar no sketch Arduino também

Testar instalação uv4l

a. Inicie:

sh ./uv4l/start.sh

b. Teste no navegador no endereço: https://seu_ip:9090/stream

c. Pare:

sudo pkill uv4l

Instalar Docker e Docker Compose

Sobre instalação Docker: https://www.raspberrypi.org/blog/docker-comes-to-...

Sobre instalação Docker Compose: https://www.raspberrypi.org/blog/docker-comes-to-...

Início Automático de Serviços no Reboot/Startup

Fazendo os serviços iniciarem automaticamente, você elimina a necessidade de logar manualmente via SSH e então ativar todos os serviços à mão, vamos fazer isso usando systemctl.

a. Copie os arquivos da pasta systemctl para /etc/systemd/system/

b. Habilite serviços

sudo systemctl enable robot-camera.service
sudo systemctl enable robot-camera-video.service

c. Reinicie

d. Opcional, verifique status:

sudo systemctl status robot-camera.service
sudo systemctl status robot-camera-video.service

Passo 6: Configurando e Construindo o Aplicativo Android

Quase terminamos, neste passo vamos instalar o aplicativo Android. Estes são todos os pré-requisitos:

1. Clone o projeto GitHub:

git clone https://github.com/danionescu0/android-robot-camera

Os próximos passos envolvem configurar seu ambiente, vou apenas enumerá-los e dar um link para um tutorial especializado, caso você não saiba como fazer.

2. Ative opções de desenvolvedor no seu telefone Android. Saiba mais aqui: https://developer.android.com/studio/debug/dev-opt...

3. Baixe e instale Android Studio: https://developer.android.com/studio/index.html?ut... e isto https://www.javaworld.com/article/3095406/android/...

4. Importe projeto: https://developer.android.com/studio/intro/migrate...

Agora vamos configurar as credenciais de streaming e MQTT:

5. Edite ./app/src/main/values/passwords.xml e configure MQTT e streaming

O host MQTT deve ser algo como: 1883

O host de streaming deve ser algo como:

6. Carregue e execute a aplicação

Passo 7: Usando o Robô e Depuração

Usando o App

A aplicação tem apenas uma tela principal, no lado esquerdo da tela a imagem do streaming é exibida. No lado direito estão os controles. O controle principal é um volante, toque no volante na direção que deseja que o robô mova. Abaixo do volante há um botão de farol, toque para alternar a luz.

No canto superior direito há um texto como: "- Batt Connected".

* Primeiro traço significa sem obstáculos, se houver obstáculo na frente ou atrás do robô será sinalizado com uma pequena seta apontando para frente ou para trás.
* O status "Batt" não está implementado ainda.
* "Connected" significa que o servidor MQTT está conectado então o robô pode ser usado, o outro valor possível é "Disconnected"

Depuração pode ser feita em múltiplas camadas:

1. Na camada Arduino

Conecte o adaptador FTDI à segunda linha serial ao laptop (RX no pino 11 e TX no pino 10) e envie comandos de motor e luz para ver se o robô responde a estes comandos
Verifique novamente as conexões, se os motores estão girando para trás inverta os fios de ambos motores, se um motor está girando para trás inverta seus fios
Verifique se o Arduino está conectado corretamente ao H-bridge, verifique este link para mais informações

2. Na camada Raspberry Pi

Verifique se o Docker está rodando os dois containers (mosquitto e servidor Python)

pi@raspberrypi:~ $ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
473a56da2230 dockercontainer_python-server "python /root/debu..." 9 months ago Up 4 hours dockercontainer_python-server_1
3e0b1933d310 robot-camera-mosquitto "/usr/bin/entry.sh..." 9 months ago Up 4 hours 0.0.0.0:1883->1883/tcp dockercontainer_mosquitto_1

Verifique se os processos estão rodando nas portas especificadas, você deve procurar por 9090 (streaming) e 1883 (mosquitto)

pi@raspberrypi:~ $ netstat -nltp
(Not all processes could be identified, non-owned process info will not be shown, you would have to be root to see it all.)
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:9090 0.0.0.0:* LISTEN -
tcp 0 0 0.0.0.0:5900 0.0.0.0:* LISTEN -
tcp 0 0 0.0.0.0:8080 0.0.0.0:* LISTEN -
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN -
tcp6 0 0 :::1883 :::* LISTEN -
tcp6 0 0 :::5900 :::* LISTEN -
tcp6 0 0 :::22 :::* LISTEN -

Verifique se a porta serial existe (é a correta) e está especificada no config.py do projeto

pi@raspberrypi:~ $ ls -l /dev/ttyS0
crw-rw---- 1 root dialout 4, 64 Jan 14 19:59 /dev/ttyS0

Pare o processo Docker e conecte manualmente à serial usando picocom

sudo systemctl start robot-camera.service
picocom -b 9600 /dev/ttyS0
# agora envie comandos de motor e luz para testar o robô

Verifique se o console serial está desativado no Raspberry Pi
Verifique se o streaming e MQTT estão acessíveis fora do Raspberry Pi usando um cliente mosquitto (para MQTT) e verificando o streaming em um navegador web)

3. Camada Aplicação Android

Verifique todos os passos necessários para ativar o telefone no modo depuração (confira isto)
Certifique-se de ter configurado as senhas e endpoints corretamente no passwords.xml
Verifique se o streaming e MQTT estão acessíveis fora do Raspberry Pi usando um cliente mosquitto (para MQTT) e verificando o streaming em um navegador web)
Veja o canto superior direito do app e verifique "Connected"
Use o depurador Android para verificar erros

Passo 8: Outros Casos de Uso, Estendendo o Código

Outro caso de uso é um robô seguidor de objetos. O robô seguirá um objeto de uma cor específica e limite de tamanho.

Verifique acima para o vídeo.

Como isso está fora do escopo deste tutorial, vou apenas dar algumas dicas:

Primeiro instale dependências usando pip, o processo de instalação será bastante lento

sudo pip3 install -r /home/pi/robot-camera-platform/navigation/requirements.txt

Certifique-se que Python 3.x está instalado

Em navigation/config_navigation.py você encontrará:

hsv_bounds = ( (24, 86, 6), (77, 255, 255) )
object_size_threshold = (10, 100)

HSV significa matiz, saturação, valor, e para nossa detecção de objeto por cor funcionar, tem um limite inferior e superior, a cor do nosso objeto terá que estar neste intervalo para ser detectado. Aqui você pode encontrar um detector visual de limite HSV de objeto.

Limite de tamanho do objeto significa o menor e maior raio do objeto (em porcentagens da largura) que será considerado uma detecção.

Instale e configure VNC (mais informações de como instalar VNC aqui)
Execute o script de rastreamento de objeto na interface gráfica VNC em um terminal. Isso permitirá que você visualize o vídeo, com um círculo desenhado sobre ele. O círculo significa que o objeto foi detectado.

python3 object_tracking.py colored-object --show-video

OU Execute o script de rastreamento de objeto sem saída de vídeo:

python3 object_tracking.py colored-object

Acho que a principal vantagem desta plataforma é versatilidade, pode ser adaptada facilmente a outros usos interessantes, algumas das minhas ideias:

Seguir uma pessoa por reconhecimento facial
Patrulhar e reportar movimento
Substituir o WiFi por um modem 3G e o robô pode ser controlado externamente, talvez explorando zonas perigosas

Sendo este um projeto muito complexo, assumo que haverá erros, apreciarei se você me perguntar qualquer coisa na área de comentários.

Se você gostou do meu projeto, inscreva-se no meu canal do YouTube para mais coisas interessantes.

Código

Aplicação Android

https://github.com/danionescu0/android-robot-camera

Repositório principal para código Arduino, Python

https://github.com/danionescu0/robot-camera-platform

Esquemáticos

sketch_nWf7cZeUWL.fzz

Repositório principal para código Arduino, Python

O repositório principal
https://github.com/danionescu0/robot-camera-platform

Aplicação Android

https://github.com/danionescu0/android-robot-camera

Globo POV DIY: Arte LED com Arduino Mega – Persistência da Visão Medição Automática de Temperatura com Alertas de Voz

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial