Added the ability to switch between different board configs

Author: Ezra Boley

src/devlprd/DaemonState.py

@@ -3,6 +3,8 @@
 import threading
 import collections as coll
 
+from devlprd.config import Board
+
 from .filtering import ButterworthFilter, BUTTER8_45_55_NOTCH, BUTTER8_55_65_NOTCH
 from pydevlpr_protocol import wrap_packet, DataTopic, DaemonSocket
 from typing import Deque, Dict, List
@@ -11,8 +13,8 @@ class DaemonState:
     """Thread protected shared state for the Daemon. It manages all of the connections and data topics."""
 
     BUFFER_SIZE = 32  # Somewhat arbitrary, can be fine tuned to provide different results with data processing (e.g. changes response time vs smoothing).
-    def __init__(self, event_loop):
-
+    def __init__(self, event_loop, board: Board):
+        self.PIN_NUMS = list(range(0, board['NUM PINS']))
         self.SUBS: Dict[str, List[DaemonSocket]] = dict()
         self.SERIAL_DATA: Dict[int, Deque[int]] = dict()
         self.SERIAL_DATA_RUNNING_SUMS: Dict[int, float] = dict() # for window avg
@@ -28,13 +30,13 @@ def init_butterworth_filters(self):
         self.BUTTER60_FILTS = dict()
         self.BUTTER50_FILTS = dict()
         # go through all possible pins and create a new one
-        for pin in [0, 1, 2, 3, 4, 5]:
+        for pin in self.PIN_NUMS:
             self.BUTTER60_FILTS[pin] = ButterworthFilter(BUTTER8_55_65_NOTCH)
             self.BUTTER50_FILTS[pin] = ButterworthFilter(BUTTER8_45_55_NOTCH)
 
     def init_data_buffers(self):
         # no need to save space, just make buffer objects ahead
-        for pin in [0, 1, 2, 3, 4, 5]:
+        for pin in self.PIN_NUMS:
             # just create the deque and throw an initial 0 in there for now
             self.SERIAL_DATA[pin] = coll.deque(maxlen=self.BUFFER_SIZE)
             self.SERIAL_DATA[pin].appendleft(0)

src/devlprd/__init__.py

@@ -1,3 +1,7 @@
 from .daemon import (
     DaemonController
+)
+
+from .config import (
+    get_board_ids
 )

src/devlprd/__main__.py

@@ -1,6 +1,6 @@
 from .daemon import DaemonController
 
 if __name__ == "__main__":
-    controller = DaemonController()
+    controller = DaemonController('DEVLPR')
     controller.start(True)
 

src/devlprd/config.py

@@ -1,4 +1,23 @@
+from typing import Dict, List, Union
+
+Board = Dict[str, Union[str, int]]
+
 CONFIG = {
-    'BAUD': 2000000,
     'ADDRESS': ("localhost", 8765)  # (Address/IP, Port)
-}
+}
+
+BOARDS: Dict[str, Board] = {
+    'DEVLPR': {
+        'BAUD': 2_000_000,
+        'NAME': 'arduino',
+        'NUM PINS': 6
+    },
+    'Neuron': {
+        'BAUD': 115_200,
+        'NAME': 'neuron',
+        'NUM PINS': 8
+    }
+}
+
+def get_board_ids() -> List[str]:
+    return list(BOARDS.keys())

src/devlprd/daemon.py

@@ -1,22 +1,30 @@
 import asyncio
 import multiprocessing as mp
 import logging
+from typing import Optional
 from pydevlpr_protocol import DataFormatException, unwrap_packet, PacketType, DaemonSocket
 
 from .serif import DevlprSerif
 from .DaemonState import DaemonState
-from .config import CONFIG
+from .config import BOARDS, Board, get_board_ids, CONFIG
 
 server = None
-state: DaemonState = None  # Make sure to pass this to any other threads that need access to shared state
-devlpr_serial: DevlprSerif = None
+state: Optional[DaemonState] = None  # Make sure to pass this to any other threads that need access to shared state
+devlpr_serial: Optional[DevlprSerif] = None
 
 logging.basicConfig(level=logging.INFO)
 
 class DaemonController:
+    def __init__(self, board_id: str) -> None:
+        try:
+            self.board = BOARDS[board_id]
+        except KeyError:
+            logging.warning("Invalid board ID, try get_board_ids() for options")
+            logging.info('Assuming DEVLPR')
+            self.board = BOARDS['DEVLPR']
 
     def start(self, block=False):
-        self.p = mp.Process(target=main)
+        self.p = mp.Process(target=main, args=(self.board,))
         self.p.start()
         if block:
             self.p.join()
@@ -25,8 +33,8 @@ def stop(self):
         if self.p is not None and self.p.is_alive():
             self.p.terminate()
 
-def main():
-    asyncio.run(startup())
+def main(board: Board):
+    asyncio.run(startup(board))
 
 async def client_accept(sock: DaemonSocket) -> None:
     """Delegate and process incoming messages from a websocket connection."""
@@ -40,8 +48,11 @@ async def client_accept(sock: DaemonSocket) -> None:
             except DataFormatException:
                 continue  # Handle an unexpected issue with the packet
             if command == PacketType.SUBSCRIBE:
-                logging.info("Sub to {}".format(data))
-                state.subscribe(sock, data)
+                logging.info("Subscribing to {}".format(data))
+                try:
+                    state.subscribe(sock, data)
+                except AttributeError:
+                    logging.error("Failed to subscribe, Daemon State is None")
 
 async def client_handler(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
     """Main function for socket connections. Holds the connection until the other side disconnects."""
@@ -52,10 +63,12 @@ async def client_handler(reader: asyncio.StreamReader, writer: asyncio.StreamWri
         await client_accept(dsock)
     finally:
         logging.info("Disconnected from {0}".format(dsock.get_remote_address()))
-        state.unsubscribe_all(dsock)
+        try:
+            state.unsubscribe_all(dsock)
+        except AttributeError:
+            logging.error("Failed to unsubscribe_all, Daemon State is None")
 
-
-async def startup() -> None:
+async def startup(board: Board) -> None:
     """Initiallizes both the serial connection and the socket server. It then just hangs until everything is done internally before cleaning up."""
 
     global server
@@ -64,17 +77,16 @@ async def startup() -> None:
     # we'll want the asyncio event loop for subscriptions, some processing, and publishing
     event_loop = asyncio.get_running_loop()
     # the DaemonState requests publishes upon state change, so needs to know the event loop
-    state = DaemonState(event_loop)
+    state = DaemonState(event_loop, board)
     # we initialize our serial connection, which is managed on a separate thread
-    devlpr_serial = DevlprSerif()
+    devlpr_serial = DevlprSerif(board)
     devlpr_serial.init_serial(state)
     # start a server, waiting for incoming subscribers to data (pydevlpr and other libraries)
     server = await asyncio.start_server(client_handler, CONFIG['ADDRESS'][0], CONFIG['ADDRESS'][1])
     try:
         await server.serve_forever()
     except asyncio.exceptions.CancelledError:
         await server.wait_closed()
-    print("Finish up")
     devlpr_serial.deinit_serial()
 
 def shutdown() -> None:
@@ -89,6 +101,8 @@ def shutdown() -> None:
         pass 
     try:
         devlpr_serial.deinit_serial()
+    except AttributeError:
+        logging.warning("Serial couldn't close because devlpr_serial is already None")
     except:
         pass # not even sure this is necessary
 

src/devlprd/serif.py

@@ -1,12 +1,13 @@
 import logging
+from typing import Optional
 import serial
 import serial.threaded as sthread
 import serial.tools.list_ports as list_ports
 
 from pydevlpr_protocol import unpack_serial, DataFormatException
-from .config import CONFIG
+from .config import CONFIG, BOARDS, Board
 
-def find_arduino_port() -> str:
+def find_port(board_name: str) -> str:
     """Smart port searching for finding an Arduino.
     
     Parses metadata to figure out where your Arduino is to avoid
@@ -15,20 +16,20 @@ def find_arduino_port() -> str:
 
     port_list = list_ports.comports()
     for port in port_list:
-        if "arduino" in port.description.lower():
+        if board_name in port.description.lower():
             return port.device   
     return ""
 
 
-def connect_to_arduino() -> serial.Serial:
+def connect_to_board(board: Board) -> serial.Serial:
     """Creates a serial connection to an Arduino if possible."""
 
-    port = find_arduino_port()
+    port = find_port(str(board['NAME']))
     if port == "":
-        logging.warning("No Arduino Found")
+        logging.warning("No Board Found")
         return None
     try:
-        serif = serial.serial_for_url(port, baudrate=CONFIG["BAUD"])
+        serif = serial.serial_for_url(port, baudrate=board['BAUD'])
     except serial.SerialException as e:
         logging.error("Failed to open serial port {}: {}".format(port, e))
         return None
@@ -37,6 +38,7 @@ def connect_to_arduino() -> serial.Serial:
 
 class DevlprReader(sthread.Packetizer):
     """Extends Packetizer from pyserial threading module, async serial support."""
+    
     TERMINATOR = bytes([1])  ## Assumed to be at the end of every message
 
     def __init__(self, daemon_state):
@@ -56,7 +58,6 @@ def connection_made(self, transport: sthread.Protocol) -> None:
     # Called on each new packet (packet + TERMINATOR) from the serial port
     def handle_packet(self, packet: bytes) -> None:
         # Always buffer, custom callbacks are further up the stack
-
         try:
             (pin, data) = unpack_serial(packet)  # Split into payload and topic
         except DataFormatException:   # If the packet is invalid
@@ -73,15 +74,16 @@ def connection_lost(self, exc: Exception) -> None:
 class DevlprSerif:
     """Devlpr Ser(ial) i(nter)f(ace). Manages the threaded serial data connection with a DEVLPR board."""
 
-    def __init__(self) -> None:
-        self.reader_thread: sthread.ReaderThread = None
-        self.devlpr_reader: DevlprReader = None
+    def __init__(self, board: Board) -> None:
+        self.board = board
+        self.reader_thread: Optional[sthread.ReaderThread] = None
+        self.devlpr_reader: Optional[DevlprReader] = None
 
     def init_serial(self, state) -> None:
         """ First opens the port, then spins off a watcher thread
         so it doesn't block the main path of execution."""
 
-        serif = connect_to_arduino()
+        serif = connect_to_board(self.board)
         if serif is None:
             return
         self.devlpr_reader = DevlprReader(state)

src/main.py

@@ -2,6 +2,6 @@
 import devlprd
 
 if __name__ == "__main__":
-    controller = devlprd.DaemonController()
+    controller = devlprd.DaemonController('Neuron')
     controller.start(True)