totalsync-webinterface 0.1.1__py3-none-any.whl

totalsync_webinterface/serial_dummy.py

@@ -0,0 +1,92 @@
+import logging
+import math
+import struct
+import threading
+import time
+
+import serial
+from cobs import cobs
+
+from .packet import DataPacketStruct
+
+
+# uint8_t type;          // 1 B, packet type
+# uint8_t size;          // 1 B, packet size
+# uint16_t crc16;        // 2 B, CRC16
+# unsigned long packetID;// 4 B, running packet count
+
+# unsigned long ts_start;// 4 B, gather start timestamp
+# unsigned long ts_end;  // 4 B, transmit timestamp
+# uint16_t analog[8];    // 16 B, ADC values
+# int16_t states[8];     // 16 B, state variables (encoder, speed, etc)
+
+# uint16_t digitalIn;    // 2 B, digital inputs
+# uint8_t digitalOut;    // 1 B, digital outputs
+# uint8_t padding[0];    // 1 B, align to 4B
+
+class SerialDummy(threading.Thread):
+    def __init__(self):
+        super(SerialDummy, self).__init__()
+        self.ser = serial.serial_for_url('loop://')
+        self.daemon = True
+        self.n_packet = 0
+        self.interval = 1
+
+        self.start()
+
+    def run(self):
+        logging.info('SerialDummy starting')
+        while self.is_alive() and self.ser.is_open:
+            self.emit()
+            time.sleep(self.interval / 1000)
+        self.ser.close()
+
+    def emit(self):
+        for n in range(10):
+            rp = self.random_packet()
+            if rp:
+                self.ser.write(rp)
+                self.n_packet += 1
+
+    def random_packet(self):
+        packet_type = 0
+        packet_size = struct.calcsize(DataPacketStruct)
+        packet_crc = 777
+        packet_id = self.n_packet
+
+        packet_us_start = self.n_packet * self.interval * 1000 % (2 ** 32 - 1)
+        packet_us_end = self.n_packet * self.interval * 1000 % (2 ** 32 - 1)
+        packet_analog = self.analog()
+        packet_states = self.states()
+
+        packet_digitalIn = int(self.n_packet / 10 % 2 ** 16)
+        packet_digitalOut = int(self.n_packet / 10 % 2 ** 8)
+
+        packet = []
+        packet.extend([packet_type, packet_size, packet_crc, packet_id,
+                       packet_us_start, packet_us_end, *packet_analog, *packet_states,
+                       packet_digitalIn, packet_digitalOut])
+
+        try:
+            ps = struct.pack(DataPacketStruct, *packet)
+        except struct.error as e:
+            logging.error(e)
+            print(packet)
+            return
+
+        enc = cobs.encode(ps)
+        return enc + b'\0'
+
+    def analog(self):
+        arr = []
+        for n in range(8):
+            val = int((math.sin((self.n_packet + n) / (2 ** (n + 1))) + 1) * (2 ** (n + 8) - 1))
+            arr.append(val)
+        return arr
+
+    def states(self):
+        arr = []
+        for n in range(8):
+            val = int((math.sin((self.n_packet + n + 500) / (2 ** (n + 1)))) * (2 ** (n + 8) - 1))
+            arr.append(val)
+        return arr

totalsync_webinterface/serial_dump.py

@@ -0,0 +1,66 @@
+import base64
+from pathlib import Path
+from datetime import datetime
+import logging
+from tkinter import filedialog
+
+
+def browse_button():
+    # Allow the user to select a directory to write the dump files into.
+    filename = filedialog.askdirectory()
+    if filename == "":
+        filename = "DataFile/"
+
+    return filename
+
+
+class SerialDump:
+    def __init__(self):
+
+        self.f_b64 = Path(browse_button() + '/' + datetime.now().strftime("%Y%m%d-%H%M%S_%f")[:-3] + '.b64')
+        self.f_bin = self.f_b64.with_suffix('.bin')
+
+        self.cobs_file = None
+        self.bin_file = None
+
+        # Counts every framed packet that came off the serial line, including those
+        # that later fail to COBS-decode or unpack: handle_raw runs before any of
+        # that happens (see Packet.PacketReceiver.handle_packet). Comparing it with
+        # TeensyCommander.n_packet, which only counts fully unpacked data packets,
+        # is what makes a flaky connection visible.
+        self.n_raw_packets = 0
+
+    def handle_raw(self, arr):
+        """Write the cobs-encoded, 0-terminated data as base64 encoded string to log file,
+        one line per packet.
+
+        To allow re-parsing of the array with a cobs-decoder, we re-add the 0 terminator that was
+        removed by the serial packetizer. (This is completely unnecessary and here for backwards
+        compatibility).
+        """
+        # Count the arrival, not the successful write, so a full disk or a closed
+        # file does not hide the fact that the packet did come in. Only the serial
+        # ReaderThread ever increments this, so a plain += needs no lock.
+        self.n_raw_packets += 1
+
+        # For future parsing, we need to re-append the line termination symbol \0.
+        if self.cobs_file is None:
+            logging.info(f"Opening COBS+Base64 serial dump file {self.f_b64.absolute()}")
+            self.cobs_file = open(self.f_b64, 'w+b')
+        self.cobs_file.write(base64.b64encode(arr + b'\0') + b'\n')
+
+    def handle_array(self, arr):
+        """Write the cobs-decoded byte-array packet into a .bin file.
+
+        This allows use of a mmap to interpret the file without having to decode again."""
+        if self.bin_file is None:
+            logging.info(f"Opening binary serial dump file {self.f_bin.absolute()}")
+            self.bin_file = open(self.f_bin, 'w+b')
+        self.bin_file.write(arr)
+
+    def __del__(self):
+        # Either file is still None if no packet of that kind ever arrived, which is
+        # the normal case for .bin unless -B was given.
+        for handle in (self.cobs_file, self.bin_file):
+            if handle is not None:
+                handle.close()

totalsync_webinterface/teensy_commander.py

@@ -0,0 +1,490 @@
+import argparse
+import logging
+import sys
+import threading
+import time
+import tkinter as tk
+import webbrowser
+from tkinter import messagebox as mb
+
+import serial
+import serial.threaded
+import serial.tools.list_ports
+import zmq
+
+try:
+    import curses
+except ImportError:
+    curses = None
+
+from .packet import PacketReceiver, pack_command_packet, pack_reset_packet
+from .pin_sheet import load_pin_labels
+from .serial_dump import SerialDump
+from .serial_dummy import SerialDummy
+from .web_interface import WebInterface, WS_PORT, HTTP_PORT
+from .curses_interface import CursesUI
+
+ZMQ_SERVER_PUB_PORT = 5680
+ZMQ_SERVER_SUB_PORT = 5681
+
+# The web interface is served by our own HTTP server, see WebInterface.WEB_DIRECTORY.
+WEB_URL = f'http://localhost:{HTTP_PORT}/index.html'
+
+
+def open_web_interface():
+    """Open the interface in a browser.
+
+    The nonce makes the URL one the browser has never seen, so the request has to
+    reach the server rather than being answered from cache. Without it, an
+    index.html cached before this port started serving redirects would be reused,
+    and the redirect that points at the current assets never seen.
+    """
+    webbrowser.open_new(f'{WEB_URL}?t={time.time_ns():x}')
+
+
+# Fallback when neither --serial_port nor the startup dialog supplies a port. There is
+# no useful cross-platform default: on POSIX the devices are /dev/cu.* or /dev/ttyUSB*
+# and differ per machine, so fall back to an empty string and let the SerialException
+# handler in TeensyCommander report it (or use -D to switch to the dummy).
+DEFAULT_SERIAL_PORT = 'COM9' if sys.platform == 'win32' else ''
+
+_root = None
+
+
+def get_root():
+    """Return the process-wide hidden Tk root, creating it on first use.
+
+    Tk supports exactly one root per process. Additional tk.Tk() instances are
+    separate Tcl interpreters that cannot share variables or `after` callbacks,
+    and destroying one on macOS leaves a dangling Aqua idle handler that
+    segfaults the next event loop. Every window below is a Toplevel of this root.
+    """
+    global _root
+    if _root is None:
+        _root = tk.Tk()
+        _root.withdraw()
+    return _root
+
+
+def destroy_root():
+    """Tear down the Tk root so the process can exit without a stuck NSApplication."""
+    global _root
+    if _root is None:
+        return
+    try:
+        # update() first: it drains the idle queue. On macOS a Tk idle handler
+        # left unserviced across a destroy() segfaults the next event loop.
+        _root.update()
+        _root.destroy()
+    except tk.TclError:
+        pass
+    _root = None
+
+
+# sys.exit() must never be called from inside a Tk callback: the SystemExit it
+# raises is discarded by `tkwait` (unlike mainloop(), Tkapp_Call does not restore
+# the pending exception), so the caller silently carries on. The dialogs below
+# therefore report "the user asked to quit" through their return value instead.
+QUIT = object()
+
+
+def choose_serial_port(parent):
+    """Modal dialog to pick a serial port. Returns the device, or '' if cancelled."""
+    ports = sorted(comport.device for comport in serial.tools.list_ports.comports())
+    if not ports:
+        mb.showwarning('No serial ports', 'No serial ports were found on this machine.',
+                       parent=parent)
+        return ''
+
+    win = tk.Toplevel(parent)
+    win.title('Select the serial port you want to use')
+    win.geometry('500x40')
+    win.transient(parent)
+
+    selected = tk.StringVar(win)
+    chosen = []
+
+    def choice(value):
+        chosen.append(value)
+        win.destroy()
+
+    tk.OptionMenu(win, selected, *ports, command=choice).pack()
+    win.grab_set()
+    win.wait_window()
+    return chosen[0] if chosen else ''
+
+
+def welcome_dialog():
+    """Show the startup window.
+
+    Returns the serial port the user picked ('' if none), or QUIT if the user
+    asked to quit.
+    """
+    win = tk.Toplevel(get_root())
+    win.title('Totalsync')
+    win.geometry('400x150')
+    port = tk.StringVar(win)
+    quitting = []
+
+    def on_play():
+        # The HTTP server is not running yet; the 'Reload' button on the next
+        # window exists to retry once it is.
+        open_web_interface()
+        win.destroy()
+
+    def on_quit():
+        if mb.askyesno('Verify', 'Really quit?', parent=win):
+            quitting.append(True)
+            win.destroy()
+            return
+        mb.showinfo('No', 'Quit has been cancelled', parent=win)
+
+    def on_close():
+        if mb.askokcancel('Quit', 'Do you want to quit?', parent=win):
+            quitting.append(True)
+            win.destroy()
+
+    def on_choose():
+        device = choose_serial_port(win)
+        if device:
+            port.set(device)
+            logging.info(f'Selected serial port: {device}')
+
+    win.protocol('WM_DELETE_WINDOW', on_close)
+    tk.Label(win, text='Welcome to TotalSync').pack()
+    tk.Button(win, text='Quit', command=on_quit).pack()
+    tk.Button(win, text='Play', command=on_play).pack()
+    tk.Button(win, text='choose COM', command=on_choose).pack()
+
+    win.wait_window()
+    return QUIT if quitting else port.get()
+
+
+class TeensyCommander:
+    def __init__(self, serial_port, http_port, ws_port, curses_screen, write_bin=False, use_dummy=False,
+                 channel_labels=None):
+        self.n_packet = 0
+        self.packets_per_second = 0
+        self.packet_timings = []
+        # Set up front so shutdown()/__del__ stay safe if __init__ bails out early.
+        self.serial = None
+        self.serial_reader = None
+        self.reader_thread = None
+        self.dummy = None
+        self.zmq_ctx = zmq.Context()
+        self.zmq_pub = self.zmq_ctx.socket(zmq.PUB)
+        self.zmq_pub.bind(f'tcp://*:{ZMQ_SERVER_PUB_PORT}')
+
+        self.zmq_sub = self.zmq_ctx.socket(zmq.SUB)
+        self.zmq_sub.setsockopt_string(zmq.SUBSCRIBE, "")
+        self.zmq_sub.bind(f'tcp://*:{ZMQ_SERVER_SUB_PORT}')
+
+        self.alive = True
+        self.shell_gui = CursesUI(self, curses_screen) if curses_screen is not None else None
+        time.sleep(0.05)  # give some time to let log display catch all startup messages
+
+        self.serial_dump = SerialDump()
+        self.serial_port = serial_port
+        self.web_server = WebInterface(http_port, ws_port, self, channel_labels=channel_labels)
+
+        try:
+            self.serial = serial.Serial(self.serial_port)
+            self.serial.flushInput()
+        except serial.SerialException as e:
+            logging.error("Can't find serial device: {}".format(e))
+            if use_dummy:
+                logging.warning('Using serial dummy')
+                self.dummy = SerialDummy()
+                self.serial = self.dummy.ser
+                self.serial_port = 'DUMMY'
+            else:
+                self.shutdown()
+                raise SystemExit(1)
+
+        # __enter__() returns the PacketReceiver protocol, not the thread, so keep a
+        # reference to the thread as well; shutdown() needs it to stop reading.
+        self.reader_thread = serial.threaded.ReaderThread(self.serial, PacketReceiver)
+        self.serial_reader = self.reader_thread.__enter__()
+
+        # raw data consumers
+        self.serial_reader.raw_callbacks.append(self.serial_dump.handle_raw)
+
+        # decoded data consumers
+        if write_bin:
+            self.serial_reader.raw_callbacks.append(self.serial_dump.handle_array)
+        # unpacked data consumers
+        self.serial_reader.packet_callbacks.append(self.handle_packet)
+        self.serial_reader.packet_callbacks.append(self.web_server.handle_packet)
+        if self.shell_gui:
+            self.serial_reader.packet_callbacks.append(self.shell_gui.handle_packet)
+
+        self.zmq_subscriber = threading.Thread(target=self.subscriber, daemon=True)
+
+    def run_forever(self):
+        """Run the session, returning once the user closes the control window.
+
+        Tk's event loop *is* the main loop: every worker (serial reader, HTTP and
+        WebSocket servers, ZMQ subscriber) is a daemon thread, so the main thread
+        only has to keep Tk responsive. It used to `time.sleep(1)` in a loop here
+        instead, which left the macOS event queue unattended and made the OS
+        report the process as "application not responding".
+        """
+        self.zmq_subscriber.start()
+        menu(self)
+
+    def handle_packet(self, packet):
+        self.n_packet += 1
+        self.zmq_pub.send_pyobj(packet)
+
+        # calculate packet rate
+        t_now = time.time_ns() * 0.000000001
+        self.packet_timings.append(t_now)
+        t_delta = t_now - (self.packet_timings[0] if len(self.packet_timings) < 1000 else self.packet_timings.pop(0))
+        try:
+            self.packets_per_second = len(self.packet_timings) / t_delta
+        except ZeroDivisionError:
+            self.packets_per_second = 0
+
+    def subscriber(self):
+        while True:
+            try:
+                msg = self.zmq_sub.recv_pyobj()
+            except zmq.ZMQBaseError as e:
+                if e.errno == zmq.ETERM:
+                    break
+                else:
+                    raise
+            if msg:
+                self.send(msg)
+
+    def send(self, msg):
+        if msg is not None:
+            logging.debug('Send message: ' + str(msg))
+            self.pack_packet(msg)
+        else:
+            logging.error('Asked to send "None" message, skipping.')
+
+    def pack_packet(self, instruction):
+        logging.debug(f'Packing instruction: {instruction}')
+        try:
+            packed = pack_command_packet(instruction)
+            if packed is None:
+                logging.error('Failed to pack!')
+                return
+            self.send_packet(packed)
+        except ValueError:
+            logging.debug('Unknown type!')
+
+    def reset_packet(self):
+        logging.debug('Reset')
+        try:
+            reset = pack_reset_packet()
+            SerialDump()
+            if reset is None:
+                logging.error('Failed to pack!')
+                return
+            self.send_packet(reset)
+        except ValueError:
+            logging.debug('Unknown type!')
+
+    def send_packet(self, packet):
+        logging.debug('Serial write: ' + str(packet))
+        try:
+            self.serial.write(packet)
+        except (ValueError, serial.SerialException) as e:
+            logging.error(f'Serial write failed: {e}')
+
+    def shutdown(self):
+        """Release the serial port and the ZMQ resources. Safe to call twice."""
+        self.alive = False
+
+        if self.reader_thread is not None:
+            logging.debug('Stopping serial reader.')
+            # Stops the reader thread and closes the port, which also ends the
+            # SerialDummy loop (it writes to this very port).
+            self.reader_thread.close()
+            self.reader_thread = None
+            self.serial_reader = None
+        elif self.serial is not None and self.serial.is_open:
+            self.serial.close()
+
+        if self.zmq_ctx is not None:
+            logging.debug('Terminating ZMQ context.')
+            # linger=0 drops whatever is still queued. With the default LINGER of
+            # -1, term() waits forever for a subscriber that may never connect.
+            # term() also makes the subscriber thread's recv_pyobj() raise ETERM,
+            # which is how that thread breaks out of its loop.
+            self.zmq_ctx.destroy(linger=0)
+            self.zmq_ctx = None
+
+    def __del__(self):
+        logging.debug('Making sure serial port is closed on exit.')
+        if self.serial is not None and self.serial.is_open:
+            self.serial.close()
+
+
+def main(screen, cli_args, channel_labels=None):
+    # SerialDump() opens a tkinter directory chooser, so a root must already exist.
+    get_root()
+    logging.info(
+        "Known serial ports: " + repr(sorted([comport.device for comport in serial.tools.list_ports.comports()])))
+    logging.info(
+        f"Launching Teensy Commander on serial port {cli_args.serial_port} and the web interface "
+        f"on ports HTTP:{cli_args.http_port} and WS:{cli_args.ws_port}")
+    tc = TeensyCommander(serial_port=cli_args.serial_port,
+                         http_port=cli_args.http_port,
+                         ws_port=cli_args.ws_port,
+                         curses_screen=screen,
+                         write_bin=cli_args.binfile,
+                         use_dummy=cli_args.dummy,
+                         channel_labels=channel_labels)
+    try:
+        tc.run_forever()
+    except KeyboardInterrupt:
+        logging.info('Interrupted, shutting down.')
+    finally:
+        # Both must happen on the way out: a live ZMQ context or Tk root keeps the
+        # process up long enough for macOS to call it unresponsive.
+        tc.shutdown()
+        destroy_root()
+
+
+def cli_entry():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-s', '--serial_port', default=None,
+                        help='Serial port of the Teensy. If omitted, a startup dialog asks for one.')
+    parser.add_argument('-w', '--ws_port', default=WS_PORT)
+    parser.add_argument('-H', '--http_port', default=HTTP_PORT)
+    parser.add_argument('-B', '--binfile', action='store_true', help='Write decoded binary serial dump file')
+    parser.add_argument('-C', '--curses', action='store_true', help='Use cursesUI in terminal')
+    parser.add_argument('-D', '--dummy', action='store_true',
+                        help='Use serial dummy if no valid serial device available')
+    parser.add_argument('-v', '--verbose', action='count', default=2, help="Increase logging verbosity")
+    parser.add_argument('--pinsheet', default=None, metavar='PATH',
+                        help='pinSheet.json describing what each pin is wired to. Channels with '
+                             'a "for" entry are labelled with it in the web interface; the rest '
+                             'keep their default names.')
+
+    cli_args = parser.parse_args()
+
+    try:
+        loglevel = {
+            0: logging.ERROR,
+            1: logging.WARN,
+            2: logging.INFO,
+        }[cli_args.verbose]
+    except KeyError:
+        loglevel = logging.DEBUG
+
+    log_format = '[%(asctime)s]{%(filename)s:%(lineno)d} %(levelname)s - %(message)s'
+    logging.basicConfig(level=loglevel,
+                        format=log_format,
+                        datefmt='%H:%M:%S')
+
+    console = logging.StreamHandler()
+    console.setLevel(loglevel)
+    console.setFormatter(logging.Formatter(log_format))
+
+    # start_time_str = datetime.now().strftime("%Y%m%d-%H%M%S")
+    # log_file = logging.FileHandler('../totalsync/LogFile/' + f'{start_time_str}_teensy_commander.log', mode='w')
+    # log_file.setLevel(logging.DEBUG)
+    # log_file.setFormatter(logging.Formatter(log_format))
+
+    logging.getLogger().handlers.clear()
+    logging.getLogger().addHandler(console)
+    # logging.getLogger().addHandler(log_file)
+    logging.getLogger().setLevel(loglevel)
+
+    # Read the pin sheet before anything opens: a bad path should fail here, not
+    # after the serial port and the servers are already up.
+    channel_labels = load_pin_labels(cli_args.pinsheet) if cli_args.pinsheet else {}
+
+    # Only ask interactively when no port was given on the command line, so that
+    # --help and scripted runs never open a window.
+    if cli_args.serial_port is None:
+        port = welcome_dialog()
+        if port is QUIT:
+            logging.info('Quit requested in the startup dialog.')
+            destroy_root()
+            return
+        cli_args.serial_port = port or DEFAULT_SERIAL_PORT
+
+    if cli_args.curses and curses is not None:
+        curses.wrapper(main, cli_args, channel_labels)
+    else:
+        main(None, cli_args, channel_labels)
+
+
+def menu(commander):
+    """Run the control window for a running commander. Returns when it is closed.
+
+    This window stays up for the whole session, so its event loop is what keeps
+    the process responsive; see TeensyCommander.run_forever.
+    """
+    win = tk.Toplevel(get_root())
+    win.title('Totalsync')
+
+    def quit_app():
+        # Never sys.exit() here, see the comment on QUIT: clearing `alive` and
+        # closing the window is what actually ends the session.
+        commander.alive = False
+        win.destroy()
+
+    def on_quit():
+        if mb.askyesno('Verify', 'Really quit?', parent=win):
+            quit_app()
+            return
+        mb.showinfo('No', 'Quit has been cancelled', parent=win)
+
+    def on_reset():
+        commander.reset_packet()
+        open_web_interface()
+
+    def on_reload():
+        open_web_interface()
+
+    def on_close():
+        if mb.askokcancel('Quit', 'Do you want to quit?', parent=win):
+            quit_app()
+
+    # Raw packet count at the previous tick, so the delta can be reported.
+    last_count = [0]
+
+    def report_packet_count():
+        """Log the received-packet counters, once per watchdog tick."""
+        received = commander.serial_dump.n_raw_packets
+        new = received - last_count[0]
+        last_count[0] = received
+        msg = (f'Serial packets: {received} received (+{new}), '
+               f'{commander.n_packet} decoded, {commander.packets_per_second:.1f}/s')
+        if new:
+            logging.info(msg)
+        else:
+            # A silent port is the failure this counter exists to make visible, so
+            # say so at a level that survives the default verbosity.
+            logging.warning(msg + ' - nothing received since the last check!')
+
+    def watchdog():
+        """Periodic health check, rescheduled on the Tk event loop."""
+        if not commander.alive:
+            quit_app()
+            return
+        report_packet_count()
+        if commander.shell_gui and commander.shell_gui.alive and not commander.shell_gui.is_alive():
+            logging.critical("Shell GUI died!")
+            # TODO: attempt to restart the shell GUI
+        win.after(1000, watchdog)
+
+    win.protocol('WM_DELETE_WINDOW', on_close)
+    tk.Label(win, text='TotalSync is now in use').pack()
+    tk.Button(win, text='Quit', command=on_quit).pack()
+    tk.Button(win, text='Reset', command=on_reset).pack()
+    tk.Button(win, text='Reload', command=on_reload).pack()
+
+    win.after(1000, watchdog)
+    win.wait_window()
+    commander.alive = False
+
+
+if __name__ == "__main__":
+    cli_entry()

totalsync_webinterface/web/CanvasCamera.js

@@ -0,0 +1,33 @@
+export class CameraView {
+    constructor(host_uri, port=8111) {
+        this.videoUri = `http://169.254.14.129:${port}/stream.mjpg`;
+        this.view = document.getElementById('videoStream');
+        this.view.src = this.videoUri;
+        this.t_last_frame = null;
+
+        this.view.onerror = (e) => {
+            console.error(e);
+            this.view.src = '';
+        };
+
+        this.view.onload = (e) => {
+            // each time a new frame is loaded?
+            if (this.t_last_frame != null) {
+                let elapsed = Date.now() - this.t_last_frame;
+
+                // if (elapsed > 1.0) {
+                //     console.log()
+                // }
+            }
+
+            this.t_last_frame = Date.now();
+        };
+
+        const reload_button = document.getElementById("videoStreamButton");
+        reload_button.onclick = this.reload
+    }
+
+    reload = () => {
+        this.view.src = this.videoUri;
+    }
+}