#!/usr/bin/env python2

import serial
import sys
import time
import threading
import gobject
import gtk

class SerialReader(threading.Thread):
    def __init__(self, path, callback):
        super(SerialReader, self).__init__()

        self._stop = threading.Event()
        self._path = path;
        self._cb = callback

    def run(self):
        uart = serial.Serial(self._path, 115200, timeout=1)
        uart.write(chr(0x81))

        try:
            data = ""
            while not self._stop.isSet():
                data += uart.read(1)
            
                if len(data) == 3:
                    n = ord(data[0])
                    val = (ord(data[1]) << 8) + ord(data[2])
                    self._cb(n, val)

                    data = ""
        finally:
            uart.write(chr(0x82))
            uart.close()

    def stop(self):
        self._stop.set()

class Monitor():
    def __init__(self):
        self.win = gtk.Window()
        self.win.set_title("Serial monitor")
        self.win.connect("destroy", lambda _: gtk.main_quit())

        self.vbox = gtk.VBox()
        self.win.add(self.vbox)

        #self.lbl = gtk.Label()
        #self.lbl.set_text("Hi there")
        #self.win.add(self.lbl)
        
        self.adjust = gtk.Adjustment(value=0.1, lower=0.01, upper=2,
            step_incr=0.01)

        self.spin = gtk.SpinButton(self.adjust, digits=2)
        self.vbox.pack_start(self.spin)

        self.zeroadjust = gtk.Adjustment(value=0, lower=0, upper=65536,
            step_incr=100)

        self.zerospin = gtk.SpinButton(self.zeroadjust, digits=0)
        self.vbox.pack_start(self.zerospin)

        self.area = gtk.DrawingArea()
        self.area.set_size_request(640, 480)
        self.area.connect("expose_event", self.draw)
        self.vbox.pack_start(self.area)
        
        self.win.show_all()

        def color(s):
            return gtk.gdk.color_parse(s)

        self.colors = {
            "bg": color("#000"),
            "grid": color("#CCC"),
            "val": [
                color("#F00"),
                color("#0F0"),
                color("#00F"),
                color("#FF0")
            ]
        }

        self.vals = [0] * 4
        self.history = []

        self.reader = SerialReader(sys.argv[1], self.recv)
        self.reader.start()

    def recv(self, n, val):
        self.vals[n] = val;

        if n == 3:
            self.history.append(self.vals)
            if len(self.history) > 640:
                del self.history[0]

            self.vals = [0] * 4

            self.area.queue_draw()

    def draw(self, a, b):
        s = self.area.get_allocation()

        w = self.area.window
        gc = w.new_gc()
        
        gc.set_rgb_fg_color(self.colors["bg"])
        w.draw_rectangle(gc, True, 0, 0, s.width, s.height)

        h = self.history

        gc.set_rgb_fg_color(self.colors["grid"])
        w.draw_line(gc, s.width/2, 0, s.width/2, s.height)
        w.draw_line(gc, 0, s.height/2, s.width, s.height/2)

        factor = self.adjust.get_value()
        zero = int(self.zeroadjust.get_value())

        gc.line_width = 2
        for x in range(1, len(h)):
            for v in range(0, 4):
                gc.set_rgb_fg_color(self.colors["val"][v])
                w.draw_line(gc,
                    x*2 - 2, int(s.height - h[x - 1][v] * factor) + zero,
                    x*2, int(s.height - h[x][v] * factor) + zero)

gobject.threads_init()

mon = Monitor()

try:
    gtk.main()
finally:
    mon.reader.stop()