Mobile Fernüberwachungskamera

Pinbelegung (arduino):

LED-Taschenlampe:D3

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

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

Infrarotsensoren:Vorderseite (A0), Rückseite (A1)

Raspberry Pi-Kommunikationspins:Tx:D11, Rx:D10

Aufbau der Leiterplatte, Bestückung

1. Im letzten Schritt haben wir die H-Brücke bereits auf der Bodenseite des Roboters untergebracht. Wir müssen auch die beiden Infrarotsensoren installieren einer vorne und einer hinten. Wir werden sie mit einer kleinen Metallplatte am Chassis montieren. Die Metallplatte hat die Form eines "L" und hat zwei Löcher. Mit Muttern und Schrauben werden wir es auf dem Chassis installieren. Die Sensoren befinden sich in der Mitte des Chassis, einer vorne und einer hinten.

2. Als nächstes der Scheinwerfer Teil, ich habe dafür eine 5-Volt-LED-Taschenlampe verwendet. Ich habe den Scheinwerfer geschnitten, der nur den "Kopf" -Teil freilegt, und zwei Drähte gelötet, um ihn mit Strom zu versorgen. Dann habe ich den Scheinwerfer mittig auf das Roboteroberteil geklebt und ein Loch in der Nähe des Scheinwerfers gebohrt, die Kabel durch das Loch gesteckt und eine kleine zweiadrige Buchse daran angelötet.

3. Zusammenbau der Himbeer-Pi-Hülle Sie benötigen einen Raspberry Pi, eine Pi-Kamera, eine Speicherkarte mit mindestens 4 GB, einen Pi-Kameraanschluss. Legen Sie die Karte mit dem neuesten installierten Raspian ein, nehmen Sie dann den Pi-Kamerastecker, stecken Sie ihn vorsichtig auf den Raspberry Pi, setzen Sie ihn dann in die Kamera ein und schließen Sie das Gehäuse.

Wenn Sie nicht wissen, wie Sie das Raspian-Betriebssystem installieren, überprüfen Sie diesen Link.

Weitere Informationen zum Installieren und Aktivieren der Kamera finden Sie in diesem offiziellen Artikel.

4. Aufbau der Leiterplatte mit den elektronischen Hauptkomponenten Ich habe die Fritzing-Schaltpläne im Fzz-Format und als Bild angehängt. Sie können es als Referenz verwenden, um die Elektronik zu bauen.

Lötschritte:

a. Schneiden Sie die PCB-Buchsen ab, es gibt zwei 12-Pin-Anschlüsse für den Mikrocontroller und zwei 5-Pin-Anschlüsse, es gibt zwei 3-Pin-Anschlüsse für die IR-Sensoren, einen 6-Pin-Anschluss für die H-Brücke und einen Pin-Anschluss für die Himbeer-Pi-Kommunikation (Masse, TX, RX) b. Nachdem alle Anschlüsse abgeschnitten sind, muss auf der Rückseite der Platine gelötet werden

c. Löten Sie den KF301-2P-Stecker an

d. Löten Sie den NPN-Transistor und den entsprechenden Widerstand an seine Basis

e. Löten Sie den L7805CV 5V-Regler

f. Löten Sie den 3,3-Volt-Regler auf der arduino to himbeere pi TX line

z. B. Löten Sie die männlichen Stifte an den Arduino Pro Mini

h. Löten Sie alle roten (+), schwarzen (-) und weißen (Signal) dünnen Drähte gemäß dem Fritzig-Schema

ich. Löten Sie einen Stecker an das Steckbrett für die Taschenlampe

5. Anschlüsse

a. Bauen Sie einen Stecker vom 5V-USB-Akku zum Himbeer-Pi und zum Arduino. Sie benötigen einen USB-Stecker vom Typ A, einen Micro-USB-Stecker mit schwarzen und roten Drähten, einen Schrumpfschlauch und eine Steckplatinenbuchse. Schneiden Sie zuerst die Buchse zu der Buchse in zwei Teile, diese Teile gehen in die negativen und positiven Steckerstifte des Arduino. Der USB-Anschluss vom Typ A sendet über einen Micro-USB-Anschluss Strom an das Arduino und auch an das Himbeer-Pi. Überprüfen Sie die Bilder zum Löten von USB-Tipps.

b. Erstellen Sie den Connector zum LiPo-Akku zur Elektronikplatine benötigen Sie eine XT-60 LiPo-Buchse, rotes und schwarzes Kabel, Schrumpfschlauch und einen kleinen Schalter mit 10 A. Das schwarze Kabel wird direkt am XT-60 angeschlossen an der Elektronikplatine (KF301-2P steckbare Schraubverbindung) wird das rote Kabel über den kleinen Schalter angeschlossen

c. Verbinden Sie die beiden IR-Sensoren des Roboters mit den entsprechenden Buchsen auf der Platine mithilfe von Buchsen-Steckern

d. Verbinden Sie die H-Brücke mit den 6-Pin-Buchsen mit der Platine mit männlichen - weiblichen Steckplatinenanschlüssen

e. Verbinden Sie die positiven und negativen Anschlüsse des Motors mit der H-Brücke

f. Verbinden Sie die H-Brücken-Hauptstromversorgung mit dem KF301-2P-Schraubsteckverbinder auf der Platine

6. Bevor Sie das Arduino auf die Platine legen, überprüfen Sie alles mit einer Lupe und einem Multimeter

Schritt 4:Arduino-Code

Zuerst muss ich eine wichtige Frage beantworten: Warum muss eine zwischengeschaltete Arduino-Schicht vorhanden sein und den Pi nicht direkt mit der Elektronik verbinden?

1. Es ist modularer, Sie können den Arduino-Roboter in einem anderen Projekt ohne PI wiederverwenden

2. Aus Sicherheitsgründen ist es billiger, ein 3 $ Arduino Pro Mini zu ersetzen, als einen Pi (35 $) zu ersetzen

3. Ein Arduino wird nicht wie der Pi vom Betriebssystem unterbrochen, daher ist es effizienter, PWM-Steuerungen für die Mottor zu implementieren, die die vorderen und hinteren Sensoren einige Male pro Sekunde abfragen

4. Wenn im Python-Skript ein Fehler auftritt, kann der Roboter für immer laufen, die Batterien entladen und wahrscheinlich beschädigen oder Feuer fangen, wenn er nicht überwacht wird. In einer Arduino-Skizze ist eine Sicherung zuverlässiger, da sie nicht von einem Betriebssystem abhängt

5. Es ist einfacher, ein entkoppeltes System zu debuggen

Ok, also habe ich den Warum-Teil abgedeckt, ich werde die Arduino-Skizze ein wenig erklären. Es macht im Wesentlichen zwei Dinge:

1. Es erhält Motor und Licht Befehle von der seriellen Leitung und treiben Sie die Motoren an oder schalten Sie das Licht um

Zum Beispiel:

* "M:-25:16; " bedeutet (-25 links) und (16 Potenzen), es wird auf den linken Motor 17% und den rechten Motor 32% und die Richtung vorwärts übersetzt * "M:44:19; " bedeutet (44 nach rechts) und (19 Potenz) wird übersetzt in:linker Motor 38%, rechter Motor 5% und Richtung vorwärts

* "L:1; " bedeutet Lichter und "L:0 " leuchtet aus

2. Es ruft die Infrarotsensoren ab von der Rückseite und Vorderseite des Roboters und sendet Entfernungsdaten über die serielle Leitung

Zuerst müssen Sie diese Bibliothek herunterladen und installieren:

Der Hauptcode befindet sich hier im Github-Repository, oder Sie können ihn von unten kopieren und einfügen.

Laden Sie den Code mit einem FTDI-Adapter auf das Arduino hoch. Jetzt können Sie dem Roboter Befehle geben, um zu sehen, wie er funktioniert. Schließen Sie dazu einfach die zweite serielle Leitung an und senden Sie Motor oder Licht durch. Eine Möglichkeit, dies zu tun, besteht darin, ein Bluetooth-Modul wie HC-05 zu verwenden und es über eine Bluetooth-Anwendung mit einem Telefon zu verbinden. Dann gib ihm serielle Befehle wie "L:1"

// Quelle für TextMotorCommandsInterpretter:"https://github.com/danionescu0/arduino/tree/master/libraries/TextMotorCommandsInterpretter" #include  #include  const char MOTOR_COMMAND ='M'; const char LIGHT_COMMAND ='L'; /** * wie lange der Motorbefehl wirksam wird in ms * ein eingehender Motorbefehl dauert maxDurationForMottorCommand * wenn er nicht durch einen anderen Motorbefehl zurückgesetzt wird */ const long maxDurationForMottorCommand =300; // diesen Wert anpassen, um die Robotergeschwindigkeit zu begrenzen const byte maxPwmValue =230; // Wie lange zwischen aufeinanderfolgenden Distanzübertragungen in ms dauern const long transmitingInterval =500; const int maxObstacleDetection =1000; // analoger maximaler Erkennungswert lesen const int minObstacleDetection =500; // analoger Lese-Min-Erkennungswert const byte FLASH_PIN =3; konstantes Byte RIGHT_MOTOR_PWM_PIN =5; konstantes Byte RIGHT_MOTOR_EN1_PIN =A4; konstantes Byte RIGHT_MOTOR_EN2_PIN =A5; konstantes Byte LEFT_MOTOR_PWM_PIN =6; konstantes Byte LEFT_MOTOR_EN1_PIN =A3; konstantes Byte LEFT_MOTOR_EN2_PIN =A2; konstantes Byte FRONT_DISTANCE_SENSOR =A0; konstantes Byte BACK_DISTANCE_SENSOR =A1; SoftwareSerial masterComm(11, 10); // RX, TX TextMotorCommandsInterpretter motorCommandsInterpretter(-50, 50, -50, 50); String aktueller Befehl; lange lastCheckedTime; lange lastTransmitTime; boolescher inMotion =false; Void setup () { Serial.begin (9600); masterComm.begin(9600); masterComm.setTimeout(10); pinMode (FLASH_PIN, AUSGANG); pinMode (LEFT_MOTOR_PWM_PIN, AUSGANG); pinMode (LEFT_MOTOR_EN1_PIN, OUTPUT); pinMode (LEFT_MOTOR_EN2_PIN, OUTPUT); pinMode (RIGHT_MOTOR_PWM_PIN, AUSGANG); pinMode (RIGHT_MOTOR_EN1_PIN, AUSGANG); pinMode (RIGHT_MOTOR_EN2_PIN, OUTPUT); lastCheckedTime =millis(); lastTransmitTime =millis(); aufrechtzuerhalten. Void Schleife () { 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(backDistance) + ";"); aufrechtzuerhalten. Void processCommand () { Schalter (currentCommand.charAt (0)) { Fall (MOTOR_COMMAND):steerCar (); brechen; Fall (LIGHT_COMMAND):toggleLight(currentCommand.charAt(2)); brechen; } } Void steerCar () { motorCommandsInterpretter.analizeText (currentCommand); float ProzentLeftMotor =motorCommandsInterpretter.getPercentLeft(); float ProzentRightMotor =motorCommandsInterpretter.getPercentRight(); Serial.write ("Left="); Serial.println (percentLeftMotor); Serial.write ("Right="); Serial.println (percentRightMotor); setMotorsDirection(motorCommandsInterpretter.getDirection()); analogWrite(LEFT_MOTOR_PWM_PIN, ProzentLeftMotor * maxPwmValue); analogWrite(RIGHT_MOTOR_PWM_PIN, ProzentRightMotor * maxPwmValue); inMotion =wahr; lastCheckedTime =millis(); aufrechtzuerhalten. 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); aufrechtzuerhalten. Sonst { 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 ( "Motoren stoppen"); analogWrite (LEFT_MOTOR_PWM_PIN, 0); analogWrite (RIGHT_MOTOR_PWM_PIN, 0); inMotion =falsch; aufrechtzuerhalten. Void toggleLight (char-Befehl) { Serial.println ( "Toggle light"); if (Befehl =='1') { digitalWrite (FLASH_PIN, HIGH); aufrechtzuerhalten. Sonst { DigitalWrite (FLASH_PIN, LOW); } }  

Schritt 5:Installieren und Konfigurieren des Raspberry Pi-Projekts und der Abhängigkeiten

Wie funktioniert es:

Sie sehen ein Diagramm dessen, was ich oben in den angehängten Bildern zu erklären versuche.

a. Die Android-App zeigt das uv4l-Streaming in einer Webansicht an. Der uv4l-Prozess läuft auf dem Raspberry Pi, erfasst den Videoeingang der Kamera und streamt ihn. Es ist ein großartiges Tool mit vielen Funktionen

b. Mit Steuerelementen in der Android-App werden Lichter und Engines Befehle an den MQTT-Server ausgegeben

c. Der Python-Server im Docker-Container auf dem Himbeer-Pi hört auf MQTT-Befehle und übergibt sie über die serielle Schnittstelle an das Arduino. Das Arduino-Board steuert die Motoren und die Lichter.

d. Das Arduino erkennt Entfernungen vor und hinter dem Roboter und sendet die Daten über die serielle Schnittstelle an den Python-Server, der Python leitet sie an den MQTT weiter und sie werden von der Android-Schnittstelle aufgenommen und dem Benutzer angezeigt

Zuerst Sie benötigen ein vollständig installiertes und konfiguriertes Raspbian auf dem Raspberry Pi, und die Kamera muss psychisch verbunden und konfiguriert sein. Außerdem wird die gesamte Konfiguration mit ssh durchgeführt, daher ist es eine gute Sache, sie zu konfigurieren.

Wir können hier nicht alle grundlegenden Dinge behandeln, aber versuchen Sie es bei Bedarf mit diesen Links:

Wenn Sie nicht wissen, wie Sie das Raspbian-Betriebssystem installieren, überprüfen Sie diesen Link. Weitere Informationen zum Installieren und Aktivieren der Kamera finden Sie in diesem offiziellen Artikel.

Um zu erfahren, wie Sie ssh unter Raspbian konfigurieren, überprüfen Sie dies.

Wenn Sie Ihren Roboter mit der Android-App von außerhalb des WLANs steuern möchten, sollten Sie eine Portweiterleitung auf Ihrem WLAN-Router in Betracht ziehen, da Sie sonst Ihre lokalen IP-Adressen in Ihrem WLAN verwenden können.

Um Ihre lokale IP-Adresse auf dem Himbeer-Pi herauszufinden, verwenden Sie "ifconfig":

ifconfig ......... eth0 Link encap:Ethernet HWaddr b8:27:eb:16:e7:ff inet6 addr:fe80::ff00:f22f:9258:b92b/64 Geltungsbereich:Link UP BROADCAST MULTICAST MTU:1500 Metrisch:1 RX-Pakete:0 Fehler:0 fallengelassen:0 Überläufe:0 Frame:0 TX-Pakete:0 Fehler:0 fallengelassen:0 Überläufe:0 Träger:0 Kollisionen: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 Maske:255.255.255.0 inet6 addr:fe80::e1f4:5112:9cb2:3839/64 Geltungsbereich:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Metrisch:1 RX-Pakete:1678396 Fehler:0 verloren:0 Überläufe:0 Rahmen:0 TX Pakete:381859 Fehler:0 Dropped:0 Overruns:0 Carrier:0 Kollisionen:0 txqueuelen:1000 RX bytes:259428527 (247,4 MiB) TX bytes:187573084 (178.8 MiB) .....  

Uns interessiert die wlan0 inet addr, in unserem Fall "192.168.0.102"

Die weiterzuleitenden Ports (Standardwerte) sind:9090 für uv4l und 1883 für mosquitto. Sie können diese Ports an dieselben Ausgabeports weiterleiten, wenn sie nicht von der Firewall des Internetanbieters oder einigen anderen Ports gesperrt sind.

Portweiterleitung wird bei jedem Router anders gemacht, hier sind einige Tutorials:dies, und Sie können auch versuchen, auf Google zu suchen "Portweiterleitung your_router_model ", um relevantere Ergebnisse zu sehen.

Voraussetzungen:

a. git über die Befehlszeile installieren

b. Klonen Sie das Github-Projekt im Home-Ordner:

Der Speicherort des Ordners ist wichtig, da der Speicherort in docker-compose.yml fest codiert ist als:/home/pi/robot-camera-platform:/root/debug Wenn Sie den Speicherort ändern müssen, ändern Sie bitte den Wert in docker-compose auch

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

C. Deaktivieren Sie die serielle Konsole des Pi, wenn Sie nicht wissen, wie das geht, überprüfen Sie diesen Link

Uv4l-Streaming installieren:

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

Wenn dies fehlschlägt oder Sie mehr Details zu uv4l erfahren möchten, lesen Sie dieses Tutorial.

Konfiguration:

a. durch Bearbeiten von uv4l/start.sh Sie können die folgenden Aspekte des Videostreamings konfigurieren:Passwort, Port, Bildrate, Höhe, Drehung und einige andere kleinere Aspekte

b. config.py bearbeiten und Passwort ersetzen mit Ihrem eigenen Passwort, das Sie auf dem Mosquitto-Server festgelegt haben

c. Bearbeiten Sie docker-container/mosquitto/Dockerfile und ersetzen Sie diese Zeile

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

mit eigenem Benutzer und Passwort für mosquitto

d. Bearbeiten Sie config.py und ersetzen Sie den seriellen Port und Baudrate mit Ihrer eigenen, ich empfehle Ihnen jedoch, die Baudrate beizubehalten. Wenn Sie es ändern möchten, vergessen Sie nicht, dies auch in der Arduino-Skizze zu bearbeiten

UV4l-Installation testena. Starten Sie es:

sh ./uv4l/start.sh  

b. Testen Sie es im Browser unter der Adresse:http://your_ip:9090/stream

c. Hör auf damit

sudo pkill uv4l  

Docker und docker-compose installieren

Über die Docker-Installation:https://www.raspberrypi.org/blog/docker-comes-to-...

Über die Docker-Compose-Installation:https://www.raspberrypi.org/blog/docker-comes-to-...

Dienste beim Neustart/Start automatisch starten

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.