Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Câmera de vigilância remota móvel

Componentes e suprimentos

SparkFun Arduino Pro Mini 328 - 5 V / 16 MHz
× 1
Pneu + motor CC com caixa de engrenagens + suporte
× 1
Drivers de motor SparkFun Dual H-Bridge L298
× 1
Raspberry Pi 3 Modelo B
× 1
Módulo de câmera Raspberry Pi
× 1

Ferramentas e máquinas necessárias

USB para adaptador FTDI serial FT232RL
Arduino IDE
Drill
Serra de lâmina fina
Chaves de fenda
Ferro de soldar (genérico)
Cortador de fio

Sobre este projeto




Este projeto interessante, mas complicado, cobrirá desde o projeto de construção de um robô, até configurações avançadas em Linux (raspberry pi), até a construção de um aplicativo Android e controle do robô.

Dito isso, é mais ambicioso do que os projetos comuns, mas acho que você terá muito a aprender examinando algumas ideias aqui ou mesmo replicando o projeto inteiro.

Primeiro, vamos construir o robô usando plexiglass, folhas de plástico, motores DC com caixas de engrenagens e vários componentes eletrônicos. O dispositivo será capaz de mover de forma independente as duas rodas dianteiras e poderá usar seu farol. Em seguida, vamos configurar o raspberry pi alimentando o robô e configurar o projeto e instalar várias dependências. Em seguida, vamos construir e instalar um aplicativo Android e usá-lo para controlar o robô remotamente usando a câmera e uma conexão wi-fi.

As tecnologias e conceitos serão explorados aqui :

Plataformas de desenvolvimento:Arduino, Raspberry pi, Android

Eletrônica:ponte H, usando um transistor para conduzir uma grande carga, sensores infravermelhos

Linux:usando docker, docker compose, configurando serviços usando systemctl, streaming de vídeo

Programação:aplicativos Android, python, linguagem arduino, comunicação serial, MQTT





Etapa 1:Coisas necessárias


Partes:

1. Folha de acrílico

2. Folha de plástico (você também pode usar uma folha de acrílico aqui)

3. cola

4. Pneu + motor DC com caixa de engrenagens + suporte. Porcas e parafusos pequenos, espaçadores hexagonais de metal

6. 2 x qualquer pneu de roda direcional

7. Lanterna LED pequena (será transformada em farol)

8. Arduino pro mini 328p

9. 2 x sensor de obstáculo infravermelho

10. PCB

11. tranzistor NPN (para acionar a lanterna)

12. Regulador L7805CV 5V

13. Ponte H L298

14. Rezistor 220 Ohms

15. Conector usb macho

16. Conector micro usb macho

17. Vários fios

18. Regulador de 3 V (para comunicação entre Arduino e Raspberry Pi)

19. Conectores PCB macho e fêmea

20. Botão liga / desliga

21. Conector LiPo fêmea XT-60

22. Bateria LiPo 2S 1300 mAh com conector XT-60

23. bateria 5v

24. Raspberry Pi 3

25. Cartão Raspberry Pi

26. Estojo Raspberry Pi

27. Câmera Raspberry Pi

Ferramentas: 1. USB para adaptador FTDI serial FT232RL para programar o arduino pro mini

2. Arduino IDE

3. Exercício

4. Serra de lâmina fina

5. Chaves de fenda

6. Ferro de soldar

7. Cortador de fio

Habilidades:

1. Solda, verifique este tutorial

2. Programação básica do Arduino, este tutorial pode ser útil

3. Configuração de serviço Linux, instalação de pacote





Etapa 2:Construindo a plataforma do robô


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

- Terá tração nas rodas dianteiras por dois motores DC separados

- as rodas traseiras devem ser capazes de se mover em qualquer direção 360 graus

- a direção será controlada pela variação da velocidade nas rodas dianteiras, de modo que nenhum mecanismo de direção separadamente é necessário, também o robô será capaz de girar no local

- terá luzes no topo

- deve ter espaço suficiente para os eletrônicos, baterias e uma caixa de pi framboesa com uma câmera

- alguns centímetros de distância ao solo são necessários para superar pequenos obstáculos

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

Vamos construir o robô em acrílico ou plástico rígido, usei os dois, mas você pode escolher o que quiser.

A placa de base terá 18 x 13 cm na placa de base e os motores DC serão fixados com porcas e parafusos de suporte de metal. A ponte H será montada no meio da placa voltada para o chão. As rodas traseiras serão fixadas com espaçadores hexagonais de metal de 2 cm (um lado macho e um lado fêmea)

Um grande orifício próximo à ponte H é necessário para conectar os componentes eletrônicos na parte superior.

A parte superior do robô será composto por duas placas em “L” uma terá 12 x 13 cm e a outra 6,5 ​​x 13 cm. As placas de plástico serão coladas umas às outras. Essas placas fornecerão cobertura para a parte eletrônica, local para montagem do farol e suporte para a caixa do raspberry pi. A parte superior será fixada na parte inferior usando espaçadores de metal hexagonais de 6 cm)





Etapa 3:Construindo a Eletrônica





Pinagem (arduino):


Lanterna Led:D3

Motor esquerdo:PWM (D5), EN1, EN2 (A4, A5)

Motor direito:PWM (D6), EN1, EN2 (A3, A2)

Sensores infravermelhos:Frente (A0), Traseiro (A1)

Pinos de comunicação do Raspberry Pi:Tx:D11, Rx:D10





Construindo o PCB, montagem


1. Na última etapa, já acomodamos a ponte H no lado do chão do robô. Também precisaremos instalar os dois sensores infravermelhos um na frente e outro atrás. Vamos montá-los no chassi usando uma pequena placa de metal. A placa de metal terá a forma de um "L" e terá dois orifícios. Usando porcas e parafusos, vamos instalá-lo no chassi. Os sensores ficarão no meio do chassi, um na frente e outro atrás.

2. Próximo ao farol parte, eu usei uma lanterna led de 5 volts para isso. Cortei o farol expondo apenas a parte da "cabeça" e soldei dois fios para ligá-lo. Em seguida, colei o farol no meio da parte superior do robô e fiz um orifício perto do farol, coloquei os cabos através do orifício e soldei um pequeno conector fêmea de dois fios nele.

3. Montando a caixa de framboesa pi. Você vai precisar de um raspberry pi, uma câmera pi, um cartão de memória de pelo menos 4 GB e um conector de câmera pi. Insira o cartão com o Raspian mais recente instalado, pegue o conector da câmera pi insira-o com cuidado no pi raspberry, insira-o na câmera e feche a caixa.

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

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

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

Etapas de soldagem:

a. Corte os conectores PCB fêmea, existem dois conectores de 12 pinos para o microcontrolador e dois conectores de 5 pinos, existem dois conectores de 3 pinos para os sensores IR, um conector de seis pinos para a ponte H e um conector de pino para a comunicação raspberry pi (terra, TX, RX) b. Depois que todos os conectores são cortados, eles devem ser soldados na parte traseira do PCB

c. Solde o conector KF301-2P

d. Solde o tranzistor NPN e o resistor correspondente em sua base

e. Solde o regulador L7805CV 5V

f. Solde o regulador de 3,3 volts na linha Arduino para raspeberry pi TX

g. Solde os pinos machos no arduino pro mini

h. Solde todos os fios finos vermelho (+), preto (-) e branco (sinal) de acordo com o esquema de Fritzig

i. Solde um conector macho para a placa de ensaio para a lanterna

5. Conectores

a. Construa um conector do pacote de bateria 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 de placa de ensaio fêmea para fêmea. Primeiro corte o conector fêmea para fêmea em dois, essas partes irão para os 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 de usb.

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

c. Conecte os dois sensores IR do robô aos conectores fêmeas correspondentes no PCB usando conectores de placa de ensaio macho - fêmea

d. Conecte a ponte H aos conectores fêmea de 6 pinos ao PCB usando conectores de placa de ensaio macho - fêmea

e. Conecte os terminais positivo e negativo do motor à ponte H

f. Conecte a fonte de alimentação principal da ponte H ao conector de parafuso KF301-2P no PCB

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





Etapa 4:Código Arduino


Primeiro, preciso responder a uma pergunta importante: Por que uma camada intermediária de arduino deve existir e não conectar diretamente o Pi à eletrônica?

1. É mais modular, você pode reutilizar o robô arduino em outro projeto sem o PI

2. Por segurança, é mais barato substituir um arduino pro mini de 3 $ do que substituir um Pi (35 $)

3. Um arduino não é interrompido pelo sistema operacional como o pi, por isso é mais eficiente implementar controladores PWM para os motores, pesquisando os sensores frontal e traseiro algumas vezes por segundo

4. Se um erro ocorrer no script python, o robô pode funcionar para sempre esgotando as baterias e provavelmente danificando-as ou pegando fogo se não for supervisionado, em um esboço do Arduino, uma proteção é mais confiável porque não depende de um sistema operacional

5. É mais fácil depurar um sistema desacoplado

Ok, então cobrimos a parte do porquê, explicarei um pouco o esboço do Arduino. Basicamente, ele faz duas coisas:

1. Ele recebe comandos de motor e luz da linha serial e acionar os motores ou alternar a luz

Por exemplo:

* " M:-25:16; "significa (-25 esquerda) e (potência 16), será convertido para o motor esquerdo 17% e o motor direito 32% e direção para frente *" M:44:19; "significa (44 para a direita) e (potência 19) que se traduzirá em:motor esquerdo 38%, motor direito 5% e direção para frente

* " L:1; "significa luzes e" L:0 " luzes desligadas

2. Ele pesquisa os sensores infravermelhos da parte de trás e da frente do robô e envia dados sobre distâncias através da 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.

Faça upload do código para o 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 motor ou luz através dela. Uma maneira de fazer isso é usar um módulo bluetooth como o HC-05 e conectá-lo a um telefone usando um aplicativo bluetooth. Em seguida, forneça comandos seriais como "L:1"
  // fonte para TextMotorCommandsInterpretter:"https://github.com/danionescu0/arduino/tree/master/libraries/TextMotorCommandsInterpretter" #include  #include  const MOTOR_CANDM> const char ='M'; const char LIGHT_COMMAND ='L'; / ** * quanto tempo o comando do motor terá efeito em ms * um comando do motor incomming durará para maxDurationForMottorCommand * se não for reinicializado por outro comando do motor * / const long maxDurationForMottorCommand =300; // ajuste este valor para limitar a velocidade do robô const byte maxPwmValue =230; // Quanto tempo entre as transmissões de distância sucessivas em ms const long transmitingInterval =500; const int maxObstacleDetection =1000; // valor de detecção máximo de leitura analógica const int minObstacleDetection =500; // valor mínimo de detecção de leitura analógica const byte FLASH_PIN =3; byte const RIGHT_MOTOR_PWM_PIN =5; byte const 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 ()); } / * PARA 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 (); pausa; case (LIGHT_COMMAND):toggleLight (currentCommand.charAt (2)); pausa; }} 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 =verdadeiro; 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 ("Parando motores"); analogWrite (LEFT_MOTOR_PWM_PIN, 0); analogWrite (RIGHT_MOTOR_PWM_PIN, 0); inMotion =falso; } void toggleLight (comando char) {Serial.println ("Alternar luz"); if (comando =='1') {digitalWrite (FLASH_PIN, HIGH); } else {digitalWrite (FLASH_PIN, LOW); }}  





Etapa 5:Instalando e configurando o projeto Raspberry Pi e dependências


Como funciona:





Você verá um diagrama do que tentarei explicar acima nas imagens anexas.

a. O aplicativo Android mostra o streaming uv4l dentro de um webview. O processo uv4l é executado no raspberry pi, captura a entrada de vídeo da câmera e o transmite. É uma ferramenta incrível com muitos recursos

b. Usando controles dentro das luzes do aplicativo Android e os comandos do mecanismo são emitidos para o servidor MQTT

c. O servidor python dentro do contêiner docker no raspberry pi escuta os comandos MQTT e os transmite usando a 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 por meio da interface serial para o servidor python, o python os encaminha para o MQTT e eles são captados pela interface do Android e mostrados ao usuário

primeiro coisa que você vai precisar de um Raspbian totalmente instalado e configurado no raspberry pi, e a câmera precisa estar psiquicamente conectada e configurada. Além disso, toda a configuração será feita usando ssh, então é uma boa coisa configurá-lo.

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 obter mais informações sobre como instalar e habilitar a câmera, consulte este artigo oficial.

Para saber como configurar o ssh no Raspbian, verifique isto.

Se você deseja controlar seu robô usando o aplicativo Android de fora do wi-fi, você deve considerar o encaminhamento de porta em seu roteador wi-fi, caso contrário, você ficará restrito a usar seus endereços IP locais dentro de seu wi-fi.

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 Escopo:Link UP BROADCAST MULTICAST MTU:1500 Métrica:1 pacotes RX:0 erros:0 descartados:0 overruns:0 frame:0 pacotes TX:0 erros:0 descartados:0 overruns:0 portadora:0 colisões:0 txqueuelen:1000 RX bytes :0 (0,0 B) bytes TX: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 Máscara:255.255.255.0 inet6 addr:fe80 ::e1f4:5112:9cb2:3839/64 Escopo:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Métrica:1 pacotes RX:1678396 erros:0 descartados:0 overruns:0 frame:0 TX pacotes:381859 erros:0 descartados:0 ultrapassagens:0 operadora:0 colisões:0 txqueuelen:1000 RX bytes:259428527 (247,4 MiB) bytes de TX:187573084 (178,8 MiB) .....  

Estamos interessados ​​no addr wlan0 inet, em 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 essas portas para as mesmas portas de saída se elas não forem banidas do firewall do provedor de Internet ou de algumas outras portas.

O encaminhamento de porta é algo que é feito de forma diferente em cada roteador, aqui estão alguns tutoriais:isso, e você também pode tentar pesquisar no google " encaminhamento de porta seu_router_model "para ver resultados mais relevantes.





Pré-requisitos:


a. instalar git usando linha de comando

b. clone o projeto github na pasta inicial:

O local da pasta é importante porque em docker-compose.yml o local é codificado como:/ home / pi / robot-camera-platform:/ root / debug Se você precisar alterar o local, altere o valor em docker-compose também
  clone git https://github.com/danionescu0/robot-camera-platform.git  

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





Instale o streaming Uv4l:

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

Se isso falhar ou você precisar saber mais detalhes sobre o 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, com, altura, rotação e alguns outros aspectos menores

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

c. edite docker-container / mosquitto / Dockerfile e substitua esta linha
  EXECUTAR mosquitto_passwd -b / etc / mosquitto / pwfile user sua_password  

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

d. edite config.py e substitua a porta serial e a taxa de transmissão com a sua própria, recomendo que você mantenha a taxa de transmissão. Se você quiser mudá-lo, não se esqueça de editar isso no esboço do arduino também

Teste a instalação uv4la. Comece:
  sh ./uv4l/start.sh  

b. Teste-o no navegador no endereço:http:// your_ip:9090 / stream

c. Pare com isso
  sudo pkill uv4l  





Instale docker e docker-compose


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

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





Serviços de inicialização automática na reinicialização / inicialização


Ao fazer os serviços iniciarem automaticamente, você eliminará a necessidade de fazer login manualmente por meio do ssh e, em seguida, ativar todos os serviços manualmente, faremos isso usando o systemctl.

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

b. Habilitar serviços
  sudo systemctl enable robot-camera.service sudo systemctl enable robot-camera-video.service  

c. Reinício

d. Opcional, verifique o status:
  sudo systemctl status robot-camera.service sudo systemctl status robot-camera-video.service  





Etapa 6:Configurar e construir o aplicativo Android


Já está tudo pronto, nesta etapa 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  

The next steps involves setting up your environment, i'll just enumerate them and give a link to a specialized tutorial, in case you don't know how to do it.

2. Enable developer options on your android phone. You can find out more here:https://developer.android.com/studio/debug/dev-opt...

3. Download and install Android studio:https://developer.android.com/studio/index.html?ut... and this https://www.javaworld.com/article/3095406/android/...

4. Import project :https://developer.android.com/studio/intro/migrate...

Now we're going to configure the the streaming and MQTT credentials:

5. Edit ./app/src/main/values/passwords.xml and configure MQTT and streaming

The MQTT host should be something like:1883

The streaming host should be something like:

6. Upload and run the application





Step 7:Using the Robot and Debugging





Using the app


The application has only a main screen, in the left of the screen the streamming image is displayed. On the right

there are the controls. The main control is a steering wheel, touch the steering wheel in the direction you wish the robot to move. Below the steering wheel there is a headlight button, touch it to toggle the light.

In the top right corner there is a text like :"- Batt Connected".

* First dash means no obstacles, if there is an obstacle in front or in the back of the robot it will be signaled with a small arrow pointing in front or in the back.

* The "Batt" status is not implemented yet.

* "Connected" means that MQTT server is connected so the robot can be used, the other possible value is "Disconnected"





Debugging can be done on multiple layers:


1 On the arduino layer

- Connect the FTDI adapter to the second serial line to the laptop (RX to pin 11 and TX to pin 10) and issue motor commands and light commands to see if the robot responds to these commands

- Double check the connections, if the motors are moving backwards reverse the both motor wires, if one motor is moving backwards reverse the it's wires

- Check if the arduino is connected properly to the H-bridge, check this link for more information

2. On the rasberry pi layer

- Check docker is running the two containers (mosquitto and python server)
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  

- Check the processes are running on specified ports, you should look for 9090 (streamming) and 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 -  

- Check the serial port exists (it's the correct one) and it's specified in the project config.py
pi@raspberrypi:~ $ ls -l /dev/ttyS0 crw-rw---- 1 root dialout 4, 64 Jan 14 19:59 /dev/ttyS0  

- Stop the docker process and manually connect to serial using picocom

Then issue motor and light commands directly to see if the robot responds
sudo systemctl start robot-camera.service picocom -b 9600 /dev/ttyS0 # now issue motor and light commands to test the robot  

- Check if the serial console is deactivated on the raspberry pi

- Check the streaming and MQTT are accessible outside the raspberry pi suing a mosquitto client (for MQTT) and checking the streaming in a web browser)

3. Android application layer

- Check all the necessary steps to enable the phone into debugging mode (check this out)

- Make sure you've set up the passwords and endpoints correctly in the passwords.xml

- Check the streaming and MQTT are accessible outside the raspberry pi suing a mosquitto client (for MQTT) and checking the streaming in a web browser)

- See the top right corner of the app and check for "Connected"

- Use the android debugger to check for errors





Step 8:Other Use Cases, Extending the Code


Another use case is a object following robot .The robot will follow an object of a specific color and size threshold

Check above for the video.

Because this is out of scope of this tutorial i'll just give you some hints:

First install dependencies using pip, the installation process will be quite slow
sudo pip3 install -r /home/pi/robot-camera-platform/navigation/requirements.txt 

- make sure python 3.x is installed though

- In navigation/config_navigation.py you'll find:
 hsv_bounds =( (24, 86, 6), (77, 255, 255) ) object_size_threshold =(10, 100)  

HSV means hue saturation value, and for our color object detection to work it has a lower and an upper bound, our object color will have to be in this range to be detected. Here you can find a visual HSV object threshold detector.

Object size threshold means the smallest and the highest object radius size (in percents from width) which will be considered a detection.

- install and configure VNC (more information of how to install VNC here)

- Run the object tracking script in VNC graphical interface in a terminal. This will enable you to view the video, with a circle drawn over it. The circle means that the object has been detected.
python3 object_tracking.py colored-object --show-video  

OR Run the object tracking script with no video output:
python3 object_tracking.py colored-object 

I think the main advantage of this platform is versatility , it can be adapted easily to other interesting usages, some of my ideas:

- Following a person by face recognition

- Patrolling and reporting movement

- Replace the wifi with a 3G modem and the robot can be controlled outside, maybe exploring dangerous zones

This being a very complex project i assume that there will be errors, i will appreciate if you ask me anything in the comments area.

If you like my project please my youtube channel for more interesting stuff.

Código

Android application
https://github.com/danionescu0/android-robot-camera
Main repository for arduino, python code
https://github.com/danionescu0/robot-camera-platform

Esquemas

sketch_nWf7cZeUWL.fzz
Main repository for arduino, python code
The main repositoryhttps://github.com/danionescu0/robot-camera-platform
Android application
https://github.com/danionescu0/android-robot-camera

Processo de manufatura

  1. Câmera
  2. Lente da câmera
  3. MrRobot - Robótica habilitada para aplicativo Ubuntu Mobile (Raspberry Pi e arduino envolvidos)
  4. Robô de vigilância Roomberry:Roomba + Pi Zero + Câmera
  5. Deslizador de câmera motorizada Arduino controlado por Bluetooth
  6. Diversão do giroscópio com anel NeoPixel
  7. Controle remoto universal usando Arduino, 1Sheeld e Android
  8. Controlador de jogo Arduino
  9. Pixie:Um relógio de pulso NeoPixel baseado em Arduino
  10. Reconhecimento de fala e síntese com Arduino