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

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 :

Robot se repérant dans l’espace grâce à ses encodeurs

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.

  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,
Réalisé par
Posté le
Univers
Robotique & RC
Temps de fabrication
3 jours
Niveau de difficulté
Expert
Matériel(s)
5
Fils de connexion
1
Raspberry pi 3 B
1
Camera Raspberry
2
Controleur moteur L293D
1
Batterie 12V
1
Powerbank 5V
2
Moteurs 12V
2
roues
2
Bille de manutention
Outils
1
Tournevis
1
scie à métaux
1
Fer à souder

Aucun commentaire. Soyez le premier à en écrire un !

Vous devez être connecté pour laisser un commentaire.