Multi-Board Networking

import serial.tools.list_ports
import serial, threading, time, json
from queue import Queue

BAUD = 115200

def find_touch_boards():
    """Find all connected Touch Boards by USB vendor/product ID."""
    boards = []
    for port in serial.tools.list_ports.comports():
        # Bare Conductive Touch Board: ATmega32U4 presents as Arduino
        # VID 0x2341 (Arduino) or 0x2A03 (Arduino.org)
        if port.vid in (0x2341, 0x2A03) or \
           'Arduino' in (port.manufacturer or '') or \
           'Bare' in (port.description or ''):
            boards.append(port.device)
    return boards

event_queue = Queue()

def board_reader(port_path, board_id):
    """Thread: read one Touch Board and push events to the queue."""
    while True:
        try:
            with serial.Serial(port_path, BAUD, timeout=1) as ser:
                print(f'Board {board_id}: connected on {port_path}')
                buf = ''
                while True:
                    data = ser.read(ser.in_waiting or 1)
                    buf += data.decode('ascii', errors='ignore')
                    while '\n' in buf:
                        line, buf = buf.split('\n', 1)
                        line = line.strip()
                        if line.startswith('T:'):
                            event_queue.put({'type':'touch','board':board_id,
                                             'electrode':int(line[2:]),'t':time.time()})
                        elif line.startswith('R:'):
                            event_queue.put({'type':'release','board':board_id,
                                             'electrode':int(line[2:]),'t':time.time()})
                        elif line.startswith('D:'):
                            vals = [int(v) for v in line[2:].split(',') if v.strip().isdigit()]
                            event_queue.put({'type':'proximity','board':board_id,
                                             'values':vals,'t':time.time()})
        except serial.SerialException as e:
            print(f'Board {board_id}: {e} — retrying in 3s')
            time.sleep(3)

def main():
    ports = find_touch_boards()
    if not ports:
        print('No Touch Boards found.')
        return

    threads = []
    for i, port in enumerate(ports):
        t = threading.Thread(target=board_reader, args=(port, i), daemon=True)
        t.start()
        threads.append(t)
        time.sleep(0.5)  # stagger startup to avoid USB enumeration collision

    print(f'Listening to {len(ports)} boards. Press Ctrl+C to stop.')
    while True:
        try:
            event = event_queue.get(timeout=1)
            handle_event(event)
        except:
            pass

def handle_event(event):
    # Global electrode address = board_id * 12 + electrode
    global_id = event['board'] * 12 + event.get('electrode', 0)
    print(f"[{event['type']}] global_id={global_id} board={event['board']} t={event['t']:.3f}")
    # Forward to p5.js / renderer via OSC or WebSocket

if __name__ == '__main__':
    main()

import pyudev

def build_stable_id_map():
    ctx = pyudev.Context()
    id_map = {}
    for dev in ctx.list_devices(subsystem='tty'):
        parent = dev.find_parent('usb', 'usb_device')
        if parent and parent.get('ID_VENDOR_ID') in ('2341', '2a03'):
            # Use bus + devpath as stable key
            key = parent.get('DEVPATH', '')
            id_map[key] = dev.get('DEVNAME')
    # Sort by key to get consistent ordering
    return {i: path for i, (_, path) in enumerate(sorted(id_map.items()))}

from pythonosc import udp_client
import socket

# Discover display nodes from a configuration file
DISPLAY_NODES = [
    ('192.168.1.101', 7400),
    ('192.168.1.102', 7400),
]

clients = [udp_client.SimpleUDPClient(ip, port) for ip, port in DISPLAY_NODES]

def broadcast_event(event):
    for client in clients:
        if event['type'] == 'touch':
            client.send_message('/touch',
                [event['board'], event['electrode'], event['t']])
        elif event['type'] == 'proximity':
            client.send_message('/proximity',
                [event['board']] + event['values'])

import paho.mqtt.client as mqtt
import zmq, json, time, re

ZMQ_ADDR = 'tcp://127.0.0.1:5555'
ctx       = zmq.Context()
pub       = ctx.socket(zmq.PUB)
pub.bind(ZMQ_ADDR)

def on_message(client, userdata, msg):
    topic   = msg.topic
    payload = msg.payload.decode()

    m = re.match(r'tb/(\d+)/(\w+)', topic)
    if not m: return
    board_id   = int(m.group(1))
    event_type = m.group(2)

    if event_type == 'touch':
        kind, electrode = payload.split(':')
        pub.send_json({'type': 'touch' if kind=='T' else 'release',
                       'board': board_id, 'electrode': int(electrode),
                       't': time.time()})
    elif event_type == 'proximity':
        vals = [int(v) for v in payload.split(',')]
        pub.send_json({'type': 'proximity', 'board': board_id,
                       'values': vals, 't': time.time()})

client = mqtt.Client()
client.on_message = on_message
client.connect('127.0.0.1', 1883)
client.subscribe('tb/#')  # subscribe to all boards
client.loop_forever()

import ntplib, time

def sync_time():
    try:
        c = ntplib.NTPClient()
        response = c.request('pool.ntp.org', version=3)
        offset = response.offset
        print(f'NTP offset: {offset*1000:.1f} ms')
        return offset
    except: return 0.0

TIME_OFFSET = sync_time()

def adjusted_time():
    return time.time() + TIME_OFFSET

# For a 4×3 grid of boards (48 electrodes total)
# Board 0 = top-left, board 3 = top-right, etc.
BOARD_POSITIONS = {
    0: (0, 0), 1: (1, 0), 2: (2, 0), 3: (3, 0),
}

ELECTRODE_POSITIONS = {}  # global_id → (x, y) in physical space
for board, (bx, by) in BOARD_POSITIONS.items():
    for e in range(12):
        row = e // 4
        col = e % 4
        global_id = board * 12 + e
        ELECTRODE_POSITIONS[global_id] = (bx * 4 + col, by * 3 + row)

class BoardMonitor:
    def __init__(self, n_boards, timeout=5.0):
        self.last_seen  = {i: 0.0 for i in range(n_boards)}
        self.online     = {i: False for i in range(n_boards)}
        self.timeout    = timeout

    def heartbeat(self, board_id):
        self.last_seen[board_id] = time.time()
        if not self.online[board_id]:
            self.online[board_id] = True
            print(f'Board {board_id} came online')

    def check(self):
        now = time.time()
        for board_id, last in self.last_seen.items():
            was_online = self.online[board_id]
            is_online  = (now - last) < self.timeout
            if was_online and not is_online:
                self.online[board_id] = False
                print(f'Board {board_id} went offline')
            elif is_online:
                self.online[board_id] = True