app_flask.py

#!/usr/bin/env python
from __future__ import division
import os
import sys
import signal
import threading
import time
import json
from flask import Flask, request, Response

import config as cfg

import camera_pi as cam
#import camera_cv as cam

import io_wrapper as hw
#import io_wrapper_dummy as hw

import logging
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)

app = Flask(__name__, static_url_path='/static')

# Immobilizes sytem (chocks on) after 'timeout' seconds 
def watchdog_timer():
    while cfg.watchdog_active:
        time.sleep(1)
        if cfg.watchdog_running:
            cfg.watchdog += 1
            if cfg.watchdog > cfg.timeout and not cfg.chocks:
                chocks_on()
            if cfg.watchdog <= cfg.timeout and cfg.chocks:
                chocks_off()

# Handler for a clean shutdown when pressing Ctrl-C
def signal_handler(signal, frame):
    hw.light_blue_blink(0.1)
    cfg.watchdog_active = False
    cfg.camera_active = False
    brakes_on()
    wd.join()
    hw.light_blue_off()
    sys.exit(0)

# Handler for explorer-hat touchpads
def touch_handler(channel, event):
    if channel == 1:
        cfg.blue = not cfg.blue
        if cfg.blue:
            hw.light_blue_on()
            hw.output_one_on()
        else:
            hw.light_blue_off()
            hw.output_one_off()
    if channel == 2:
        cfg.yellow = not cfg.yellow
        if cfg.yellow:
            hw.light_yellow_on()
            hw.output_two_on()
        else:
            hw.light_yellow_off()
            hw.output_two_off()
    if channel == 3:
        cfg.chocks = not cfg.chocks
        if cfg.chocks:
            cfg.watchdog_running = False
            chocks_on()
        else:
            cfg.watchdog_running = True
            chocks_off()
    if channel == 4:
        hw.light_green_blink(0.1)
        cfg.green = True
        time.sleep(5)
        if cfg.chocks:
            hw.light_green_on()
            os.system("sudo -s shutdown -h now")
        else:
            hw.light_green_off()
            cfg.green = False
    
def brakes_on():
    cfg.brakes = True
    cfg.left_motor = 0
    cfg.right_motor = 0
    hw.motor_one_speed(cfg.right_motor)
    hw.motor_two_speed(cfg.left_motor)
    
def brakes_off():
    cfg.brakes = False
    cfg.watchdog = 0
    
def chocks_on():
    cfg.chocks = True
    brakes_on()
    hw.light_red_blink(0.2)
    
def chocks_off():
    cfg.chocks = False
    brakes_off()
    hw.light_red_off()


# Base URL / - loads web interface        
@app.route('/')
def index():
    cfg.video_fps = 0
    video = request.args.get('video')
    if video == 'n':
        cfg.video_status = False
    else:
        if video == None:
            cfg.video_status = cfg.camera_detected
        elif float(video) > 0:
            cfg.video_fps = float(video)
            cfg.video_status = cfg.camera_detected
    return app.send_static_file('index.html')

def gen(camera):
    """Video streaming generator function."""
    if cfg.video_status:
        while True:
            frame = camera.get_frame()
            yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')

# URL to remote control touchpads 1-4 on explorer-hat
@app.route('/touchpad')
def touchpad():
    pad = request.args.get('pad')
    if pad:
        touch_handler(int(pad), True)
    return 'ok'

# URL for heartbeat requests (resets watchdog timer)    
# Returns JSON object with status data
@app.route('/heartbeat')
def heartbeat():
    cfg.watchdog = 0
    output = {}
    output['b'] = cfg.blue
    output['y'] = cfg.yellow
    output['c'] = cfg.chocks
    output['g'] = cfg.green
    output['f'] = cfg.video_fps
    output['v'] = cfg.video_status
    output['l'] = cfg.left_motor
    output['r'] = cfg.right_motor
    output['i1'] = hw.input_one_read()
    output['i2'] = hw.input_two_read()
    output['i3'] = hw.input_three_read()
    output['i4'] = hw.input_four_read()
    output['a1'] = hw.analog_one_read()
    output['a2'] = hw.analog_two_read()
    output['a3'] = hw.analog_three_read()
    output['a4'] = hw.analog_four_read()
    return json.dumps(output)

# URL for motor control - format: /motor?l=[speed]&r=[speed]
@app.route('/motor')
def motor():
    left = request.args.get('l')
    right = request.args.get('r')
    if left and not cfg.chocks:
        left = int(left)
        if left >= -100 and left <= 100:
            cfg.left_motor = left
            hw.motor_two_speed(cfg.left_motor)
    if right and not cfg.chocks:
        right = int(right)
        if right >= -100 and right <= 100:
            cfg.right_motor = right
            hw.motor_one_speed(cfg.right_motor)
    return 'ok'

# URL for joystick input - format: /joystick?x=[x-axis]&y=[y-axis]
@app.route('/joystick')
def joystick():
    cfg.watchdog = 0
    x_axis = int(request.args.get('x'))
    y_axis = int(request.args.get('y'))
    x_axis = -1 * max( min(x_axis, 100), -100)
    y_axis = max( min(y_axis, 100), -100)
    v = (100-abs(x_axis)) * (y_axis/100) + y_axis
    w = (100-abs(y_axis)) * (x_axis/100) + x_axis
    r = int((v+w) / 2)
    l = int((v-w) / 2)
    if not cfg.chocks:
        cfg.right_motor = r
        cfg.left_motor = l
        hw.motor_one_speed(cfg.right_motor)
        hw.motor_two_speed(cfg.left_motor)
    return 'ok'

# URL for video stream feed
@app.route('/video_feed.mjpg')
def video_feed():
    if cfg.camera_detected:
        """Video streaming route. Put this in the src attribute of an img tag."""
        return Response(gen(cam.Camera()), mimetype='multipart/x-mixed-replace; boundary=frame')
    else:
        return 'no video'
        
# URL for single frame feed
@app.route('/single_frame.jpg')
def single_frame():
    if cfg.camera_detected:
        jpeg =  cam.single_frame()
        return Response(jpeg, mimetype='image/jpeg; boundary=frame')
    else:
        return 'no video'

if __name__ == '__main__':
    hw.light_green_blink(0.1)
    time.sleep(1)
    hw.light_green_off()
    cfg.camera_detected, cfg.camera = cam.init_camera()
    
    # register signal handler for a clean exit    
    signal.signal(signal.SIGINT, signal_handler)

    # register handler for touchpads
    if hw.explorerhat:
        hw.xhat.touch.released(touch_handler)
        
    # prepare and start watchdog
    wd = threading.Thread(name='watchdog_timer', target=watchdog_timer)
    wd.start()
    
    app.run(host='0.0.0.0', debug=False, threaded=True)