wip: art-net RDM table-of-devices support

Author: shuckc

README.md

@@ -134,5 +134,12 @@ This application aims to be fully compatible with Art-Net devices. We have teste
 * iOS [DMX Monitor app](https://apps.apple.com/us/app/dmx-monitor/id1544911427)
 * Many other iOS apps
 
-
 ![Art-Net logo](./docs/art-net-master-logo.svg) Art-Net™ Designed by and Copyright Artistic Licence Engineering Ltd.
+
+RDM
+---
+
+See https://www.rdmprotocol.org/rdm/
+
+RDM specs are https://tsp.esta.org/tsp/documents/published_docs.php
+

aioartnet/aio_artnet.py

@@ -108,7 +108,9 @@ def __init__(self, portaddress: int):
         self.last_data = bytearray(DMX_UNIVERSE_SIZE)
         self._last_seq = 1
         self._last_publish: float = 0.0
+        self._last_tod_request: float = 0.0
         self.publisherseq: dict[Tuple[DGAddr, int], int] = {}
+        self.tod_uuids: set[bytes] = set()
 
     def split(self) -> Tuple[int, int, int]:
         # name  net:sub_net:universe
@@ -159,6 +161,8 @@ def __init__(self, client: "ArtNetClient"):
             0x2000: self.on_art_poll,
             0x2100: self.on_art_poll_reply,
             0x5000: self.on_art_dmx,
+            0x8000: self.on_art_tod_request,
+            0x8100: self.on_art_tod_data,
         }
         client.protocol = self
         self.node_report_counter = 0
@@ -176,7 +180,7 @@ def datagram_received(self, data: bytes, addr: DGAddr) -> None:
             if h:
                 h(addr, data[10:])
             else:
-                logger.debug(
+                logger.info(
                     f"Received unsupported Art-Net: op {hex(opcode)} from {addr}: {data[10:]!r}"
                 )
         else:
@@ -335,6 +339,44 @@ def on_art_dmx(self, addr: DGAddr, data: bytes) -> None:
         # Only two sources are allowed to contribute to the values in the universe
         u.last_data[0:chlen] = data[8 : 8 + chlen]
 
+    def on_art_tod_request(self, addr: DGAddr, data: bytes) -> None:
+        (ver,) = struct.unpack("<H", data[0:2])
+        net = data[11]
+        cmd = data[12]
+        address_count = data[13]
+        # net+address => universe address
+        for universe in [int(x) + net << 8 for x in data[14 : 14 + address_count]]:
+            logger.debug(
+                f"Received Art-Net TOD request: ver {ver} cmd {cmd} universe {universe} from {addr}"
+            )
+            # TODO: if we are an output, answer this with our cached tod table by sending
+            # art_tod_data packets
+
+    def on_art_tod_data(self, addr: DGAddr, data: bytes) -> None:
+        ver, rdm_ver, port = struct.unpack("<HBB", data[0:4])
+        # 6 bytes spare
+        bind_index, net, response, address, tot_uid, block_count, uid_count = (
+            struct.unpack("<BBBBHBB", data[10:18])
+        )
+        portaddress = net << 8 + address
+        TOD_FULL = 0
+
+        if response != TOD_FULL:
+            logger.info(
+                "Got unexpected art_tod_data with response {response} from {addr}"
+            )
+            return
+
+        u = self.client._get_create_universe(portaddress)
+
+        # I think tot_uid and block_count are *paging* related if more tod UIDs than can fit in a packet
+        for i in range(uid_count):
+            uid = data[18 + i * 6 : 18 + (i + 1) * 6]
+            u.tod_uuids.add(uid)
+            logger.info(
+                f"Received Art-Net TOD entry: universe {portaddress} uid={uid.hex()} from {addr}"
+            )
+
     async def art_poll_task(self) -> None:
         while True:
             await asyncio.sleep(0.1)
@@ -343,6 +385,8 @@ async def art_poll_task(self) -> None:
             for u in self.client._publishing:
                 if t > u._last_publish + 1.0:
                     self._send_art_dmx(u)
+                if t > u._last_tod_request + 5.0:
+                    self._send_art_tod_request(u)
 
             if t > self._last_poll + 2.0:
                 self._send_art_poll()
@@ -468,6 +512,37 @@ def _send_art_dmx_subscriber(
         if self.transport:
             self.transport.sendto(message, addr=(node.ip, node.udpport))
 
+    def _send_art_tod_request(self, universe: ArtNetUniverse):
+        logger.debug(f"sending art tod request for {universe}")
+        universe._last_tod_request = time.time()
+
+        subuni = universe.portaddress & 0xFF
+        net = universe.portaddress >> 8
+        message = ARTNET_PREFIX + struct.pack(
+            "<HBBBBBBBBBBBBBBB",
+            0x8000,
+            0,
+            14,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            net,
+            0,  # command TodFull
+            1,
+            subuni,
+        )
+
+        if self.transport:
+            # send direct to node?
+            #    self.transport.sendto(message, addr=(node.ip, node.udpport))
+            self.transport.sendto(message, addr=(self.client.broadcast_ip, ARTNET_PORT))
+
     def error_received(self, exc: Exception) -> None:
         logger.warn("Error received:", exc)
 
@@ -586,6 +661,7 @@ def set_port_config(
         universe: UniverseKey,
         is_input: bool = False,
         is_output: bool = False,
+        rdm: bool = False,
     ) -> ArtNetUniverse:
         port_addr = self._parse_universe(universe)
 

aioartnet/main.py

@@ -30,6 +30,8 @@ async def main(client: ArtNetClient) -> None:
     parser.add_argument("-i", "--interface")
     parser.add_argument("-n", "--portName")
     parser.add_argument("-p", "--publish", action="store_true")
+    parser.add_argument("-r", "--rdm", action="store_true")
+
     args = parser.parse_args()
 
     level = {False: logging.INFO, True: logging.DEBUG}[args.verbose]
@@ -42,7 +44,7 @@ async def main(client: ArtNetClient) -> None:
         kwargs["portName"] = args.portName
     client = ArtNetClient(**kwargs)
     if args.publish:
-        u1 = client.set_port_config("0:0:0", is_input=True)
+        u1 = client.set_port_config("0:0:0", is_input=True, rdm=args.rdm)
         u1.set_dmx(bytes(list(range(128)) * 4))
     asyncio.run(main(client))
     asyncio.get_event_loop().run_forever()