Caméra de surveillance à distance mobile

Outils et machines nécessaires

	Adaptateur USB vers série FTDI FT232RL
	Arduino IDE
	Perceuse
	Scie à lame fine
	Tournevis
	Fer à souder (générique)
	Coupe-fil

À propos de ce projet

Ce projet intéressant mais compliqué couvrira des choses allant de la conception de la construction d'un robot aux configurations avancées sous Linux (raspberry pi) à la construction d'une application Android et au contrôle du robot.

Cela étant dit, c'est plus ambitieux que la moyenne des projets, mais je pense que vous aurez beaucoup à apprendre en examinant quelques idées ici ou même en reproduisant l'ensemble du projet.

Nous allons d'abord construire le robot en utilisant du plexiglas, des feuilles de plastique, des moteurs à courant continu avec des boîtes de vitesses et divers composants électroniques. L'appareil pourra déplacer indépendamment les deux roues avant et il pourra utiliser son phare. Ensuite, nous allons configurer le raspberry pi alimentant le robot et configurer le projet et installer diverses dépendances. Ensuite, nous allons créer et installer une application Android et l'utiliser pour contrôler le robot à distance à l'aide de la caméra et d'une connexion wifi.

Les technologies et les concepts seront explorés ici :

Plateformes de développement :Arduino, Raspberry pi, Android

Électronique :pont en H, utilisant un transistor pour piloter une grosse charge, capteurs infrarouges

Linux :utilisation de docker, docker compose, configuration des services avec systemctl, streaming vidéo

Programmation :applications Android, python, langage arduino, communication série, MQTT

Étape 1 :Éléments requis

Pièces :

1. Feuille de plexiglas

2. Feuille de plastique (vous pouvez également utiliser une feuille de plexiglas ici)

3. Colle

4. Pneu + moteur à courant continu avec boîte de vitesses + support. Petits écrous et boulons, entretoises métalliques hexagonales

6. 2 x n'importe quel pneu de roue directionnelle

7. Petite lampe torche LED (elle se transformera en phare)

8. Arduino pro mini 328p

9. 2 x capteur d'obstacles infrarouge

10. PCB

11. Transistor NPN (pour piloter la lampe de poche)

12. Régulateur L7805CV 5V

13. Pont en H L298

14. Rezistor 220 Ohms

15. Connecteur USB mâle

16. Connecteur micro usb mâle

17. Divers fils

18. Régulateur 3 v (pour la communication entre arduino et raspberry pi)

19. Connecteurs PCB mâles et femelles

20. Interrupteur marche/arrêt

21. Connecteur LiPo femelle XT-60

22. Batterie LiPo 2S 1300 mAh avec connecteur XT-60

23. Batterie 5v

24. Raspberry Pi 3

25. Carte Raspberry Pi

26. Boîtier Raspberry Pi

27. Caméra Raspberry Pi

Outils : 1. Adaptateur USB vers série FTDI FT232RL pour programmer l'arduino pro mini

2. IDE Arduino

3. Percer

4. Scie à lame fine

5. Tournevis

6. Fer à souder

7. Coupe-fil

Compétences :

1. Souder, consultez ce tutoriel

2. Programmation arduino de base, ce tutoriel peut être utile

3. Configuration du service Linux, installation du package

Étape 2 : Création de la plate-forme robotique

Le robot nous allons construire va avoir les spécifications suivantes :

- Il aura une traction sur les roues avant par deux moteurs CC séparés

- les roues arrière doivent pouvoir se déplacer dans n'importe quelle direction à 360 degrés

- la direction sera contrôlée en faisant varier la vitesse sur les roues avant, donc aucun mécanisme de direction séparé n'est nécessaire, le robot pourra également tourner sur place

- il aura des lumières sur le dessus

- il devrait avoir assez de place pour l'électronique, les batteries et un boîtier Raspberry Pi avec un appareil photo

- une garde au sol de quelques cm est nécessaire pour franchir les petits obstacles

N'oubliez pas de consulter les images pour des détails importants et des conseils de construction.

Nous allons construire le robot en plexiglas ou en plastique dur, je les ai utilisés tous les deux mais vous pouvez choisir ce que vous voulez.

La plaque de base sera de 18 x 13 cm sur la plaque de base les moteurs à courant continu seront fixés avec des écrous et des boulons de supports métalliques. Le pont en H sera monté au milieu de la plaque face au sol. Les roues arrière seront fixées à l'aide d'entretoises métalliques hexagonales de 2 cm (un côté mâle un côté femelle)

Un gros trou près du pont en H est nécessaire pour connecter l'électronique sur la face supérieure.

La partie supérieure du robot se composera de deux plaques en forme de "L" l'une sera de 12 x 13 cm et l'autre de 6,5 x 13 cm. Les plaques en plastique seront collées ensemble. Ces plaques fourniront un couvercle pour l'électronique, un endroit pour monter le phare et un support pour le boîtier Raspberry Pi. La partie supérieure sera fixée à partir de la partie inférieure à l'aide d'entretoises métalliques hexagonales de 6 cm )

Étape 3 : Construire l'électronique

Brochage (arduino) :

Lampe de poche à LED :D3

Moteur gauche :PWM (D5), EN1, EN2(A4, A5)

Moteur droit :PWM (D6), EN1, EN2(A3, A2)

Capteurs infrarouges :Avant (A0), Arrière (A1)

Broches de communication Raspberry Pi :Tx :D11, Rx :D10

Construction du PCB, assemblage

1. Dans la dernière étape, nous avons déjà installé le pont en H du côté du sol du robot. Nous devrons également installer les deux capteurs infrarouges un devant et un derrière. Nous allons les monter sur le châssis à l'aide d'une petite plaque métallique. La plaque de métal sera en forme de "L" et aura deux trous. À l'aide d'écrous et de boulons, nous allons l'installer sur le châssis. Les capteurs seront au milieu du châssis un à l'avant et un à l'arrière.

2. Suivant le phare partie, j'ai utilisé une lampe de poche LED 5 volts pour cela. J'ai coupé le phare en exposant uniquement la partie "tête" et j'ai soudé deux fils pour l'alimenter. Ensuite, j'ai collé le phare au milieu de la partie supérieure du robot et j'ai percé un trou près du phare, j'ai passé les câbles à travers le trou et j'y ai soudé un petit connecteur femelle à deux fils.

3. Assemblage du boîtier framboise pi. Vous aurez besoin d'un raspberry pi, d'une caméra pi, d'une carte mémoire d'au moins 4 Go, d'un connecteur caméra pi. Insérez la carte avec le dernier Raspian installé, puis prenez le connecteur de l'appareil photo pi insérez-le soigneusement sur le raspberry pi, puis insérez-le dans l'appareil photo, puis fermez le boîtier.

Si vous ne savez pas comment installer le système d'exploitation Raspian, consultez ce lien.

Pour plus d'informations sur l'installation et l'activation de la caméra, consultez cet article officiel.

4. Construire le PCB avec les composants électroniques principaux. J'ai joint les schémas frits au format fzz et sous forme d'image. Vous pouvez l'utiliser comme référence pour savoir comment construire l'électronique.

Étapes de soudure :

un. Coupez les connecteurs PCB femelles, il y a deux connecteurs à 12 broches pour le microcontrôleur et deux connecteurs à 5 broches, il y a deux connecteurs à 3 broches pour les capteurs IR, un connecteur à six broches pour le pont en H et un connecteur à broches pour la communication raspberry pi (terre, TX, RX) b. Une fois tous les connecteurs coupés, il doit être soudé à l'arrière du PCB

c. Souder le connecteur KF301-2P

d. Soudez le transistor NPN et la résistance correspondante à sa base

e. Souder le régulateur L7805CV 5V

f. Souder le régulateur 3,3 volts sur la ligne TX arduino vers raspeberry pi

g. Soudez les broches mâles à l'arduino pro mini

h. Soudez tous les fils minces rouge (+), noir (-) et blanc (signal) selon le schéma de fritzig

je. Soudez un connecteur mâle à la maquette pour la lampe de poche

5. Connecteurs

un. Construisez un connecteur entre la batterie USB 5V et le raspberry pi et l'arduino, vous aurez besoin d'un connecteur USB mâle de type A, d'un connecteur micro usb mâle, de fils noirs et rouges, d'un tube thermorétractable et d'un connecteur femelle à femelle. Coupez d'abord le connecteur femelle à femelle en deux, ces pièces iront dans les broches mâles négatives et positives de l'arduino. Le connecteur USB de type A enverra l'alimentation à l'arduino et également au raspberry pi à l'aide d'un connecteur micro usb. Vérifiez les images pour les embouts USB à souder.

b. Construisez le connecteur à la batterie LiPo à la carte électronique, vous aurez besoin d'un connecteur LiPo femelle XT-60, de fils rouge et noir, d'une gaine thermorétractable et d'un petit interrupteur capable de gérer 10 A. Le fil noir sera connecté directement depuis le XT-60 à la carte électronique (connecteur à vis KF301-2P), le fil rouge sera connecté via le petit interrupteur

c. Connectez les deux capteurs IR du robot aux connecteurs femelles correspondants sur le PCB à l'aide de connecteurs de planche à pain femelle - mâle

d. Connectez le pont en H aux connecteurs femelles à 6 broches du circuit imprimé à l'aide de connecteurs mâle-femelle pour planche à pain

e. Connectez les bornes positives et négatives des moteurs au pont en H

f. Connectez l'alimentation principale du pont en H au connecteur à vis enfichable KF301-2P sur le PCB

6. Avant de placer l'arduino sur le PCB, vérifiez tout à l'aide d'une loupe et d'un multimètre

Étape 4 : Code Arduino

Je dois d'abord répondre à une question importante : Pourquoi une couche arduino intermédiaire doit-elle exister et ne pas connecter directement le Pi à l'électronique ?

1. C'est plus modulaire, vous pouvez réutiliser le robot arduino dans un autre projet sans le PI

2. Par sécurité, il est moins cher de remplacer un arduino pro mini à 3$ que de remplacer un Pi (35$)

3. Un arduino n'est pas interrompu par le système d'exploitation comme le pi, il est donc plus efficace d'implémenter des contrôles PWM pour les moteurs, en interrogeant les capteurs avant et arrière quelques fois par seconde

4. Si une erreur peut se produire dans le script python, le robot peut fonctionner indéfiniment en vidant les batteries et probablement en l'endommageant ou en prenant feu s'il n'est pas supervisé. Dans un croquis arduino, une sauvegarde est plus fiable car elle ne dépend pas d'un système d'exploitation

5. Il est plus facile de déboguer un système découplé

Ok, j'ai donc couvert la partie Pourquoi, je vais expliquer un peu le sketch arduino. Il fait essentiellement deux choses :

1. Il reçoit moteur et lumière commandes de la ligne série et piloter les moteurs ou basculer la lumière

Par exemple :

* "M:-25:16 ; " signifie (-25 gauche) et (16 puissance), cela se traduira par le moteur gauche 17% et le moteur droit 32%, et la direction vers l'avant * "M:44:19 ; " signifie (44 à droite) et (19 puissance) cela se traduira par :moteur gauche 38 %, moteur droit 5 % et direction vers l'avant

* "L:1; " signifie lumières et "L:0 " s'éteint

2. Il sonde les capteurs infrarouges de l'arrière et de l'avant du robot et envoie des données sur les distances via la ligne série

Vous devez d'abord télécharger et installer cette bibliothèque :

Le code principal se trouve sur le référentiel github ici, ou vous pouvez le copier-coller ci-dessous.

Téléchargez le code sur l'arduino à l'aide d'un adaptateur FTDI. Maintenant, vous pouvez donner des commandes au robot pour le voir fonctionner, pour cela il suffit de connecter la deuxième ligne série et d'envoyer le moteur ou la lumière à travers elle. Une façon de le faire consiste à utiliser un module Bluetooth comme HC-05 et à le connecter à un téléphone à l'aide d'une application Bluetooth. Ensuite, donnez-lui des commandes série comme "L:1"

// source pour TextMotorCommandsInterpretter :"https://github.com/danionescu0/arduino/tree/master/libraries/TextMotorCommandsInterpretter" #include  #include  const char MOTOR_COMMAND ='M'; const char LIGHT_COMMAND ='L'; /** * combien de temps la commande moteur prendra effet en ms * une commande moteur entrante durera pendant maxDurationForMottorCommand * si elle ne va pas être réinitialisée par une autre commande moteur */ const long maxDurationForMottorCommand =300; // ajuste cette valeur pour limiter la vitesse du robot const byte maxPwmValue =230; // Combien de temps entre les transmissions à distance successives en ms const long transmitingInterval =500; const int maxObstacleDetection =1000; // valeur de détection max de lecture analogique const int minObstacleDetection =500; // lecture analogique valeur de détection min const octet FLASH_PIN =3; octet const RIGHT_MOTOR_PWM_PIN =5 ; octet const RIGHT_MOTOR_EN1_PIN =A4 ; octet const RIGHT_MOTOR_EN2_PIN =A5 ; octet const LEFT_MOTOR_PWM_PIN =6 ; octet const LEFT_MOTOR_EN1_PIN =A3 ; octet const LEFT_MOTOR_EN2_PIN =A2 ; octet const FRONT_DISTANCE_SENSOR =A0 ; octet const BACK_DISTANCE_SENSOR =A1 ; LogicielSerial masterComm(11, 10); // RX, TX TextMotorCommandsInterpretter motorCommandsInterpretter(-50, 50, -50, 50); Chaîne currentCommand; long lastCheckedTime; long lastTransmitTime; booléen inMotion =false; void setup() { Serial.begin(9600); masterComm.begin(9600); masterComm.setTimeout(10) ; pinMode(FLASH_PIN, SORTIE); pinMode(LEFT_MOTOR_PWM_PIN, SORTIE); pinMode(LEFT_MOTOR_EN1_PIN, SORTIE); pinMode(LEFT_MOTOR_EN2_PIN, SORTIE); pinMode(RIGHT_MOTOR_PWM_PIN, SORTIE); pinMode(RIGHT_MOTOR_EN1_PIN, SORTIE); pinMode(RIGHT_MOTOR_EN2_PIN, SORTIE); 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()); } /* POUR 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(); Pause; case (LIGHT_COMMAND):toggleLight(currentCommand.charAt(2)); Pause; } } 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); en mouvement =vrai ; lastCheckedTime =millis(); } void setMotorsDirection(boolean forward) { if (forward) { digitalWrite(LEFT_MOTOR_EN1_PIN, HIGH); digitalWrite(LEFT_MOTOR_EN2_PIN, BAS); digitalWrite(RIGHT_MOTOR_EN1_PIN, HAUT); digitalWrite(RIGHT_MOTOR_EN2_PIN, LOW); } else { digitalWrite(LEFT_MOTOR_EN1_PIN, LOW); digitalWrite(LEFT_MOTOR_EN2_PIN, HAUT); digitalWrite(RIGHT_MOTOR_EN1_PIN, LOW); digitalWrite(RIGHT_MOTOR_EN2_PIN, HAUT); } } void stopMotors() { Serial.println("Arrêt des moteurs"); analogWrite(LEFT_MOTOR_PWM_PIN, 0); analogWrite(RIGHT_MOTOR_PWM_PIN, 0); en mouvement =faux ; } void toggleLight(char command) { Serial.println("Toggle light"); if (commande =='1') { digitalWrite(FLASH_PIN, HIGH); } else { digitalWrite(FLASH_PIN, LOW); } }  

Étape 5 :Installation et configuration du projet Raspberry Pi et des dépendances

Comment ça marche :

Vous verrez un schéma de ce que je vais essayer d'expliquer ci-dessus dans les images ci-jointes.

un. L'application Android affiche le streaming uv4l dans une vue Web. Le processus uv4l s'exécute sur le raspberry pi, capture l'entrée vidéo de la caméra et la diffuse. C'est un outil génial avec de nombreuses fonctionnalités

b. À l'aide des commandes à l'intérieur de l'application Android, les commandes des voyants et des moteurs sont envoyées au serveur MQTT

c. Le serveur python à l'intérieur du conteneur docker sur le raspberry pi écoute les commandes MQTT et les transmet via l'interface série à l'arduino. La carte arduino contrôle les moteurs et les lumières.

d. L'arduino détecte les distances devant et derrière le robot et envoie les données via l'interface série au serveur python, le python les transmet au MQTT et elles sont récupérées par l'interface Android et montrées à l'utilisateur

Premier chose que vous aurez besoin d'un Raspbian entièrement installé et configuré sur le raspberry pi, et la caméra doit être psychiquement connectée et configurée. De plus, toute la configuration sera effectuée à l'aide de ssh, c'est donc une bonne chose de le configurer.

Nous ne pouvons pas couvrir toutes les choses de base ici, mais essayez ces liens si nécessaire :

Si vous ne savez pas comment installer le système d'exploitation Raspbian, consultez ce lien. Pour plus d'informations sur l'installation et l'activation de la caméra, consultez cet article officiel.

Pour savoir comment configurer ssh sur Raspbian, vérifiez ceci.

Si vous souhaitez contrôler votre robot à l'aide de l'application Android depuis l'extérieur du wifi, vous devriez envisager la redirection de port sur votre routeur wifi, sinon vous serez limité à utiliser vos adresses IP locales à l'intérieur de votre wifi.

Pour connaître votre adresse IP locale sur le raspberry pi, utilisez "ifconfig":

ifconfig ......... eth0 Link encap:Ethernet HWaddr b8:27:eb:16:e7:ff inet6 addr:fe80::ff00:f22f:9258:b92b/64 Portée :Link UP BROADCAST MULTICAST MTU:1500 Metric:1 RX packets:0 error:0 drop:0 overruns:0 frame:0 TX packets:0 error:0 drop:0 overruns:0 carrier:0 collisions:0 txqueuelen:1000 RX bytes :0 (0,0 B) octets TX :0 (0,0 B) ........ wlan0 Encap de lien :Ethernet HWaddr 00:c1:41:00:10:f6 inet addr:192.168.0.102 Bcast:192.168.0.255 Masque:255.255.255.0 inet6 addr:fe80::e1f4:5112:9cb2:3839/64 Portée:Lien UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:1678396 error:0 drop:0 overruns:0 frame:0 TX paquets :381859 erreurs :0 abandonné :0 dépassement :0 transporteur :0 collisions :0 txqueuelen :1000 octets RX :259428527 (247,4 Mio) octets TX :187573084 (178,8 Mio) .....  

Nous nous intéressons à l'adresse inet wlan0, dans notre cas "192.168.0.102"

Les ports à rediriger (par défaut) sont :9090 pour uv4l et 1883 pour mosquitto. Vous pouvez transférer ces ports vers les mêmes ports de sortie s'ils ne sont pas bannis du pare-feu du fournisseur d'accès Internet ou d'autres ports.

La redirection de port est quelque chose qui se fait différemment sur chaque routeur, voici quelques tutoriels :ceci, et vous pouvez aussi essayer de rechercher sur google "port forwarding your_router_model " pour voir des résultats plus pertinents.

Prérequis :

un. installer git en ligne de commande

b. cloner le projet github dans le dossier home :

L'emplacement du dossier est important car dans docker-compose.yml, l'emplacement est codé en dur comme suit :/home/pi/robot-camera-platform:/root/debug Si vous devez modifier l'emplacement, veuillez modifier la valeur dans docker-compose aussi

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

c. désactiver la console série du pi, si vous ne savez pas comment faire, consultez ce lien

Installez le streaming Uv4l :

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

Si cela échoue ou si vous avez besoin d'en savoir plus sur uv4l, consultez ce didacticiel.

Configuration :

un. en éditant uv4l/start.sh vous pouvez configurer les aspects suivants du streaming vidéo :mot de passe, port, fréquence d'images, avec, hauteur, rotation et quelques autres aspects mineurs

b. modifiez config.py et remplacez mot de passe avec votre propre mot de passe que vous avez défini sur le serveur mosquitto

c. éditez docker-container/mosquitto/Dockerfile et remplacez cette ligne

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

avec votre propre nom d'utilisateur et mot de passe pour moustique

d. modifiez config.py et remplacez le port série et le débit en bauds avec le vôtre, je vous recommande de garder le débit en bauds cependant. Si vous voulez le changer, n'oubliez pas de le modifier également sur l'arduino-sketch

Testez l'installation d'uv4l. Démarrez-le :

sh ./uv4l/start.sh  

b. Testez-le dans le navigateur à l'adresse :http://your_ip:9090/stream

c. Arrêtez-le

sudo pkill uv4l  

Installer docker et docker-compose

À propos de l'installation de Docker :https://www.raspberrypi.org/blog/docker-comes-to-...

À propos de l'installation de docker-compose :https://www.raspberrypi.org/blog/docker-comes-to-...

Démarrage automatique des services au redémarrage/démarrage

En faisant démarrer automatiquement les services, vous éliminerez le besoin de vous connecter manuellement via ssh, puis d'activer tous les services à la main, nous allons le faire en utilisant systemctl.

un. Copiez les fichiers du dossier systemctl dans le dossier systemctl vers /etc/systemd/system/

b. Activer les services

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

c. Redémarrer

d. Facultatif, vérifiez l'état :

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.

Code

Android application

Main repository for arduino, python code

Schémas

Main repository for arduino, python code

Android application