Check sACN START_CODE and only proceed if it's a START_CODE that we can handle (DMX512). Ref #108

Author: Breina

custom_components/dmx/server/sacn_packet.py

@@ -48,8 +48,16 @@ def __post_init__(self) -> None:
 
         if len(self.dmx_data) == 0:
             self.dmx_data = bytearray(513)
-        if self.dmx_data[0] != 0x00:
-            self.dmx_data[0] = 0x00
+
+    @property
+    def start_code(self) -> int:
+        """Return the DMX start code (first byte of dmx_data)."""
+        return self.dmx_data[0] if len(self.dmx_data) > 0 else 0x00
+
+    @property
+    def channel_data(self) -> bytearray:
+        """Return DMX channel data (bytes 1-512, excluding start code)."""
+        return self.dmx_data[1:] if len(self.dmx_data) > 1 else bytearray()
 
     def set_dmx_channel(self, channel: int, value: int) -> None:
         assert 1 <= channel <= 512, "Channel must be 1-512"
@@ -63,17 +71,17 @@ def set_dmx_channel(self, channel: int, value: int) -> None:
     def set_dmx_data(self, data: bytearray) -> None:
         assert len(data) <= 513, "DMX data must be <= 513 bytes"
         self.dmx_data = data
-        if len(self.dmx_data) > 0 and self.dmx_data[0] != 0x00:
-            self.dmx_data[0] = 0x00
 
     def get_multicast_address(self) -> str:
         return f"239.255.{self.universe >> 8}.{self.universe & 0xFF}"
 
     def serialize(self) -> bytes:
+        dmx_data_out = bytearray(self.dmx_data)
+        if len(dmx_data_out) > 0:
+            dmx_data_out[0] = 0x00
+
         # Calculate lengths
-        dmp_layer_length = 10 + len(
-            self.dmx_data
-        )  # DMP header (10) + property values (dmx_data contains the 0x00 byte)
+        dmp_layer_length = 10 + len(dmx_data_out)  # DMP header (10) + property values (dmx_data contains the 0x00 byte)
         framing_layer_length = 77 + dmp_layer_length  # Framing header (77) + DMP layer
         root_layer_length = 22 + framing_layer_length  # Root header (22) + Framing layer
 
@@ -113,9 +121,9 @@ def serialize(self) -> bytes:
         packet.extend(struct.pack(">B", DMP_ADDRESS_TYPE_DATA_TYPE))
         packet.extend(struct.pack(">H", DMP_FIRST_PROPERTY_ADDRESS))
         packet.extend(struct.pack(">H", DMP_ADDRESS_INCREMENT))
-        packet.extend(struct.pack(">H", len(self.dmx_data)))
+        packet.extend(struct.pack(">H", len(dmx_data_out)))
 
-        packet.extend(self.dmx_data)
+        packet.extend(dmx_data_out)
 
         return bytes(packet)
 

custom_components/dmx/server/sacn_server.py

@@ -179,7 +179,10 @@ def send_dmx_data(self, universe_id: int, dmx_data: bytearray) -> bool:
         # Start streaming task if not already running
         if universe_state.stream_task is None or universe_state.stream_task.done():
             log.debug(f"Universe {universe_id}: creating new streaming task")
-            universe_state.stream_task = self.hass.async_create_task(self._stream_universe_data(universe_id))
+            universe_state.stream_task = self.hass.async_create_background_task(
+                self._stream_universe_data(universe_id),
+                name=f"sACN stream universe {universe_id}",
+            )
 
         self.hass.async_create_task(self._send_pending_frame(universe_id))
 
@@ -394,32 +397,42 @@ def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
         try:
             packet = SacnPacket.deserialize(data)
 
-            if packet.universe in self.subscribed_universes:
-                log.debug(
-                    f"Received sACN data for universe {packet.universe} from {addr[0]} "
-                    f"(source: '{packet.source_name}', seq: {packet.sequence_number}, "
-                    f"priority: {packet.priority}, channels: {len(packet.dmx_data)})"
-                )
-
-                # Ignore packets from our own sACN server to prevent feedback loops
-                if self.own_source_name and packet.source_name == self.own_source_name:
-                    return
-
-                if self.data_callback:
-                    port_address = PortAddress(0, 0, packet.universe)
-                    self.data_callback(port_address, packet.dmx_data, packet.source_name)
-                else:
-                    log.warning("No data callback configured for sACN receiver")
+            if packet.start_code == 0x00:
+                self._handle_dmx_packet(packet, addr)
             else:
                 log.debug(
-                    f"Ignoring sACN data for universe {packet.universe} from {addr[0]} "
-                    f"(not subscribed, subscribed universes: {self.subscribed_universes})"
+                    f"Ignoring sACN packet with unsupported start code 0x{packet.start_code:02X} "
+                    f"for universe {packet.universe} from {addr[0]} (source: '{packet.source_name}')"
                 )
 
         except Exception as e:
             log.warning(f"Error processing sACN packet from {addr[0]}:{addr[1]} ({len(data)} bytes): {e}")
             log.debug(f"Raw packet data: {data[:50].hex()}{'...' if len(data) > 50 else ''}")
 
+    def _handle_dmx_packet(self, packet: SacnPacket, addr: tuple[str, int]) -> None:
+        """Handle a DMX512-A data packet (start code 0x00)."""
+        if self.own_source_name and packet.source_name == self.own_source_name:
+            return
+
+        if packet.universe not in self.subscribed_universes:
+            log.debug(
+                f"Ignoring sACN data for universe {packet.universe} from {addr[0]} "
+                f"(not subscribed, subscribed universes: {self.subscribed_universes})"
+            )
+            return
+
+        log.debug(
+            f"Received sACN DMX data for universe {packet.universe} from {addr[0]} "
+            f"(source: '{packet.source_name}', seq: {packet.sequence_number}, "
+            f"priority: {packet.priority}, channels: {len(packet.channel_data)})"
+        )
+
+        if self.data_callback:
+            port_address = PortAddress(0, 0, packet.universe)
+            self.data_callback(port_address, packet.channel_data, packet.source_name)
+        else:
+            log.warning("No data callback configured for sACN receiver")
+
     def subscribe_universe(self, universe_id: int) -> None:
         if not (1 <= universe_id <= 63999):
             log.error(f"Invalid universe ID: {universe_id}")

deploy_staging.py

@@ -1,4 +1,4 @@
-import shutil
+import subprocess
 import time
 import webbrowser
 
@@ -16,8 +16,15 @@
 def copy_repo():
     print("Copying repo...")
     # Requires Samba share and it being configured as network location in Windows
-    shutil.rmtree(STAGING_FOLDER)
-    shutil.copytree("custom_components/dmx", STAGING_FOLDER, dirs_exist_ok=True)
+    result = subprocess.run(
+        ["robocopy", "custom_components/dmx", STAGING_FOLDER, "/MIR", "/NJH", "/NJS"],
+        capture_output=True,
+        text=True,
+    )
+    print(result.stdout)
+    # robocopy exit codes 0-7 are success (bitmask: 1=copied, 2=extras deleted, 4=mismatches)
+    if result.returncode >= 8:
+        raise RuntimeError(f"robocopy failed with exit code {result.returncode}\n{result.stderr}")
 
 
 def restart_ha() -> Response:

tests/test_sacn_packet.py

@@ -94,13 +94,27 @@ def test_set_dmx_data(self):
         packet.set_dmx_data(test_data)
 
         assert packet.dmx_data == test_data
-        assert packet.dmx_data[0] == 0x00
+        assert packet.start_code == 0x00
+        assert packet.channel_data == test_data[1:]
 
-        no_start_code_data = bytearray([255] + [i % 256 for i in range(1, 513)])
-        packet.set_dmx_data(no_start_code_data)
+        non_zero_start_code_data = bytearray([0xDD] + [i % 256 for i in range(1, 513)])
+        packet.set_dmx_data(non_zero_start_code_data)
 
-        assert packet.dmx_data[0] == 0x00
-        assert packet.dmx_data[1:] == no_start_code_data[1:]
+        assert packet.dmx_data == non_zero_start_code_data
+        assert packet.start_code == 0xDD
+        assert packet.channel_data == non_zero_start_code_data[1:]
+
+    def test_serialize_forces_start_code_zero(self):
+        """Test that serialize() always outputs start code 0x00 regardless of internal value."""
+        packet = SacnPacket()
+
+        non_zero_start_code_data = bytearray([0xDD] + [100] * 512)
+        packet.set_dmx_data(non_zero_start_code_data)
+
+        assert packet.start_code == 0xDD
+
+        serialized = packet.serialize()
+        assert serialized[125] == 0x00
 
     def test_multicast_address_calculation(self):
         test_cases = [

tests/test_sacn_server.py

@@ -225,7 +225,7 @@ def test_packet_processing(self, sacn_receiver, data_callback):
         assert port_address.universe == 1
 
         dmx_data = call_args[1]
-        assert dmx_data == test_packet.dmx_data
+        assert dmx_data == test_packet.dmx_data[1:]
 
         source_name = call_args[2]
         assert source_name == test_packet.source_name
@@ -242,6 +242,21 @@ def test_packet_processing_unsubscribed(self, sacn_receiver, data_callback):
 
         data_callback.assert_not_called()
 
+    def test_packet_processing_non_dmx_start_code_ignored(self, sacn_receiver, data_callback):
+        """Test that packets with non-DMX start codes (e.g., 0xDD per-address priority) are ignored."""
+        sacn_receiver.subscribe_universe(1)
+
+        from custom_components.dmx.server.sacn_packet import SacnPacket
+
+        test_packet = SacnPacket(universe=1, dmx_data=bytearray([0] + [100] * 512))
+        serialized_packet = bytearray(test_packet.serialize())
+
+        serialized_packet[125] = 0xDD  # Per-address priority start code
+
+        sacn_receiver.datagram_received(bytes(serialized_packet), ("192.168.1.100", 5568))
+
+        data_callback.assert_not_called()
+
     def test_connection_lifecycle(self, sacn_receiver):
         mock_transport = MagicMock()