Cámara de vigilancia remota móvil

Acerca de este proyecto

Este interesante pero complicado proyecto cubrirá cosas desde el diseño de la construcción de un robot, hasta configuraciones avanzadas en Linux (raspberry pi) para construir una aplicación de Android y controlar el robot.

Dicho esto, es más ambicioso que los proyectos promedio, pero creo que tendrás mucho que aprender examinando algunas ideas aquí o incluso replicando el proyecto completo.

Primero construiremos el robot usando plexiglás, láminas de plástico, motores de CC con cajas de engranajes y varios componentes electrónicos. El dispositivo podrá mover de forma independiente las dos ruedas delanteras y podrá utilizar su faro. Luego, configuraremos la raspberry pi que alimenta el robot y configuraremos el proyecto e instalaremos varias dependencias. Luego, crearemos e instalaremos una aplicación de Android y la usaremos para controlar el robot de forma remota usando la cámara y una conexión wifi.

Las tecnologías y los conceptos se explorarán aquí :

Plataformas de desarrollo:Arduino, Raspberry pi, Android

Electrónica:puente en H, que utiliza un transistor para impulsar una gran carga, sensores infrarrojos

Linux:usando docker, docker compose, configurando servicios usando systemctl, transmisión de video

Programación:aplicaciones de Android, python, lenguaje arduino, comunicación serial, MQTT

Paso 1:Cosas necesarias

Partes:

1. Lámina de plexiglás

2. Lámina de plástico (también puede usar una lámina de plexiglás aquí)

3. Pegamento

4. Neumático + motor DC con caja de cambios + soporte. Tuercas y tornillos pequeños, espaciadores metálicos hexagonales

6. 2 x cualquier neumático de rueda direccional

7. Pequeña linterna LED (se transformará en un faro)

8. Arduino pro mini 328p

9. 2 x sensor de obstáculos por infrarrojos

10. PCB

11. Transistor NPN (para conducir la linterna)

12. Regulador L7805CV 5V

13. Puente en H L298

14. Rezistor 220 ohmios

15. Conector USB macho

16. Conector micro usb macho

17. Varios cables

18. Regulador de 3 v (para comunicación entre arduino y raspberry pi)

19. Conectores de PCB macho y hembra

20. Interruptor de encendido / apagado

21. Conector LiPo hembra XT-60

22. Batería LiPo 2S 1300 mAh con conector XT-60

23. Paquete de baterías de 5v

24. Raspberry Pi 3

25. Tarjeta Raspberry Pi

26. Funda Raspberry Pi

27. Cámara Raspberry Pi

Herramientas: 1. Adaptador FTDI FT232RL de USB a serie para programar el arduino pro mini

2. IDE de Arduino

3. Perforar

4. Sierra de hoja fina

5. Destornilladores

6. Soldador

7. Cortador de alambre

Habilidades:

1. Soldadura, consulte este tutorial

2. Programación básica de arduino, este tutorial puede ser útil

3. Configuración del servicio Linux, instalación del paquete

Paso 2:construcción de la plataforma del robot

El robot que vamos a construir tendrá las siguientes especificaciones :

- Tendrá tracción en las ruedas delanteras por dos motores DC separados

- las ruedas traseras deben poder moverse en cualquier dirección 360 grados

- la dirección se controlará variando la velocidad en las ruedas delanteras, por lo que no se necesita un mecanismo de dirección por separado, y el robot también podrá girar en el lugar

- tendrá luces en la parte superior

- debe tener suficiente espacio para los dispositivos electrónicos, las baterías y una carcasa de frambuesa pi con una cámara

- se necesita una distancia al suelo de unos pocos cm para superar pequeños obstáculos

No olvide consultar las imágenes para obtener detalles importantes y sugerencias de construcción.

Vamos a construir el robot de plexiglás o plástico duro, los he usado ambos, pero puedes elegir lo que quieras.

La placa base será de 18 x 13 cm en la placa base, los motores de CC irán sujetos con tornillos y tuercas de soportes metálicos. El puente en H se montará en el medio de la placa mirando hacia el suelo. Las ruedas traseras se unirán mediante espaciadores metálicos hexagonales de 2 cm (un lado macho y un lado hembra)

Se necesita un gran orificio cerca del puente H para conectar los componentes electrónicos en la parte superior.

La parte superior del robot constará de dos placas en forma de "L" una será de 12 x 13 cm y la otra de 6,5 x 13 cm. Las placas de plástico se pegarán entre sí. Estas placas proporcionarán una cubierta para la electrónica, un lugar para montar el faro y un soporte para la carcasa de la raspberry pi. La parte superior se unirá desde la parte inferior mediante espaciadores metálicos hexagonales de 6 cm)

Paso 3:construcción de la electrónica

Pinout (arduino):

Linterna LED:D3

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

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

Sensores de infrarrojos:frontal (A0), posterior (A1)

Pines de comunicación de frambuesa pi:Tx:D11, Rx:D10

Construyendo la PCB, montaje

1. En el último paso ya hemos colocado el puente en H en el lado del piso del robot. También necesitaremos instalar los dos sensores infrarrojos uno al frente y otro atrás. Los vamos a montar en el chasis mediante una pequeña placa de metal. La placa de metal tendrá forma de "L" y tendrá dos agujeros. Usando tuercas y pernos lo vamos a instalar en el chasis. Los sensores estarán en el medio del chasis, uno en la parte delantera y otro en la parte trasera.

2. A continuación, el faro parte, he usado una linterna led de 5 voltios para esto. Corté el faro dejando al descubierto solo la parte de la "cabeza" y soldé dos cables para alimentarlo. Luego pegué el faro en el medio de la parte superior del robot y perforé un orificio cerca del faro, puse los cables a través del orificio y le soldé un pequeño conector hembra de dos cables.

3. Montaje de la carcasa de la frambuesa pi. Necesitará una frambuesa pi, una cámara pi, una tarjeta de memoria de al menos 4 GB, un conector de cámara pi. Inserte la tarjeta con el último Raspian instalado, luego tome el conector de la cámara pi, insértelo con cuidado en el raspberry pi, luego insértelo en la cámara y luego cierre la carcasa.

Si no sabe cómo instalar el sistema operativo Raspian, consulte este enlace.

Para obtener más información sobre cómo instalar la cámara y habilitarla, consulte este artículo oficial.

4. Construyendo la PCB con los componentes electrónicos principales. He adjuntado los esquemas fritzing en formato fzz y como una imagen. Puede usarlo como referencia sobre cómo construir la electrónica.

Pasos de soldadura:

a. Corta los conectores de PCB hembra, hay dos conectores de 12 pines para el microcontrolador y dos conectores de 5 pines, hay dos conectores de 3 pines para los sensores IR, un conector de seis pines para el puente H y un conector de pines para la comunicación raspberry pi (tierra, TX, RX) b. Después de cortar todos los conectores, se debe soldar en la parte posterior de la PCB

c. Suelde el conector KF301-2P

d. Suelde el transistor NPN y la resistencia correspondiente a su base

e. Suelde el regulador L7805CV 5V

f. Suelde el regulador de 3,3 voltios en la línea TX de arduino a raspeberry pi

g. Suelde los pines macho al arduino pro mini

h. Suelde todos los cables delgados rojo (+), negro (-) y blanco (señal) de acuerdo con el esquema de Fritzig

i. Suelde un conector macho a la placa de pruebas para la linterna

5. Conectores

a. Construya un conector desde el paquete de baterías USB de 5V a la raspberry pi y arduino, necesitará un conector USB macho tipo A, un conector micro USB macho cables negros y rojos, tubos termorretráctiles y un conector de placa de pruebas hembra a hembra. Primero corte el conector hembra a hembra en dos, estas partes irán a los pines macho positivo y negativo de arduino. El conector USB tipo A enviará energía al arduino y también al raspberry pi usando un conector micro usb. Verifique las imágenes para las puntas de soldadura USB.

b. Construye el conector a la batería LiPo a la placa electrónica, necesitará un conector LiPo hembra XT-60, cables rojo y negro, tubo termorretráctil y un pequeño interruptor capaz de manejar 10 A. El cable negro se conectará directamente desde el XT-60 a la placa electrónica (conector de tornillo KF301-2P), el cable rojo se conectará a través del interruptor pequeño

c. Conecte los dos sensores de infrarrojos del robot a los conectores hembra correspondientes de la placa de circuito impreso utilizando conectores hembra-macho de placa de pruebas

d. Conecte el puente en H a los conectores hembra de 6 pines a la PCB utilizando conectores macho-hembra para placa de pruebas

e. Conecte los terminales positivo y negativo del motor al puente H

f. Conecte la fuente de alimentación principal del puente H al conector de tornillo enchufable KF301-2P en la PCB

6. Antes de colocar el arduino en la PCB, verifique todo con una lupa y un multímetro

Paso 4:Código Arduino

Primero necesito responder una pregunta importante: ¿Por qué tiene que existir una capa intermedia de arduino y no conectar directamente el Pi a la electrónica?

1. Es más modular, puede reutilizar el robot arduino en otro proyecto sin el PI

2. Por seguridad, es más barato reemplazar un arduino pro mini de 3 $ que reemplazar un Pi (35 $)

3. Un arduino no es interrumpido por el sistema operativo como lo es el pi, por lo que es más eficiente implementar controles PWM para los mottors, sondeando los sensores delanteros y traseros unas cuantas veces por segundo

4. Si pudiera ocurrir un error en el script de Python, el robot podría funcionar para siempre agotando las baterías y probablemente dañándolo o prendiéndose fuego si no es supervisado, en un boceto arduino una salvaguarda es más confiable porque no depende de un sistema operativo

5. Es más fácil depurar un sistema desacoplado

Bien, tengo la parte de por qué cubierta, explicaré un poco el boceto de arduino. Básicamente hace dos cosas:

1. recibe comandos de motor y luz de la línea serial y accione los motores o encienda la luz

Por ejemplo:

* " M:-25:16; "significa (-25 a la izquierda) y (16 de potencia), se traducirá al motor izquierdo en un 17% y al motor derecho en un 32%, y dirección hacia adelante *" M:44:19; "significa (44 a la derecha) y (19 potencias) que se traducirá en:motor izquierdo 38%, motor derecho 5% y dirección de avance

* " L:1; "significa luces y" L:0 "luces apagadas

2. Sondea los sensores infrarrojos desde la parte posterior y frontal del robot y envía datos sobre distancias a través de la línea serial

Primero deberá descargar e instalar esta biblioteca:

El código principal se encuentra en el repositorio de github aquí, o puede copiarlo y pegarlo desde abajo.

Sube el código al arduino usando un adaptador FTDI. Ahora puede darle comandos al robot para verlo funcionar, para esto simplemente conecte la segunda línea serial y envíe el motor o la luz a través de ella. Una forma de hacer esto es usando un módulo bluetooth como HC-05 y conectarlo a un teléfono usando una aplicación bluetooth. Luego dale comandos en serie como "L:1"

  // fuente para TextMotorCommandsInterpretter:"https://github.com/danionescu0/arduino/tree/master/libraries/TextMotorCommandsInterpretter" #include  #include  const char MOTOR_COMMAND ='M'; const char LIGHT_COMMAND ='L'; / ** * cuánto tiempo tendrá efecto el comando de motor en ms * un comando de motor entrante durará maxDurationForMottorCommand * si no va a ser reiniciado por otro comando de motor * / const long maxDurationForMottorCommand =300; // ajusta este valor para limitar la velocidad del robot const byte maxPwmValue =230; // Cuánto tiempo entre transmisiones de distancia sucesivas en ms const long transmitingInterval =500; const int maxObstacleDetection =1000; // valor de detección máximo de lectura analógica const int minObstacleDetection =500; // valor de detección mínimo de lectura analógica byte constante FLASH_PIN =3; byte constante RIGHT_MOTOR_PWM_PIN =5; byte constante RIGHT_MOTOR_EN1_PIN =A4; byte constante RIGHT_MOTOR_EN2_PIN =A5; byte constante LEFT_MOTOR_PWM_PIN =6; byte constante LEFT_MOTOR_EN1_PIN =A3; byte constante LEFT_MOTOR_EN2_PIN =A2; byte constante FRONT_DISTANCE_SENSOR =A0; byte constante BACK_DISTANCE_SENSOR =A1; SoftwareSerial masterComm (11, 10); // RX, TX TextMotorCommandsInterpretter motorCommandsInterpretter (-50, 50, -50, 50); String currentCommand; long lastCheckedTime; long lastTransmitTime; booleano inMotion =false; configuración vacía () {Serial.begin (9600); masterComm.begin (9600); masterComm.setTimeout (10); pinMode (FLASH_PIN, SALIDA); pinMode (LEFT_MOTOR_PWM_PIN, SALIDA); pinMode (LEFT_MOTOR_EN1_PIN, SALIDA); pinMode (LEFT_MOTOR_EN2_PIN, SALIDA); pinMode (RIGHT_MOTOR_PWM_PIN, SALIDA); pinMode (RIGHT_MOTOR_EN1_PIN, SALIDA); pinMode (RIGHT_MOTOR_EN2_PIN, SALIDA); lastCheckedTime =millis (); lastTransmitTime =millis (); } bucle vacío () {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 DEPURAR motorCommandsInterpretter.analizeText ("M:-14:40;"); Serial.write ("Izquierda =="); Serial.println (motorCommandsInterpretter.getPercentLeft ()); Serial.write ("Derecha =="); 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 (); descanso; case (LIGHT_COMMAND):toggleLight (currentCommand.charAt (2)); descanso; }} void steerCar () {motorCommandsInterpretter.analizeText (currentCommand); flotador percentLeftMotor =motorCommandsInterpretter.getPercentLeft (); flotador percentRightMotor =motorCommandsInterpretter.getPercentRight (); Serial.write ("Izquierda ="); Serial.println (percentLeftMotor); Serial.write ("Derecha ="); Serial.println (percentRightMotor); setMotorsDirection (motorCommandsInterpretter.getDirection ()); analogWrite (LEFT_MOTOR_PWM_PIN, percentLeftMotor * maxPwmValue); analogWrite (RIGHT_MOTOR_PWM_PIN, percentRightMotor * maxPwmValue); inMotion =verdadero; lastCheckedTime =millis (); } void setMotorsDirection (boolean adelante) {if (adelante) {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); } más {digitalWrite (FLASH_PIN, LOW); }}  

Paso 5:Instalar y configurar el proyecto y las dependencias de Raspberry Pi

Cómo funciona:

Verá un diagrama de lo que intentaré explicar arriba en las imágenes adjuntas.

a. La aplicación de Android muestra la transmisión de uv4l dentro de una vista web. El proceso uv4l se ejecuta en la raspberry pi, captura la entrada de video de la cámara y la transmite. Es una herramienta increíble con muchas características

b. El uso de controles dentro de las luces de la aplicación de Android y los comandos de los motores se envían al servidor MQTT

c. El servidor Python dentro del contenedor Docker en Raspberry Pi escucha los comandos MQTT y los pasa usando la interfaz serial al Arduino. La placa arduino controla los motores y las luces.

d. El arduino detecta distancias en la parte delantera y trasera del robot y envía los datos a través de la interfaz en serie al servidor de Python, Python los reenvía al MQTT y son recogidos por la interfaz de Android y mostrados al usuario

Primero Lo que necesitará un Raspbian completamente instalado y configurado en el raspberry pi, y la cámara debe estar conectada y configurada psíquicamente. Además, toda la configuración se realizará mediante ssh, por lo que es bueno configurarlo.

No podemos cubrir todas las cosas básicas aquí, pero pruebe estos enlaces si es necesario:

Si no sabe cómo instalar el sistema operativo Raspbian, consulte este enlace. Para obtener más información sobre cómo instalar la cámara y habilitarla, consulte este artículo oficial.

Para saber cómo configurar ssh en Raspbian, verifique esto.

Si desea controlar su robot usando la aplicación de Android desde fuera del wifi, debe considerar el reenvío de puertos en su enrutador wifi; de lo contrario, estará restringido para usar sus direcciones IP locales dentro de su wifi.

Para averiguar su dirección IP local en la Raspberry Pi, use "ifconfig":

  ifconfig ......... eth0 Link encap:Ethernet HWaddr b8:27:eb:16:e7:ff inet6 addr:fe80 ::ff00:f22f:9258:b92b / 64 Alcance:Link UP BROADCAST MULTICAST MTU:1500 Métrica:1 paquetes RX:0 errores:0 descartados:0 desbordamientos:0 trama:0 paquetes TX:0 errores:0 descartados:0 desbordamientos:0 portadora:0 colisiones:0 txqueuelen:1000 bytes RX :0 (0.0 B) TX bytes:0 (0.0 B) ........ wlan0 Encapsulado de enlace: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 Alcance:Link UP BROADCAST EJECUTANDO MULTICAST MTU:1500 Métrica:1 RX paquetes:1678396 errores:0 descartado:0 overruns:0 frame:0 TX paquetes:381859 errores:0 descartados:0 desbordamientos:0 portadora:0 colisiones:0 txqueuelen:1000 bytes RX:259428527 (247,4 MiB) bytes TX:187573084 (178,8 MiB) .....  

Estamos interesados ​​en el wlan0 inet addr, en nuestro caso "192.168.0.102"

Los puertos que se reenviarán (predeterminados) son:9090 para uv4l y 1883 para mosquitto. Puede reenviar estos puertos a los mismos puertos de salida si no están prohibidos en el firewall del proveedor de Internet o en otros puertos.

El reenvío de puertos es algo que se hace de manera diferente en cada enrutador, aquí hay algunos tutoriales:esto, y también puede intentar buscar en google " reenvío de puertos your_router_model "para ver resultados más relevantes.

Requisitos previos:

a. instalar git usando la línea de comando

b. clona el proyecto github en la carpeta de inicio:

La ubicación de la carpeta es importante porque en docker-compose.yml la ubicación está codificada como:/ home / pi / robot-camera-platform:/ root / debug Si necesita cambiar la ubicación, cambie el valor en docker-compose también

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

C. deshabilite la consola serie de pi, si no sabe cómo hacerlo, consulte este enlace

Instale la transmisión de Uv4l:

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

Si esto falla o necesita obtener más detalles sobre uv4l, consulte este tutorial.

Configuración:

a. editando uv4l / start.sh puede configurar los siguientes aspectos de la transmisión de video:contraseña, puerto, velocidad de cuadros, altura, rotación y algunos otros aspectos menores

b. editar config.py y reemplazar contraseña con su propia contraseña que ha establecido en el servidor mosquitto

c. edite docker-container / mosquitto / Dockerfile y reemplace esta línea

  EJECUTAR mosquitto_passwd -b / etc / mosquitto / pwfile usuario your_password  

con su propio usuario y contraseña para mosquitto

d. edite config.py y reemplace el puerto serie y la velocidad en baudios con la suya, le recomiendo que mantenga la velocidad en baudios. Si desea cambiarlo, no olvide editarlo también en arduino-sketch

Pruebe la instalación de uv4la. Iniciarlo:

  sh ./uv4l/start.sh  

b. Pruébelo en el navegador en la dirección:http:// your_ip:9090 / stream

c. Detente

  sudo pkill uv4l  

Instale docker y docker-compose

Acerca de la instalación de Docker:https://www.raspberrypi.org/blog/docker-comes-to -...

Acerca de la instalación de docker-compose:https://www.raspberrypi.org/blog/docker-comes-to -...

Servicios de inicio automático al reiniciar / iniciar

By making the services auto start you'll eliminate the need of manually login through ssh and then activate all the services by hand, we're going to do this using systemctl.

a. Copy the files from systemctl folder in systemctl folder to /etc/systemd/system/

b. Enable services

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

c. Reboot

d. Optional, check status:

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

Step 6:Configuring and Building the Android Application

We're all most done, in this step we're going to install the android application. These are all the prerequisites:

1. Clone the github project:

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.