Websocket Python

a marqué ce sujet comme résolu.
Auteur du sujet

Bonjour

Je fais quelques tests pour commander à distance un bras robotisé via un Raspberry pi.

Pour ce projet j’utilise déjà un programme en Python qui me permet de streamer ce que vois la camera sur une page web.

Ce programme utilise les websockets.

Et je me dis que je pourrais passer aussi par ce système pour envoyer d’autre donner. Comme un appuis sur une touche ou une une position de souris par exemple.

Je n’est aucune notion en Python :honte: alors je fais appel a vous.

Dans le code ci-dessous, comment ajouter la réception et le traitement d’une nouvel requête ?

#!/usr/bin/env python



import sys

import io

import os

import shutil

from subprocess import Popen, PIPE

from string import Template

from struct import Struct

from threading import Thread

from time import sleep, time

from http.server import HTTPServer, BaseHTTPRequestHandler

from wsgiref.simple_server import make_server



import picamera

from ws4py.websocket import WebSocket

from ws4py.server.wsgirefserver import (

    WSGIServer,

    WebSocketWSGIHandler,

    WebSocketWSGIRequestHandler,

)

from ws4py.server.wsgiutils import WebSocketWSGIApplication



###########################################

# CONFIGURATION

WIDTH = 900

HEIGHT = 500

FRAMERATE = 60

HTTP_PORT = 8082

WS_PORT = 8084

COLOR = u'#444'

BGCOLOR = u'#333'

JSMPEG_MAGIC = b'jsmp'

JSMPEG_HEADER = Struct('>4sHH')

VFLIP = False

HFLIP = False



###########################################





class StreamingHttpHandler(BaseHTTPRequestHandler):

    def do_HEAD(self):

        self.do_GET()



    def do_GET(self):

        if self.path == '/':

            self.send_response(301)

            self.send_header('Location', '/index.html')

            self.end_headers()

            return

        elif self.path == '/jsmpg.js':

            content_type = 'application/javascript'

            content = self.server.jsmpg_content

        elif self.path == '/index.html':

            content_type = 'text/html; charset=utf-8'

            tpl = Template(self.server.index_template)

            content = tpl.safe_substitute(dict(

                WS_PORT=WS_PORT, WIDTH=WIDTH, HEIGHT=HEIGHT, COLOR=COLOR,

                BGCOLOR=BGCOLOR))

        else:

            self.send_error(404, 'File not found')

            return

        content = content.encode('utf-8')

        self.send_response(200)

        self.send_header('Content-Type', content_type)

        self.send_header('Content-Length', len(content))

        self.send_header('Last-Modified', self.date_time_string(time()))

        self.end_headers()

        if self.command == 'GET':

            self.wfile.write(content)





class StreamingHttpServer(HTTPServer):

    def __init__(self):

        super(StreamingHttpServer, self).__init__(

                ('', HTTP_PORT), StreamingHttpHandler)

        with io.open('index.html', 'r') as f:

            self.index_template = f.read()

        with io.open('jsmpg.js', 'r') as f:

            self.jsmpg_content = f.read()





class StreamingWebSocket(WebSocket):

    def opened(self):

        self.send(JSMPEG_HEADER.pack(JSMPEG_MAGIC, WIDTH, HEIGHT), binary=True)





class BroadcastOutput(object):

    def __init__(self, camera):

        print('Spawning background conversion process')

        self.converter = Popen([

            'ffmpeg',

            '-f', 'rawvideo',

            '-pix_fmt', 'yuv420p',

            '-s', '%dx%d' % camera.resolution,

            '-r', str(float(camera.framerate)),

            '-i', '-',

            '-f', 'mpeg1video',

            '-b', '800k',

            '-r', str(float(camera.framerate)),

            '-'],

            stdin=PIPE, stdout=PIPE, stderr=io.open(os.devnull, 'wb'),

            shell=False, close_fds=True)



    def write(self, b):

        self.converter.stdin.write(b)



    def flush(self):

        print('Waiting for background conversion process to exit')

        self.converter.stdin.close()

        self.converter.wait()





class BroadcastThread(Thread):

    def __init__(self, converter, websocket_server):

        super(BroadcastThread, self).__init__()

        self.converter = converter

        self.websocket_server = websocket_server



    def run(self):

        try:

            while True:

                buf = self.converter.stdout.read1(32768)

                if buf:

                    self.websocket_server.manager.broadcast(buf, binary=True)

                elif self.converter.poll() is not None:

                    break

        finally:

            self.converter.stdout.close()





def main():

    print('Initializing camera')

    with picamera.PiCamera() as camera:

        camera.resolution = (WIDTH, HEIGHT)

        camera.framerate = FRAMERATE

        camera.vflip = VFLIP # flips image rightside up, as needed

        camera.hflip = HFLIP # flips image left-right, as needed

        sleep(1) # camera warm-up time

        print('Initializing websockets server on port %d' % WS_PORT)

        WebSocketWSGIHandler.http_version = '1.1'

        websocket_server = make_server(

            '', WS_PORT,

            server_class=WSGIServer,

            handler_class=WebSocketWSGIRequestHandler,

            app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket))

        websocket_server.initialize_websockets_manager()

        websocket_thread = Thread(target=websocket_server.serve_forever)

        print('Initializing HTTP server on port %d' % HTTP_PORT)

        http_server = StreamingHttpServer()

        http_thread = Thread(target=http_server.serve_forever)

        print('Initializing broadcast thread')

        output = BroadcastOutput(camera)

        broadcast_thread = BroadcastThread(output.converter, websocket_server)

        print('Starting recording')

        camera.start_recording(output, 'yuv')

        try:

            print('Starting websockets thread')

            websocket_thread.start()

            print('Starting HTTP server thread')

            http_thread.start()

            print('Starting broadcast thread')

            broadcast_thread.start()

            while True:

                camera.wait_recording(1)

        except KeyboardInterrupt:

            pass

        finally:

            print('Stopping recording')

            camera.stop_recording()

            print('Waiting for broadcast thread to finish')

            broadcast_thread.join()

            print('Shutting down HTTP server')

            http_server.shutdown()

            print('Shutting down websockets server')

            websocket_server.shutdown()

            print('Waiting for HTTP server thread to finish')

            http_thread.join()

            print('Waiting for websockets thread to finish')

            websocket_thread.join()





if __name__ == '__main__':

    main()

Je n’ai pas la solution mais j’admire le problème…

+0 -0

Salut,

Ta websocket n’est ici utilisée que pour envoyer des données du serveur vers le client, donc cela demandera un peu de travail pour arriver à ce que tu souhaites.
Des infos seront donc déjà à trouver auprès de la lib ws4py pour recevoir des données sur le serveur.

Mais aussi, il y a toute la partie cliente à réaliser, où le code du fichier jsmpg.js doit se charger d’envoyer les événements correspondant au serveur.

Auteur du sujet

Merci je vais me pencher dessus.

La communication se fait dans les deux sens ?

Le client peut envoyer des requêtes au serveur ?

Je n’ai pas la solution mais j’admire le problème…

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte