import sys
import asyncio
import websockets
import time
import serial
import threading

stopFlag = False

class SerialWorker(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.data = None
        self.ser = serial.Serial(sys.argv[1], 9600)
        self.ser.setDTR()
        self.ser.flush()

    def run(self):
        while not stopFlag:
            self.data = self.read_pin()

    def read_pin(self):
        byte2 = 0
        byte3 = 0
        byte4 = 0
        while 1:
            byte1 = byte2
            byte2 = byte3
            byte3 = byte4
            byte4 = ord(self.ser.read())
            if ((byte1 == 1) & (byte2 == 2) & (byte3 == 3) & (byte4 == 4)):
                break
        data = []
        for i in range(0, 8):
            up_low = ord(self.ser.read())
            up_high = ord(self.ser.read())
            down_low = ord(self.ser.read())
            down_high = ord(self.ser.read())
            up_val = 256*up_high + up_low
            down_val = 256*down_high + down_low
            val = (up_val + (1023 - down_val)) / 2
            data.append(val)
        return data

    def get(self):
        return self.data


class WSWorker(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.connected = set()

    def run(self):
        while not stopFlag:
            data = serial_worker.get()
            self.sendData(data)
            time.sleep(.1)

    async def handler(self, websocket, path):
        self.connected.add(websocket)
        try:
            await websocket.recv()
        except websockets.exceptions.ConnectionClosed:
            pass
        finally:
            self.connected.remove(websocket)

    def sendData(self, data):
        for websocket in self.connected.copy():
            out = ",".join(map(str, data))
            coro = websocket.send(out)
            future = asyncio.run_coroutine_threadsafe(coro, loop)

if __name__=='__main__':
    serial_worker = SerialWorker()
    ws_worker = WSWorker()
    try:
        serial_worker.start()
        ws_worker.start()
        start_server = websockets.serve(ws_worker.handler, '127.0.0.1', 8765)
        loop = asyncio.get_event_loop()
        loop.run_until_complete(start_server)
        loop.run_forever()
    except KeyboardInterrupt:
        stopFlag = True