Raspberry faire un stream avec la picamera

Depuis un navigateur internet, nous allons voir le stream de la picamera connecté au Raspberry facilement.

Depuis pas mal de temps, j’ai une Picamera que j’ai déjà testé avec différente manière, il est temps d’aller un peu plus loin, j’ai cherché à faire du streaming avec la Picamera connectée à mon Raspberry.

Au début, cela me paraissait compliquer, il y avait plein de point obscure pour moi, après pas mal de recherche, j’ai pensé que ce n’était pas possible, certes, il y a plein de méthodes (au moins 5 sur magdiblog) mais celle-ci ne me convenait pas, je voulais passer par du Python (allez savoir pourquoi…)

Après plusieurs heures de recherche et de test, je suis tombé sur ce site et enfin, j’ai trouvé une solution pour faire du streaming de ma cam, avec une latence suffisamment faible et une qualité suffisamment correct pour l’intégrer plus tard dans des projets plus amibitieux.

Je me base sur le site, mais j’ai simplifié son contenu pour ne garder que le nécessaire

Je tiens à préciser que je voulais que le stream soit facilement visualisable et surtout actif seulement lorsque je suis sur la page web.

Matériels requis

Pour suivre ce petit article, vous allez avoir besoin :

  • un Raspberry (j’ai fait le test avec un Raspberry Pi B+)
  • une picamera (j’ai la version 2)

Installations des dépendances requises

Coté software, j’ai installé sur mon Raspberry un serveur LAMP mais je précise qu’il n’est pas nécessaire mais sachant que un streaming simple sans rien derrière n’est pas forcément utile, j’ai tout placé dans un dossier web, voir installation d’un serveur internet.

Maintenant pour les paquets, nous allons installer les paquets nécessaires pour la picamera, installation de Flask, de Pip (pour installer Flask), dans un terminal :

sudo apt-get install python-pip python-picamera

Ensuite, nous allons installer Flask, il s’agit d’un projet qui permettra de faire notre streaming, toujours dans le terminal :

sudo pip install Flask

L’installation s’effectue sans soucis, il s’agit des seules installations à faire.

Mise en place du streaming

Dans mon cas, j’ai fait l’installation dans /var/www/html, je me suis placé dans ce dossier pour la suite mais je garde les chemins absolus pour plus de lisibilité

L’ensemble du projet est disponible sur le git de Miguel Grinberg, dans l’article qui suit, je ne mets que l’indispensable.

Commencez par créer un dossier : mkdir /var/www/html/templates

Puis à l’intérieur, je crée mon fichier index.html : nano /var/www/html/templates/index.html  et j’y inscris :

<html>
  <head>
    <title>Video Streaming Demonstration</title>
  </head>
  <body>
    <h1>Video Streaming Demonstration</h1>
    <img src="{{ url_for('video_feed') }}">
  </body>
</html>

Ne modifiez pas la source de l’image

Ensuite, dans le dossier /var/www/html, je vais créer 2 fichiers en python.

  • app.py, contient :
    #!/usr/bin/env python
    from flask import Flask, render_template, Response
    
    # Raspberry Pi camera module (requires picamera package)
    from camera_pi import Camera
    
    app = Flask(__name__)
    
    
    @app.route('/')
    def index():
        """Video streaming home page."""
        return render_template('index.html')
    
    
    def gen(camera):
        """Video streaming generator function."""
        while True:
            frame = camera.get_frame()
            yield (b'--frame\r\n'
                   b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
    
    
    @app.route('/video_feed')
    def video_feed():
        """Video streaming route. Put this in the src attribute of an img tag."""
        return Response(gen(Camera()),
                        mimetype='multipart/x-mixed-replace; boundary=frame')
    
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', debug=True, threaded=True)

    Sur la dernière ligne, remplacez les 0.0.0.0 par l’adresse IP de votre Raspberry

  • camera_py.py :
    import time
    import io
    import threading
    import picamera
    
    
    class Camera(object):
        thread = None  # background thread that reads frames from camera
        frame = None  # current frame is stored here by background thread
        last_access = 0  # time of last client access to the camera
    
        def initialize(self):
            if Camera.thread is None:
                # start background frame thread
                Camera.thread = threading.Thread(target=self._thread)
                Camera.thread.start()
    
                # wait until frames start to be available
                while self.frame is None:
                    time.sleep(0)
    
        def get_frame(self):
            Camera.last_access = time.time()
            self.initialize()
            return self.frame
    
        @classmethod
        def _thread(cls):
            with picamera.PiCamera() as camera:
                # camera setup
                camera.resolution = (320, 240)
                camera.hflip = True
                camera.vflip = True
    
                # let camera warm up
                camera.start_preview()
                time.sleep(2)
    
                stream = io.BytesIO()
                for foo in camera.capture_continuous(stream, 'jpeg',
                                                     use_video_port=True):
                    # store frame
                    stream.seek(0)
                    cls.frame = stream.read()
    
                    # reset stream for next frame
                    stream.seek(0)
                    stream.truncate()
    
                    # if there hasn't been any clients asking for frames in
                    # the last 10 seconds stop the thread
                    if time.time() - cls.last_access > 10:
                        break
            cls.thread = None
    

     

Voilà, il s’agit des seuls fichiers à devoir installer.

Utilisation et mise en route du streaming de la picamera

Mise en route du streaming

Maintenant toujours en étant dans votre dossier (le mien /var/www/html), faites : python ./app.py , cela va lancer le serveur de votre picamera

Visualiser votre streaming

Maintenant pour visualiser votre stream, depuis un navigateur, saisir l’adresse ip sur le  port 5000, dans mon cas : 192.168.43.156:5000, et vous allez voir apparaître ce que vois votre picamera.

Raspberry streaming avec la picamera
Raspberry streaming avec la picamera

Voilà, à vous de vous faire plaisir.

N’hésitez pas à partager (et oui pas d’autres sources en français de cette méthode) et à commenter.

 

Laisser un commentaire