Mobiele bewakingscamera op afstand

Over dit project

Dit interessante maar gecompliceerde project omvat zaken van het ontwerpen van een robot tot geavanceerde configuraties in linux (raspberry pi) tot het bouwen van een Android-applicatie en het besturen van de robot.

Dit gezegd zijnde, is het ambitieuzer dan de gemiddelde projecten, maar ik denk dat je veel te leren hebt door hier enkele ideeën te onderzoeken of zelfs het hele project te repliceren.

Eerst bouwen we de robot met behulp van plexiglas, plastic platen, gelijkstroommotoren met versnellingsbakken en verschillende elektronische componenten. Het apparaat kan de twee voorwielen onafhankelijk van elkaar bewegen en kan zijn koplamp gebruiken. Daarna gaan we de Raspberry Pi opzetten die de robot aandrijft en het project configureren en verschillende afhankelijkheden installeren. Daarna gaan we een Android-app bouwen en installeren en deze gebruiken om de robot op afstand te besturen met behulp van de camera en een wifi-verbinding.

De technologieën en concepten zullen hier worden onderzocht :

Ontwikkelingsplatforms:Arduino, Raspberry pi, Android

Elektronica:H-brug, met behulp van een transistor om een ​​grote belasting aan te sturen, infraroodsensoren

Linux:docker gebruiken, docker compose, services configureren met systemctl, videostreaming

Programmering:Android-applicaties, python, arduino-taal, seriële communicatie, MQTT

Stap 1:Dingen die nodig zijn

Onderdelen:

1. Plexiglas plaat

2. Plastic plaat (u kunt hier ook een plaat van plexiglas gebruiken)

3. Lijm

4. Band + gelijkstroommotor met versnellingsbak + beugel. Kleine moeren en bouten, zeshoekige metalen afstandhouders

6. 2 x elke directionele wielband

7. Kleine LED-zaklamp (deze wordt omgevormd tot een koplamp)

8. Arduino pro mini 328p

9. 2 x infrarood obstakelsensor

10. PCB

11. NPN-transzistor (om de zaklamp aan te drijven)

12. L7805CV 5V-regelaar

13. L298 H-brug

14. Rezistor 220 Ohm

15. Mannelijke USB-connector

16. Mannelijke micro-usb-connector

17. Diverse draden

18. 3 v-regelaar (voor communicatie tussen arduino en raspberry pi)

19. Mannelijke en vrouwelijke PCB-connectoren

20. Aan/uit schakelaar

21. XT-60 vrouwelijke LiPo-connector

22. 2S 1300 mAh LiPo-batterij met XT-60-connector

23. 5v batterijpakket

24. Raspberry Pi 3

25. Raspberry Pi-kaart

26. Raspberry Pi-behuizing

27. Raspberry Pi-camera

Hulpprogramma's: 1. USB naar seriële FTDI-adapter FT232RL om de arduino pro mini te programmeren

2. Arduino IDE

3. Boor

4. Fijnbladige zaag

5. Schroevendraaiers

6. Soldeerbout

7. Draadknipper

Vaardigheden:

1. Solderen, bekijk deze tutorial

2. Basis Arduino-programmering, deze tutorial kan nuttig zijn

3. Linux-serviceconfiguratie, pakketinstallatie

Stap 2:Het robotplatform bouwen

De robot we gaan bouwen, heeft de volgende specificaties :

- Het heeft tractie op de voorwielen door twee afzonderlijke DC-motoren

- de achterwielen moeten 360 graden in elke richting kunnen bewegen

- de richting wordt gecontroleerd door de snelheid op de voorwielen te variëren, dus er is geen afzonderlijk richtingsmechanisme nodig, ook de robot kan ter plaatse draaien

- er zitten lampjes aan de bovenkant

- er moet voldoende ruimte zijn voor de elektronica, batterijen en een Raspberry Pi-behuizing met een camera

- een paar cm bodemvrijheid is nodig om kleine obstakels te overwinnen

Vergeet niet de afbeeldingen te bekijken voor belangrijke details en bouwtips.

We gaan de robot bouwen van plexiglas of hard plastic, ik heb ze allebei gebruikt, maar je kunt kiezen wat je wilt.

De grondplaat zal 18 x 13 cm zijn op de grondplaat zullen de gelijkstroommotoren worden bevestigd met metalen beugels, bouten en moeren. De H-brug wordt in het midden van de plaat naar de vloer toe gemonteerd. De achterwielen worden bevestigd met behulp van 2 cm zeshoekige metalen afstandhouders (een zijde mannelijk en een zijde vrouwelijk)

Een groot gat bij de H-brug is nodig om de elektronica aan de bovenzijde aan te sluiten.

Het bovenste deel van de robot zal bestaan ​​uit twee platen in "L"-vorm, de ene is 12 x 13 cm en de andere 6,5 x 13 cm. De kunststof platen worden aan elkaar gelijmd. Deze platen bieden dekking voor de elektronica, een plaats om de koplamp te monteren en een ondersteuning voor de Raspberry Pi-behuizing. Het bovenste deel wordt vanaf het onderste deel bevestigd met zeshoekige metalen afstandhouders van 6 cm )

Stap 3:De elektronica bouwen

Pinout (arduino):

Led zaklamp:D3

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

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

Infraroodsensoren:voorkant (A0), achterkant (A1)

Raspberry pi-communicatiepinnen:Tx:D11, Rx:D10

De printplaat bouwen, assemblage

1. In de laatste stap hebben we de H-brug al aan de vloerzijde van de robot ondergebracht. We moeten ook de twee infraroodsensoren . installeren een voor en een achter. We gaan ze met een metalen plaatje op het chassis monteren. De metalen plaat heeft de vorm van een "L" en heeft twee gaten. Met moeren en bouten gaan we hem op het chassis monteren. De sensoren bevinden zich in het midden van het chassis, één aan de voorkant en één aan de achterkant.

2. Vervolgens de koplamp deel, ik heb hiervoor een 5 volt led-zaklamp gebruikt. Ik heb de koplamp doorgesneden zodat alleen het "kop" -gedeelte zichtbaar is en twee draden gesoldeerd om hem van stroom te voorzien. Daarna heb ik de koplamp op het midden van het bovenste gedeelte van de robot gelijmd en een gat geboord bij de koplamp, de kabels door het gat gestoken en er een kleine vrouwelijke tweedraads connector aan gesoldeerd.

3. De framboos pi-behuizing in elkaar zetten. Je hebt een raspberry pi, een pi-camera, een geheugenkaart van minimaal 4 GB, een pi-cameraconnector nodig. Plaats de kaart met de nieuwste Raspian geïnstalleerd, neem vervolgens de pi-cameraconnector, plaats deze voorzichtig op de Raspberry pi, plaats deze in de camera en sluit vervolgens de behuizing.

Als je niet weet hoe je het Raspian-besturingssysteem moet installeren, check dan deze link.

Raadpleeg dit officiële artikel voor meer informatie over het installeren en inschakelen van de camera.

4. De printplaat bouwen met de belangrijkste elektronische componenten. Ik heb de fritzing-schema's in fzz-formaat en als afbeelding bijgevoegd. Je kunt het als referentie gebruiken voor het bouwen van de elektronica.

Soldeerstappen:

a. Snijd de vrouwelijke PCB-connectoren door, er zijn twee 12-pins connectoren voor de microcontroller en twee 5-pins connectoren, er zijn twee 3-pins connectoren voor de IR-sensoren, een zes-pins connector voor de H-brug en een pin-connector voor de Raspberry Pi-communicatie (grond, TX, RX) b. Nadat alle connectoren zijn doorgesneden, moet er op de achterkant van de PCB worden gesoldeerd

c. Soldeer de KF301-2P connector

d. Soldeer de NPN-transzistor en de bijbehorende weerstand aan de basis

e. Soldeer de L7805CV 5V regelaar

v. Soldeer de 3,3 volt regelaar op de arduino naar raspeberry pi TX-lijn

g. Soldeer de mannelijke pinnen aan de arduino pro mini

u. Soldeer alle rode (+), zwarte (-) en witte (signaal) dunne draden volgens het fritzig-schema

i. Soldeer een mannelijke connector op het breadboard voor de zaklamp

5. Connectoren

a. Bouw een connector van het 5V USB-batterijpakket naar de Raspberry Pi en Arduino, je hebt een mannelijke USB-connector type A nodig, een mannelijke micro-USB-connector met zwarte en rode draden, krimpkous en een vrouwelijke naar vrouwelijke breadboard-connector. Snijd eerst de vrouwelijke naar vrouwelijke connector in twee, deze delen gaan in de arduino-negatieve en positieve mannelijke pinnen. De type A USB-connector stuurt stroom naar de Arduino en ook naar de Raspberry Pi met behulp van een micro-USB-connector. Bekijk de afbeeldingen voor het solderen van usb-tips.

b. Bouw de connector naar de LiPo-batterij naar de elektronicakaart, hebt u een XT-60 vrouwelijke LiPo-connector, rode en zwarte draden, krimpkous en een kleine schakelaar nodig die 10 A aankan. De zwarte draad wordt rechtstreeks vanaf de XT-60 aangesloten op de elektronicakaart (KF301-2P plug-in schroefconnector), wordt de rode draad aangesloten via de kleine schakelaar

c. Sluit de twee IR-sensoren van de robot aan op de corresponderende vrouwelijke connectoren op de printplaat met behulp van vrouwelijke - mannelijke breadboard-connectoren

d. Sluit de H-brug aan op de 6-pins vrouwelijke connectoren op de PCB met behulp van mannelijke - vrouwelijke breadboard-connectoren

e. Sluit de positieve en negatieve klemmen van de motoren aan op de H-brug

v. Sluit de H-bridge hoofdvoeding aan op de KF301-2P plug-in schroefconnector op de print

6. Voordat je de arduino op de printplaat plaatst, moet je alles dubbel controleren met een vergrootglas en een multimeter

Stap 4:Arduino-code

Eerst moet ik een belangrijke vraag beantwoorden: Waarom moet er een tussenliggende Arduino-laag bestaan ​​en mag de Pi niet rechtstreeks met de elektronica worden verbonden?

1. Het is meer modulair, je kunt de Arduino-robot opnieuw gebruiken in een ander project zonder de PI

2. Voor de veiligheid is het goedkoper om een ​​arduino pro mini van $ 3 te vervangen dan een Pi (35 $) te vervangen

3. Een Arduino die niet wordt onderbroken door het besturingssysteem zoals de pi, dus het is efficiënter om PWM-besturingselementen voor de mottors te implementeren, waarbij de voor- en achtersensoren een paar keer per seconde worden ondervraagd

4. Als er een fout optreedt in het python-script, kan de robot voor altijd de batterijen leegmaken en waarschijnlijk beschadigen of in brand vliegen als hij niet onder toezicht staat, in een Arduino-schets een beveiliging die betrouwbaarder is omdat deze niet afhankelijk is van een besturingssysteem

5. Het is gemakkelijker om een ​​ontkoppeld systeem te debuggen

Ok, dus ik heb het waarom-gedeelte behandeld, ik zal de Arduino-schets een beetje uitleggen. Het doet eigenlijk twee dingen:

1. Het ontvangt motor en licht commando's van de seriële lijn en drijf de motoren aan of schakel het licht in

Bijvoorbeeld:

* "M:-25:16; " betekent (-25 links), en (16 vermogen), het vertaalt zich naar linker motor 17% en rechter motor 32%, en richting vooruit * "M:44:19; " betekent (44 naar rechts) en (19 kracht) het zal vertalen naar:linker motor 38%, rechter motor 5% en richting vooruit

* "L:1; " betekent lichten en "L:0 " lichten uit

2. Het ondervraagt ​​de infraroodsensoren van de achterkant en de voorkant van de robot en verzendt gegevens over afstanden via de seriële lijn

Eerst moet je deze bibliotheek downloaden en installeren:

De hoofdcode bevindt zich hier in de github-repository, of u kunt deze van onderaf kopiëren en plakken.

Upload de code naar de Arduino met behulp van een FTDI-adapter. Nu kun je de robot commando's geven om het te zien werken, hiervoor hoef je alleen maar de tweede seriële lijn aan te sluiten en motor of licht er doorheen te sturen. Een manier om dit te doen is door een bluetooth-module zoals HC-05 te gebruiken en deze met een bluetooth-applicatie op een telefoon aan te sluiten. Geef het dan seriële commando's zoals "L:1"

// source for TextMotorCommandsInterpretter:"https://github.com/danionescu0/arduino/tree/master/libraries/TextMotorCommandsInterpretter" #include  #include  const char MOTOR_COMMAND ='M'; const char LIGHT_COMMAND ='L'; /** * hoe lang het motorcommando van kracht wordt in ms * een binnenkomend motorcommando duurt maxDurationForMottorCommand * als het niet gereset wordt door een ander motorcommando */ const long maxDurationForMottorCommand =300; // pas deze waarde aan om de robotsnelheid te beperken const byte maxPwmValue =230; // Hoe lang tussen opeenvolgende afstandstransmissies in ms const long transmitingInterval =500; const int maxObstacleDetection =1000; // analoog lees max. detectiewaarde const int minObstacleDetection =500; // analoge lees min detectiewaarde const byte FLASH_PIN =3; constbyte RIGHT_MOTOR_PWM_PIN =5; constbyte RIGHT_MOTOR_EN1_PIN =A4; constbyte 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; SoftwareSeriële masterComm (11, 10); // RX, TX TekstMotorCommando'sInterpretter motorCommandsInterpretter (-50, 50, -50, 50); String huidigeCommand; lang laatsteCheckedTime; lang laatsteTransmitTime; boolean inMotion =onwaar; void setup() { Serial.begin(9600); masterComm.begin(9600); masterComm.setTimeout(10); pinMode (FLASH_PIN, UITGANG); pinMode (LEFT_MOTOR_PWM_PIN, UITGANG); pinMode (LEFT_MOTOR_EN1_PIN, UITGANG); pinMode (LEFT_MOTOR_EN2_PIN, UITGANG); pinMode (RIGHT_MOTOR_PWM_PIN, UITGANG); pinMode (RIGHT_MOTOR_EN1_PIN, UITGANG); pinMode (RIGHT_MOTOR_EN2_PIN, UITGANG); lastCheckedTime =millis(); lastTransmitTime =millis(); } void loop() { if (masterComm.available()> 0) { currentCommand =masterComm.readString(); procesCommand(); } if (inMotion &&millis() - lastCheckedTime> maxDurationForMottorCommand) { stopMotors(); } if (millis() - lastTransmitTime> verzendingInterval) { lastTransmitTime =millis(); masterComm.print(getObstacleData()); Serial.print(analogRead(BACK_DISTANCE_SENSOR));Serial.print("---"); Serial.println(getObstacleData()); } /* VOOR DEBUG motorCommandsInterpretter.analizeText("M:-14:40;"); Serial.write("Left==");Serial.println(motorCommandsInterpretter.getPercentLeft()); Serial.write("Right==");Serial.println(motorCommandsInterpretter.getPercentRight()); vertraging (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 (); pauze; case (LIGHT_COMMAND):toggleLight(currentCommand.charAt(2)); pauze; } } 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, procentRightMotor * maxPwmValue); inMotion =waar; lastCheckedTime =millis(); } void setMotorsDirection (boolean forward) { if (forward) { digitalWrite (LEFT_MOTOR_EN1_PIN, HIGH); digitalWrite (LEFT_MOTOR_EN2_PIN, LAAG); digitalWrite (RIGHT_MOTOR_EN1_PIN, HOOG); digitalWrite (RIGHT_MOTOR_EN2_PIN, LAAG); } else { digitalWrite (LEFT_MOTOR_EN1_PIN, LAAG); digitalWrite (LEFT_MOTOR_EN2_PIN, HOOG); digitalWrite (RIGHT_MOTOR_EN1_PIN, LAAG); digitalWrite (RIGHT_MOTOR_EN2_PIN, HOOG); } } void stopMotors() { Serial.println("Stopmotoren"); analogWrite(LEFT_MOTOR_PWM_PIN, 0); analogWrite (RIGHT_MOTOR_PWM_PIN, 0); inMotion =onwaar; } void toggleLight (char-opdracht) { Serial.println ("Toggle light"); if (commando =='1') { digitalWrite (FLASH_PIN, HOOG); } else { digitalWrite (FLASH_PIN, LAAG); } }  

Stap 5:Het Raspberry Pi-project en de afhankelijkheden installeren en configureren

Hoe werkt het:

Je zult een diagram zien van wat ik hierboven zal proberen uit te leggen in de bijgevoegde afbeeldingen.

a. De Android-app toont de uv4l-streaming in een webview. Het uv4l-proces draait op de Raspberry Pi, legt video-invoer van de camera vast en streamt deze. Het is een geweldige tool met veel functies

b. Met behulp van bedieningselementen in de Android-app worden lichten en engine-opdrachten verzonden naar de MQTT-server

c. De python-server in de docker-container op de raspberry pi luistert naar MQTT-commando's en geeft deze via een seriële interface door aan de arduino. Het Arduino-bord bestuurt de motoren en de lichten.

d. De arduino detecteert afstanden voor en achter de robot en stuurt de gegevens via de seriële interface naar de python-server, de python stuurt ze door naar de MQTT en ze worden opgepikt door de Android-interface en getoond aan de gebruiker

Eerste ding heb je een volledig geïnstalleerde en geconfigureerde Raspbian op de Raspberry Pi nodig, en de camera moet psychisch zijn aangesloten en geconfigureerd. Ook alle configuratie zal worden gedaan met behulp van ssh, dus het is een goede zaak om het te configureren.

We kunnen hier niet alle basiszaken behandelen, maar probeer indien nodig deze links:

Als je niet weet hoe je het Raspbian-besturingssysteem moet installeren, kijk dan op deze link. Raadpleeg dit officiële artikel voor meer informatie over het installeren en inschakelen van de camera.

Voor het configureren van ssh op Raspbian, vink dit aan.

Als je je robot wilt besturen met de Android-app van buiten de wifi, moet je port forwarding op je wifi-router overwegen, anders ben je beperkt tot het gebruik van je lokale IP-adressen binnen je wifi.

Gebruik "ifconfig" om uw lokale ip-adres op de raspberry pi te achterhalen:

ifconfig ......... eth0 Link encap:Ethernet HWaddr b8:27:eb:16:e7:ff inet6 addr:fe80::ff00:f22f:9258:b92b/64 Bereik:Link UP BROADCAST MULTICAST MTU:1500 Metrisch:1 RX-pakketten:0 fouten:0 weggevallen:0 overschrijdingen:0 frame:0 TX-pakketten:0 fouten:0 weggevallen:0 overschrijdingen:0 vervoerder:0 botsingen:0 txqueuelen:1000 RX-bytes :0 (0.0 B) TX bytes:0 (0.0 B) ........ wlan0 Link encap:Ethernet HWaddr 00:c1:41:00:10:f6 inet addr:192.168.0.102 Bcast:192.168.0.255 Mask:255.255.255.0 inet6 addr:fe80::e1f4:5112:9cb2:3839/64 Scope:Link UP BROADCAST RUNNING MULTICAST MTU:1500 Metrisch:1 RX-pakketten:1678396 fouten:0 gedaald:0 overschrijdingen:0 frame:0 TX pakketten:381859 fouten:0 gedaald:0 overschrijdingen:0 vervoerder:0 botsingen:0 txqueuelen:1000 RX bytes:259428527 (247,4 MiB) TX bytes:187573084 (178,8 MiB) .....  

We zijn geïnteresseerd in de wlan0 inet-addr, in ons geval "192.168.0.102"

De poorten die moeten worden doorgestuurd (standaard) zijn:9090 voor uv4l en 1883 voor mosquitto. Je kunt deze poorten doorsturen naar dezelfde uitvoerpoorten als ze niet zijn verbannen uit de firewall van de internetprovider of andere poorten.

Port forwarding is iets dat op elke router anders wordt gedaan, hier zijn enkele tutorials:dit, en je kunt ook proberen te zoeken op google "port forwarding your_router_model " om meer relevante resultaten te zien.

Vereisten:

a. installeer git via de opdrachtregel

b. kloon het github-project in de thuismap:

De maplocatie is belangrijk omdat in docker-compose.yml de locatie hard gecodeerd is als:/home/pi/robot-camera-platform:/root/debug Als u de locatie moet wijzigen, wijzigt u de waarde in docker-compose ook

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

C. schakel de seriële console van de pi uit, als je niet weet hoe je dat moet doen, kijk dan op deze link

Installeer Uv4l-streaming:

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

Als dit niet lukt of als je meer details over uv4l wilt weten, bekijk dan deze tutorial.

Configuratie:

a. door uv4l/start.sh . te bewerken u kunt de volgende aspecten van de videostreaming configureren:wachtwoord, poort, framesnelheid, met, hoogte, rotatie en enkele andere kleine aspecten

b. bewerk config.py en vervang wachtwoord met je eigen wachtwoord dat je hebt ingesteld op de muggenserver

c. bewerk docker-container/mosquitto/Dockerfile en vervang deze regel

VOER mosquitto_passwd -b /etc/mosquitto/pwfile gebruiker your_password uit 

met uw eigen gebruiker en wachtwoord voor mug

d. bewerk config.py en vervang seriële poort en baudrate met die van u, ik raad u aan de baudrate echter te behouden. Als je het wilt veranderen, vergeet dan niet om dat ook op de Arduino-schets te bewerken

Uv4l-installatie testen. Begin ermee:

sh ./uv4l/start.sh  

b. Test het in de browser op het adres:http://your_ip:9090/stream

c. Stop ermee

sudo pkill uv4l  

Installeer docker en docker-compose

Over de installatie van docker:https://www.raspberrypi.org/blog/docker-comes-to-...

Over de installatie van docker-compose:https://www.raspberrypi.org/blog/docker-comes-to-...

Automatisch startende services bij opnieuw opstarten/opstarten

Door de services automatisch te laten starten, elimineert u de noodzaak om handmatig in te loggen via ssh en vervolgens alle services handmatig te activeren, we gaan dit doen met systemctl.

a. Kopieer de bestanden van de map systemctl in de map systemctl naar /etc/systemd/system/

b. Diensten inschakelen

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.