MiWiC > Robotique & RC > Robot commandé par Raspberry Pi par réseau Wifi et vision de la caméra

Robot commandé par Raspberry Pi par réseau Wifi et vision de la caméra

 

Expert

Tuto créé par vince574, le 4 février 2019

 

Salut à tous c’est Vince574,

Je vais vous expliquer de A à Z la fabrication d’un robot piloté par Raspberry Pi par réseau Wi-fi et la visualisation de sa caméra en direct sur un réseau Wifi.

Je vais juste détailler la partie implémentation du Raspberry Pi car la fabrication de la base du robot et la partie commande des moteurs est déjà expliqué dans le tutoriel précédent que voici :

N’hésitez pas à poser des questions !

Je pense qu’en travaillant un peu tous les jours et en suivant mon tutoriel, la fabrication du robot en entier devrait durer une semaine.

Outils nécessaires

 

Suivez le guide !

 

 

1

 

Je vais vous tout d'abord vous expliquer comment visionner l'image de la caméra du Raspberry sur un réseau Wi-fi. Pour cela j'ai utilisé un Raspberry 3 et la caméra Raspberry dans le kit "ensemble camera raspberry pi 3".

Il faut tout d'abord installer le système d'exploitation Noobs.

 

2

 

Une fois le système d'exploitation installé, il faut paramétrer la caméra et envoyer les images capturés sur le réseau Wi-fi du raspberry.

Pour cela il est nécessaire de la configurer :

Pour cela ouvrer le terminal et entrer la commande : $ sudo raspi-config

Une fois dans le menu de configuration il est nécessaire d'active la caméra, pour cela il suffit d'activer l'enable de la caméra

 

3

 

L'étape d'après consiste à tester si la caméra est bien fonctionnelle ou non. Pour cela rentrer les commandes suivantes :

$ cd /home/pi/Pictures/
$ raspistill -o img1.jpg

Ces commandes permettent de se déplacer dans le répertoire Pictures et d'y prendre une photo.

Allez visualiser si elle est bien présente.

Voici la commande pour prendre une vidéo de 10 secondes :

$ raspivid -o video.h264 -t 10000

 

 

4

 

Une fois que la caméra est fonctionnelle il faut configurer le raspberry comme un point d'accès Wi-fi pour pouvoir y venir se connecter grâce à son smartphone et visualiser l'image de la caméra et pouvoir piloter le robot.

Pour créer le point d'accès Wi-fi j'ai suivi ce tutoriel qui est très bien expliqué : http://hardware-libre.fr/2014/02/raspberry-pi-creer-un-point-dacces-wifi/

 

5

 

En amont d'écrire un programme sous python, il faut :

- Charger la bibliothèque Rpi.GPIO.
Il faut d'abord charger l'archive et l'extraire.

$ sudo apt-get install python-dev
$ sudo wget http://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.4.1a.tar.gz
$ tar -zxf RPi.GPIO-0.4.1a.tar.gz

Il faut ensuite se placer dans le répertoire créé puis lancer l'installation avec python.

$ cd RPi.GPIO-0.4.1a
$ sudo python setup.py install

 

6

 

Il faut ensuite se connecter à distance au Raspberry Pi avec un PC grâce à l'adresse IP du raspberry qu'on obtient grâce à la commande (cf configuration du réseau internet):

$ ifconfig

 

7

 

Le programme qui tourne sous python à besoin d'une page HTML d'index, des dessins et une feuille de style CSS. La hiérarchie suivante doit être respectée.
Le contenu du dossier webpyserver logiquement placé dans /home/pi/web.py-0.37/webpyserver, contient le programme python robot2.py et 2 sous dossiers.
static -> pour y placer la page index.html
templates -> pour y placer les images et la feuille de style robot2.css

L'arborescence est créée avec les commandes

$ cd /
$mkdir webpyserver
$cd /webpyserver
$mkdir templates
$mkdir static

 

8

 

Voici le code permettant de contrôler l'ensemble du robot :

Je vous mets une image du câblage dont je me suis inspiré

[code]
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
import web
import spidev
import RPi.GPIO as GPIO
from RPIO import PWM
from web import form
import threading

# definit GPIO en sortie
GPIO.setmode(GPIO.BCM)
PWM.setup()
PWM.init_channel(0)

pins = [17,18,22,24,25,27,4]

for pin in pins:

GPIO.setup(pin, GPIO.OUT)
GPIO.output(pin, GPIO.LOW)


vitmotd = GPIO.PWM(4,500)
vitmotg = GPIO.PWM(27,500)
vset = 30

horizontal=150
vertical=150

GPIO.setup(15, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

def StopEvent(pin):
print("Detection obstacle")
vitmotd.stop()
vitmotg.stop()
GPIO.output(25,0)
GPIO.output(24,0)
Volt()

def Volt():

spiDevice = spidev.SpiDev()
channel = 0
spiDevice.open(0,0)
values = spiDevice.xfer2([1,(8+channel)<<4,0])
index = ((values[1]&3) << 8) + values[2]
print "Tension =", round(index*(13.2/1023),2),"V"
if index 180:

vertical = 180

elif userdata.orientation=='bth':

vertical=vertical - 2
if vertical < 120:

vertical = 120

elif userdata.orientation=='btd':

horizontal=horizontal - 2
if horizontal 180:

horizontal = 180

class ServoThread(threading.Thread):
def run(self) :

global vertical
global horizontal
while True :

PWM.add_channel_pulse(0, 17, 0, horizontal)
PWM.add_channel_pulse(0, 18 ,0, vertical)
time.sleep(0.05)

# programme
if __name__ == '__main__':
myServo= ServoThread()
myServo.start()
GPIO.add_event_detect(15, GPIO.RISING)
GPIO.add_event_callback(15,StopEvent,50)
app.run()

[/code]

 

9

 

Parlons du schéma électrique. Pour l'alimentation du Raspberry je n'ai pas utilisé un convertisseur 12/5V mais un powerbank. La batterie de 12V est nécessaire pour les moteurs. Quant aux contrôleurs moteurs comme sur mes précédents tutoriels j'ai utilisé les L293D.

 

10

 

Voilà, il ne reste plus qu'à se connecter à l'adresse IP du Raspberry et voici le contrôle que vous obtiendrez :

 

11

 

Concernant le visualisation de la caméra, il faut réaliser les étapes suivantes :

On utilise la commande raspivid pour une capture video en streaming et VLC pour la lecture. VLC va lire un flux Rtsp ( protocole de streaming en temps réel).
Le plus simple est de créer un fichier bash, donc exécutable par le Raspberry Pi. On lui donne le nom de camera.sh. On copie dans le fichier le texte suivant:


#!/bin/bash
echo "mise en route de la camera"
echo "VLC rtps://192.168.1.25:8554/"
raspivid -o - -t 0 -n -w 600 -h 400 -fps 12 | cvlc -vvv stream:///dev/stdin --sout '#rtp{sdp=rtsp://:8554/}' :demux=h264
Pour exécuter le fichier avec la console, on tape:

$./camera.sh

Les réglages peuvent être modifiés mais une image trop grande ou trop d'images par seconde risque de ralentir le fonctionnement. Le streaming fonctionne avec des tampons mémoires.

Les arguments :

"-o -" écriture du flux en sortie
"-t 0" pas de timeout
"-n" pas de flux sur la sortie HDMI (écran)
"cvlc" utilise VLC
"-sout" argument qui spécifie le flux rtsp et son Port
"-w" largeur de l'image: 64 to 1920
"-h" hauteur de l'image: 64 to 1080
"-fps" nombre d'images par seconde: 2 to 30
"demux=h264" format du fichier de sortie

Du côté de VLC, il suffit de choisir dans le menu fichier -> ouvrir un flux réseau et d'entrer l'adresse IP du Raspberry Pi précédée de rtsp:// et suivi du port :8554/

 

12

 

Voilà donc le projet n'est pas totalement aller à terme car j'aimerai bien pouvoir visualiser l'image de la caméra en direct sur le contrôle.

Je suis en train d'y bosser dessus et je mettrai le tutoriel à jour lorsque cela marchera.

A+ les amis,

 

Lancez-vous !
Une question, une hésitation ? Rejoignez notre communauté Facebook pour échanger sur le sujet !