# Art-Net 4 (protocol 14). MicroPython and CPython. # UDP 6454. ArtDmx payload[0] is DMX channel 1 (no start code). import socket try: from time import ticks_diff, ticks_ms, sleep_ms except ImportError: from time import sleep, time def ticks_ms(): return int(time() * 1000) def ticks_diff(a, b): return a - b def sleep_ms(ms): sleep(ms / 1000.0) PORT = 6454 HEADER = b"Art-Net\x00" OP_POLL = 0x2000 OP_POLL_REPLY = 0x2100 OP_DMX = 0x5000 PROT_VER = 14 BROADCAST = "255.255.255.255" def _u16le(n): return bytes((n & 0xFF, (n >> 8) & 0xFF)) def _pad(text, size): raw = text.encode("ascii")[: size - 1] return raw + b"\x00" * (size - len(raw)) def _ip_bytes(ip): if isinstance(ip, (bytes, bytearray)): return bytes(ip[:4]) parts = ip.split(".") return bytes(int(p) for p in parts) def port_lo(universe=0, subnet=0): """SubUni byte: subnet in high nibble, universe in low nibble.""" return ((subnet & 0x0F) << 4) | (universe & 0x0F) def as_channels(data): """Normalise to 512-or-fewer channel bytes (ch 1 at index 0).""" if data is None: return b"" if len(data) == 513: data = data[1:] if len(data) > 512: data = data[:512] return data def build_artdmx(channels, universe=0, subnet=0, net=0, sequence=1, physical=0): data = bytearray(as_channels(channels)) n = len(data) if n < 2: data.extend(b"\x00" * (2 - n)) n = 2 if n & 1: data.append(0) n += 1 pkt = bytearray(18 + n) pkt[0:8] = HEADER pkt[8:10] = _u16le(OP_DMX) pkt[10] = 0 pkt[11] = PROT_VER pkt[12] = sequence pkt[13] = physical pkt[14] = port_lo(universe, subnet) pkt[15] = net & 0x7F pkt[16] = (n >> 8) & 0xFF pkt[17] = n & 0xFF pkt[18 : 18 + n] = data return pkt def parse(packet): """Return ('dmx', net, subuni, data), ('poll', addr_unused), or None.""" if packet is None or len(packet) < 10 or packet[0:8] != HEADER: return None opcode = packet[8] | (packet[9] << 8) if opcode == OP_DMX: if len(packet) < 18: return None length = (packet[16] << 8) | packet[17] data = packet[18 : 18 + length] return ("dmx", packet[15] & 0x7F, packet[14], data) if opcode == OP_POLL: return ("poll", None) if opcode == OP_POLL_REPLY: return ("poll_reply", None) return None class ArtNet: """Send and receive Art-Net on one universe. universe/subnet/net match the 15-bit Port-Address (net << 8) | (subnet << 4) | universe. """ def __init__( self, universe=0, subnet=0, net=0, bind="0.0.0.0", port=PORT, bind_port=None, name="esp-dmx", ip=None, mac=None, ): self.universe = universe & 0x0F self.subnet = subnet & 0x0F self.net = net & 0x7F self.name = name self.ip = ip self.mac = mac or bytes(6) self.sequence = 1 self.channels = bytearray(512) self.peers = [] self._subuni = port_lo(self.universe, self.subnet) self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) except OSError: pass try: self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) except OSError: pass self.sock.bind((bind, port if bind_port is None else bind_port)) try: self.sock.settimeout(0) except OSError: self.sock.setblocking(False) self._guess_host() def _guess_host(self): try: import network sta = network.WLAN(network.STA_IF) if sta.active() and sta.isconnected(): self.ip = sta.ifconfig()[0] try: self.mac = sta.config("mac") except Exception: pass return ap = network.WLAN(network.AP_IF) if ap.active(): self.ip = ap.ifconfig()[0] try: self.mac = ap.config("mac") except Exception: pass return except (ImportError, OSError, AttributeError): pass if not self.ip: self.ip = "0.0.0.0" def _note_peer(self, addr): """Remember unicast Art-Net sources (QLC+) so we can reply unicast.""" if not addr: return host = addr[0] if isinstance(addr, (tuple, list)) else addr if not host or host in (self.ip, BROADCAST, "0.0.0.0"): return if host.split(".")[-1] == "255": return if host not in self.peers: self.peers.append(host) print("artnet peer", host) self._unicast_poll_reply(host) def _announce_addrs(self, extra=None): addrs = [BROADCAST] if extra: host = extra[0] if isinstance(extra, (tuple, list)) else extra if host: addrs.append(host) self._guess_host() parts = (self.ip or "").split(".") if len(parts) == 4 and parts[0] != "0": addrs.append(".".join(parts[:3] + ["255"])) for p in self.peers: addrs.append(p) try: import network sta = network.WLAN(network.STA_IF) if sta.active() and sta.isconnected(): gw = sta.ifconfig()[2] if gw: addrs.append(gw) except Exception: pass seen = [] for a in addrs: if a and a not in seen: seen.append(a) return seen def announce(self): """ArtPoll + ArtPollReply. Unicast to known PCs; broadcast for the rest.""" self._guess_host() reply = self._poll_reply_packet() poll = bytearray(14) poll[0:8] = HEADER poll[8:10] = _u16le(OP_POLL) poll[10] = 0 poll[11] = PROT_VER poll[12] = 0x02 poll[13] = 0 for host in self._announce_addrs(): try: self.sock.sendto(reply, (host, PORT)) self.sock.sendto(poll, (host, PORT)) except OSError: pass def send(self, data=None, dest=BROADCAST, port=PORT): """Send ArtDmx. data[0] is channel 1, or pass a 513-byte UART frame.""" if data is None: data = self.channels pkt = build_artdmx( data, universe=self.universe, subnet=self.subnet, net=self.net, sequence=self.sequence, ) self.sequence += 1 if self.sequence > 255: self.sequence = 1 self.sock.sendto(pkt, (dest, port)) def poll(self, dest=BROADCAST, port=PORT): """Broadcast ArtPoll so other nodes reply.""" pkt = bytearray(14) pkt[0:8] = HEADER pkt[8:10] = _u16le(OP_POLL) pkt[10] = 0 pkt[11] = PROT_VER pkt[12] = 0 pkt[13] = 0 self.sock.sendto(pkt, (dest, port)) def recv(self): """Read pending UDP. Returns channel bytes for this universe, else None. Replies to ArtPoll so QLC+ / consoles can discover this node. If several ArtDmx packets are queued, the latest matching one is kept. """ latest = None while True: packet, addr = self._recvfrom() if packet is None: break kind = parse(packet) if kind is None: continue self._note_peer(addr) if kind[0] == "poll": self._send_poll_reply(addr) elif kind[0] == "dmx": _name, net, subuni, data = kind if net == self.net and subuni == self._subuni: n = len(data) if n > 512: n = 512 self.channels[:n] = data[:n] if n < 512: # leave remaining channels as last values pass latest = self.channels return latest def apply_frame(self, frame): """Copy current channels into a UART DMX frame (start code at [0]).""" n = len(self.channels) frame[1 : 1 + n] = self.channels def serve(self, dmx): """Block: Art-Net in, UART DMX out. Announces to QLC+ every 2.5s.""" self.announce() print("artnet node", self.ip, "universe", self.universe) last_announce = ticks_ms() while True: if self.recv() is not None: self.apply_frame(dmx.frame) dmx.send() now = ticks_ms() if ticks_diff(now, last_announce) >= 2500: self.announce() last_announce = now sleep_ms(20) def close(self): self.sock.close() def _recvfrom(self): try: return self.sock.recvfrom(2048) except OSError: return None, None def _poll_reply_packet(self): pkt = bytearray(239) pkt[0:8] = HEADER pkt[8:10] = _u16le(OP_POLL_REPLY) pkt[10:14] = _ip_bytes(self.ip) pkt[14:16] = _u16le(PORT) pkt[16] = 0 pkt[17] = 1 pkt[18] = self.net pkt[19] = self.subnet pkt[20] = 0x00 pkt[21] = 0xFF pkt[23] = 0xF0 pkt[26:44] = _pad(self.name, 18) pkt[44:108] = _pad(self.name + " Art-Net node", 64) pkt[108:172] = _pad("#0001 [00] ok", 64) pkt[173] = 1 pkt[174] = 0x80 pkt[182] = 0x80 pkt[190] = self.universe pkt[200] = 0 mac = bytes(self.mac)[:6] pkt[201 : 201 + len(mac)] = mac pkt[207:211] = _ip_bytes(self.ip) pkt[211] = 1 pkt[212] = 0x08 return pkt def _unicast_poll_reply(self, host): try: self.sock.sendto(self._poll_reply_packet(), (host, PORT)) except OSError: pass def _send_poll_reply(self, addr): pkt = self._poll_reply_packet() dests = self._announce_addrs(addr) for host in dests: try: self.sock.sendto(pkt, (host, PORT)) except OSError: pass