def main():
print('Initializing HAT')
hat.servo_enable(1, False)
hat.servo_enable(2, False)
hat.light_mode(hat.WS2812)
hat.light_type(hat.GRBW)
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('Disabling servos')
hat.servo_enable(1, False)
hat.servo_enable(2, False)
hat.clear()
hat.show()
print('Waiting for websockets thread to finish')
websocket_thread.join()
def run(self):
global host, port, rbox, uboxlog
logger.info('PyRecordBox is running...')
rbox = self
self.rbox = RecordBox()
_rboxCallback = self.rbox.makeCallback(rboxCallback)
if uboxlog:
self.rbox.open_logfile()
self.rbox.open(_rboxCallback)
try:
self.server = make_server(
host,
port,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=PhoneWebSocket))
self.server.initialize_websockets_manager()
self.server.serve_forever()
except KeyboardInterrupt:
self.rbox.close()
self.rbox.close_logfile()
def start(self, ctx=None):
_logger.debug("Starting Websocket engine...")
dispatcher.mount('/ws',
WebSocketWSGIApplication(handler_cls=WSConnection))
_logger.debug("Websocket engine started.")
def __init__(self, port=5570, cb_recept=None, log=None):
global __ctrlServer__
# check free port
for s in __ctrlServer__:
if s.port == port:
if log:
log.error(
"Creating WS server error, port %d allready used." %
port)
raise WsUIServerException(
"Creating WS server error, port %d allready used." % port)
self.buffer = []
self.clients = set()
self.fail_clients = set()
self.running = False
self.port = port
self.cb_recept = cb_recept
self.log = log
self.server = make_server(
'',
port,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=WebSocketsHandler))
self.server.initialize_websockets_manager()
__ctrlServer__.append(self)
servUI = threading.Thread(None, self.run, "th_WSserv_msg_to_ui", (),
{})
servUI.start()
time.sleep(0.1)
if self.log:
self.log.info('WebSocket server started on port : %d' % self.port)
print "**************** WebSocket server is started on port %d ********************" % self.port
def __init__(self, host, port):
self.host = host
self.port = port
self.ws = WebSocketWSGIApplication(handler_cls=HQCWebSocket)
self.clients = []
# TODO: remove clients when they exit
self.current_clients = {}
def __init__(self):
print('Initializing camera')
self.camera = picamera.PiCamera()
self.camera.resolution = (WIDTH, HEIGHT)
self.camera.framerate = FRAMERATE
self.camera.vflip = VFLIP # flips image rightside up, as needed
self.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'
self.websocket_server = make_server(
'',
WS_PORT,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket))
self.websocket_server.initialize_websockets_manager()
self.websocket_thread = Thread(
target=self.websocket_server.serve_forever)
print('Initializing HTTP server on port %d' % HTTP_PORT)
self.http_server = StreamingHttpServer()
self.http_thread = Thread(target=self.http_server.serve_forever)
print('Initializing broadcast thread')
self.output = BroadcastOutput(self.camera)
self.broadcast_thread = BroadcastThread(self.output.converter,
self.websocket_server)
def start(self):
# Start video server streaming
print('Initializing websockets server on port %d' % WS_PORT)
self.websocket_server = make_server(
'',
WS_PORT,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket))
self.websocket_server.initialize_websockets_manager()
self.websocket_thread = Thread(
target=self.websocket_server.serve_forever)
print('Initializing HTTP server on port %d' % HTTP_PORT)
self.http_server = StreamingHttpServer()
self.http_thread = Thread(target=self.http_server.serve_forever)
print('Initializing broadcast thread')
output = BroadcastOutput(self.camera)
self.broadcast_thread = BroadcastThread(output.converter,
self.websocket_server)
print('Starting recording')
self.camera.start_recording(output, 'yuv')
print('Starting websockets thread')
self.websocket_thread.start()
print('Starting HTTP server thread')
self.http_thread.start()
print('Starting broadcast thread')
self.broadcast_thread.start()
print("Video Stream available...")
while True:
self.camera.wait_recording(1)
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("Initialize video object")
# Initialize the face detection with the camera object
# that is being used by the live streaming thread.
video = Video(camera, cascPath="./cascade.xml")
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()
# Start the video thread.
print("Start video")
video.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()
def includeme(config):
origins = aslist(config.registry.settings.get('origins', ''))
config.registry.websocket = WebSocketWSGIApplication(handler_cls=WebSocket)
config.registry.websocket_origins = origins
config.add_route('ws', 'ws')
config.add_view(websocket, route_name='ws')
config.add_view(bad_handshake, context=HandshakeError)
config.scan(__name__)
def start(ip, port):
server = make_server(ip,
port,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=MyWebsocket))
server.initialize_websockets_manager()
server.serve_forever()
def websocket_view(request):
# Provide environment which the WebSocket handler can use...
request.environ.update({
"h.ws.streamer_work_queue": streamer.WORK_QUEUE,
"h.ws.identity": request.identity,
})
app = WebSocketWSGIApplication(handler_cls=websocket.WebSocket)
return request.get_response(app)
def start_server(port):
global server
server = make_server('',
port,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=WSServer))
server.initialize_websockets_manager()
server.serve_forever()
def __init__(self, host, port):
self.host = host
self.port = port
self.ws = WebSocketWSGIApplication(handler_cls=BroadcastWebSocket)
# keep track of connected websocket clients
# so that we can brodcasts messages sent by one
# to all of them. Aren't we cool?
self.clients = []
def main(weight_path, model_config, class_names, draw):
print("making net...")
net = YoloRunner(weight_path=weight_path,
model_config=model_config,
class_names=["person"])
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, net, draw)
broadcast_thread = BroadcastThread(output.converter, websocket_server)
print('Starting recording')
camera.start_recording(output, 'yuv')
error = None
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 Exception as e:
err = e
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 error is not None:
raise e
def __init__(self,
listen,
request_handler,
msg_handler_pool_size=1024,
indent='indented',
pingpong_trigger=0,
pingpong_timeout=0,
keyfile=None,
certfile=None):
"""
:param listen: string ip:port
:param request_handler: instance of januscloud.proxy.core.request:RequestHandler
:param msg_handler_pool_size:
:param keyfile:
:param certfile:
"""
if msg_handler_pool_size == 0:
msg_handler_pool_size = None
self._msg_handler_pool = Pool(size=msg_handler_pool_size)
self._request_handler = request_handler
self._listen = listen
if keyfile or certfile:
self._server = WSGIServer(
self._listen,
WebSocketWSGIApplication(protocols=['janus-protocol'],
handler_cls=WSServerConn),
log=logging.getLogger('websocket server'),
keyfile=keyfile,
certfile=certfile)
else:
self._server = WSGIServer(
self._listen,
WebSocketWSGIApplication(protocols=['janus-protocol'],
handler_cls=WSServerConn),
log=logging.getLogger('websocket server'),
)
self._server.set_environ({
'app.recv_msg_cbk': self._async_incoming_msg_handler,
'app.closed_cbk': self._request_handler.transport_gone,
'json_indent': indent,
'pingpong_trigger': pingpong_trigger,
'pingpong_timeout': pingpong_timeout
})
def main():
led_flash = flash.Flash()
led_flash.on()
print('Initializing camera')
with picamera.PiCamera() as camera:
camera.resolution = (WIDTH, HEIGHT)
camera.framerate = FRAMERATE
sleep(1) # camera warm-up time
print('Initializing websockets server on port %d' % WS_PORT)
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)
output = BroadcastOutput(camera)
http_server = StreamingHttpServer(camera, output, led_flash)
http_thread = Thread(target=http_server.serve_forever)
print('Initializing broadcast thread')
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)
pass
except KeyboardInterrupt:
pass
finally:
print('Turning off flash')
led_flash.off()
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()
def __init__(self, pi_camera, resolution=(320, 240)):
self.camera = pi_camera
print(
'Viewer:Initializing websockets server server for img on port %d' %
WS_PORT)
WebSocketWSGIHandler.http_version = '1.1'
self.websocket_server = make_server(
'',
WS_PORT,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket))
self.websocket_server.initialize_websockets_manager()
self.websocket_thread = Thread(
target=self.websocket_server.serve_forever)
print(
'Viewer:Initializing websockets server for control data on port %d'
% WS_CONTROLLER_PORT)
self.controller_websocket_server = make_server(
'',
WS_CONTROLLER_PORT,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(
handler_cls=ControllerStreamingWebSocket))
self.controller_websocket_server.initialize_websockets_manager()
self.controller_websocket_thread = Thread(
target=self.controller_websocket_server.serve_forever)
self.controller_broadcast = ControllerBroadcast(
self.controller_websocket_server)
self.controller_broadcast_thread = Thread(
target=self.controller_broadcast.updata)
print('Viewer:Initializing HTTP server on port %d' % HTTP_PORT)
self.http_server = StreamingHttpServer()
self.http_thread = Thread(target=self.http_server.serve_forever)
print('Viewer:Initializing broadcast thread')
self.output = BroadcastOutput(self.camera)
self.broadcast_thread = BroadcastThread(self.output.converter,
self.websocket_server)
def make_ws_server(host="localhost", port=9000):
server = make_server(
host,
port,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=RpcWebSocket))
server.initialize_websockets_manager()
return server
def websocket_view(request):
# Provide environment which the WebSocket handler can use...
request.environ.update({
"h.ws.authenticated_userid": request.authenticated_userid,
"h.ws.effective_principals": request.effective_principals,
"h.ws.streamer_work_queue": streamer.WORK_QUEUE,
})
app = WebSocketWSGIApplication(handler_cls=websocket.WebSocket)
return request.get_response(app)
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)
# Start the threaded server
server = ThreadedHTTPServer("", CONTROL_SERVER_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 broadcast thread')
output = BroadcastOutput(camera, q)
broadcast_thread = BroadcastThread(output.converter, websocket_server,
q)
print('Start recording')
camera.start_recording(output, 'yuv')
try:
print('Starting websockets thread')
websocket_thread.start()
print('Starting broadcast thread')
broadcast_thread.start()
print('Starting file recording thread')
record_thread.start()
print('Starting web server control thread')
server.start()
while True:
camera.wait_recording(1)
except KeyboardInterrupt:
pass
finally:
print('Waiting for websockets thread to finish')
print('Stopping recording')
camera.stop_recording()
print('Waiting for broadcast thread to finish')
broadcast_thread.join()
print('Shutting down websockets server')
websocket_server.shutdown()
print('Waiting for recording to shutdown')
record_thread.kill()
print('Stopping web server control thread')
server.stop()
print('Waiting for websockets server')
websocket_thread.join()
def main():
print('Initializing camera')
with picamera.PiCamera() as camera:
camera.resolution = (WIDTH, HEIGHT)
camera.framerate = FRAMERATE
sleep(1) # camera warm-up time
camera.awb_mode = AWB_MODE
camera.brightness = BRIGHTNESS
camera.exposure_mode = EXPOSURE_MODE
camera.contrast = CONTRAST
camera.saturation = SATURATION
camera.sharpness = SHARPNESS
print('Initializing websockets server on port %d' % WS_PORT)
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')
camera.start_recording('output.h264', splitter_port=2, format='h264')
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(camera.frame.index)
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()
def main():
print('Initializing camera')
with picamera.PiCamera() as camera:
camera.resolution = (WIDTH, HEIGHT)
camera.framerate = FRAMERATE
sleep(1) # camera warm-up time
print('Initializing websockets server on port %d' % WS_PORT)
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')
buffer = picamera.PiCameraCircularIO(camera, seconds=2)
output = BroadcastOutput(websocket_server)
print('Starting recording')
camera.start_recording(output, 'h264', intra_period = 25)
try:
print('Starting websockets thread')
websocket_thread.start()
print('Starting HTTP server thread')
http_thread.start()
while True:
camera.wait_recording(1)
#with buffer.lock:
#for frame in buffer.frames :
#if frame.frame_type == picamera.PiVideoFrameType.sps_header:
#buffer.seek(frame.position)
#break
#output.write(buffer.read())
except KeyboardInterrupt:
pass
finally:
print('Stopping recording')
camera.stop_recording()
print('Waiting for broadcast thread to finish')
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()
def websocket_view(request):
# WebSockets can be opened across origins and send cookies. To prevent
# scripts on other sites from using this socket, ensure that the Origin
# header (if present) matches the request host URL or is whitelisted.
origin = request.headers.get('Origin')
allowed = request.registry.settings['origins']
if origin is not None:
if origin != request.host_url and origin not in allowed:
return httpexceptions.HTTPForbidden()
app = WebSocketWSGIApplication(handler_cls=websocket.WebSocket)
return request.get_response(app)
def main():
print('Initializing camera')
#with picamera.PiCamera() as camera:
with picamera.PiCamera(resolution='{}x{}'.format(WIDTH, HEIGHT),
framerate=FRAMERATE) as camera:
encoder = VideoEncoder(camera)
with ImageAnalyser(camera, encoder) as output:
# 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')
#broadcast_thread = BroadcastThread(output.converter, websocket_server)
broadcast_thread = BroadcastThread(encoder.proc, websocket_server)
print('Starting recording')
camera.start_recording(output, 'bgr')
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()
def main():
logger.info('Initializing camera')
with picamera.PiCamera() as camera:
config = get_config()
w = config.getint('camera', 'width', fallback=640)
h = config.getint('camera', 'height', fallback=480)
camera.resolution = (w, h)
camera.framerate = config.getint('camera', 'framerate', fallback=24)
camera.rotation = config.getint('camera', 'rotation', fallback=0)
camera.hflip = config.getboolean('camera', 'hflip', fallback=False)
camera.vflip = config.getboolean('camera', 'vflip', fallback=False)
camera.led = config.getboolean('camera', 'led', fallback=False)
sleep(1) # camera warm-up tim
logger.info('Initializing websockets server on port %d' % WS_PORT)
websocket_server = make_server(
'',
WS_PORT,
server_class=WSGIServer,
handler_class=HTTP11WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket))
websocket_server.initialize_websockets_manager()
websocket_thread = Thread(target=websocket_server.serve_forever)
#logger.info('Initializing HTTP server on port %d' % HTTP_PORT)
#http_server = StreamingHttpServer()
#http_thread = Thread(target=http_server.serve_forever)
logger.debug('Initializing broadcast thread')
output = BroadcastOutput(camera)
broadcast_thread = BroadcastThread(output.converter, websocket_server)
logger.info('Starting recording')
camera.start_recording(output, 'yuv')
try:
logger.debug('Starting websockets thread')
websocket_thread.start()
#logger.info('Starting HTTP server thread')
#http_thread.start()
logger.debug('Starting broadcast thread')
broadcast_thread.start()
while True:
camera.wait_recording(1)
except KeyboardInterrupt:
pass
finally:
logger.info('Stopping recording')
camera.stop_recording()
logger.debug('Waiting for broadcast thread to finish')
broadcast_thread.join()
logger.debug('Shutting down HTTP server')
#http_server.shutdown()
logger.debug('Shutting down websockets server')
websocket_server.shutdown()
logger.debug('Waiting for HTTP server thread to finish')
#http_thread.join()
logger.debug('Waiting for websockets thread to finish')
websocket_thread.join()
def start(self):
if self.server:
return
self.server = make_server(
self.host,
3000,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=BrowserReloadProtocol))
self.server.initialize_websockets_manager()
self.server_thread = Thread(target=self.server.serve_forever)
self.server_thread.start()
def start_websockets(self):
print('Initializing websocket...')
WebSocketWSGIHandler.http_version = '1.1'
self.websocket_server = make_server(
'',
WS_PORT,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=StreamingWebSocket))
self.websocket_server.initialize_websockets_manager()
self.websocket_thread = Thread(
target=self.websocket_server.serve_forever)
def run(self):
from . import server
self.server = make_server(
'',
9222,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(handler_cls=server.DebuggerWebSocket))
sys.stderr.write(
'Navigate to chrome://devtools/devtools.html?ws=0.0.0.0:9222\n')
self.server.initialize_websockets_manager()
self.server.serve_forever()
def main():
print('Setting up GPIO ' + str(GPIO_PIN) + ' IR LED')
GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIO_PIN, GPIO.OUT)
print('Initializing camera')
with picamera.PiCamera() as camera:
camera.resolution = (WIDTH, HEIGHT)
camera.framerate = FRAMERATE
camera.led = False
sleep(1) # camera warm-up time
print('Initializing websockets server on port %d' % WS_PORT)
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(camera)
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()
def __init__(self, debugger_store, port):
class ConcreteDebuggerWebSocket(DebuggerWebSocket):
@staticmethod
def debugger_store():
return debugger_store
self.debug_server = make_server(
'localhost',
port,
server_class=WSGIServer,
handler_class=WebSocketWSGIRequestHandler,
app=WebSocketWSGIApplication(
handler_cls=ConcreteDebuggerWebSocket))
self.debug_server.initialize_websockets_manager()
def __init__(self, app):
self.app = app
WebSocketWSGIApplication.__init__(self)
def __call__(self, environ, start_response):
if 'ws4py.socket' in environ:
WebSocketWSGIApplication.__call__(self, environ, start_response)
response = self.app(environ, start_response)
return response
def make_websocket(self, sock, protocols, extensions, environ):
connection = WebSocketWSGIApplication.make_websocket(self, sock, protocols, extensions, environ)
connection.conn_id = sock.fileno()
pad_server.new_connection(connection)
return connection
