Files
jimmyandClaude Haiku 5.5 4cd3bc7973 feat: DDP frame sync over UDP broadcast, DDP acks, DDP enable setting
- Driver acks each completed DDP frame; the test waits for the acks before broadcasting the sync.
- Sync listener on UDP 4049: a frame is held until the next sync, then shown.
- DDP pixels are shown at full brightness, ignoring the device brightness settings.
- "DDP and sync receive on" setting (NVS, network API, web UI); off ignores DDP and sync packets.
- ddp_test.py: finds devices on the subnet, drives them in lockstep at a fixed rate, runs animations.
- /api/ddp reports sync counters for diagnosis.
- Includes in-progress WebSocket, multi-driver web UI and Wi-Fi work from the same tree.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-11-11 14:10:55 +13:00

342 lines
14 KiB
Python

# SPDX-FileCopyrightText: 2022-2026 Espressif Systems (Shanghai) CO LTD
# SPDX-License-Identifier: Unlicense OR CC0-1.0
import ipaddress
import os
import re
import select
import socket
import struct
import time
from threading import Event, Thread
try:
import dpkt
import dpkt.dns
except ImportError:
pass
def _encode_qname(name):
"""Encode a DNS QNAME (e.g. 'host.local' or '100.1.168.192.in-addr.arpa')."""
qname = b''
for label in name.split('.'):
qname += struct.pack('B', len(label)) + label.encode()
qname += b'\x00'
return qname
def _decode_dns_name(data, offset, seen=None):
"""Decode a DNS name from packet, handling compression. Returns (name, new_offset)."""
if seen is None:
seen = set()
labels = []
while offset < len(data):
if offset in seen:
break
length = data[offset]
if length == 0:
return ('.'.join(labels), offset + 1)
if (length & 0xC0) == 0xC0:
ptr = struct.unpack('!H', data[offset:offset + 2])[0] & 0x3FFF
if ptr < len(data) and ptr not in seen:
seen.add(ptr)
subname, _ = _decode_dns_name(data, ptr, seen)
return ('.'.join(labels) + ('.' + subname if labels else subname), offset + 2)
return ('.'.join(labels), offset + 2)
seen.add(offset)
offset += 1
if offset + length <= len(data):
labels.append(data[offset:offset + length].decode('utf-8', errors='replace'))
offset += length
return ('.'.join(labels), offset)
def run_one_shot_query(name, qtype='A', server='224.0.0.251', port=5353, timeout=5, retries=3):
"""
Pure-python single-shot DNS query to a multicast address (replaces dig +short).
For qtype='A': name is hostname (e.g. 'esp32.local'), returns bytes with IP(s).
For qtype='PTR': name is reverse format (e.g. '100.1.168.192.in-addr.arpa'), returns bytes with hostname(s).
"""
qtype_val = 1 if qtype == 'A' else 12 # A=1, PTR=12
tx_id = struct.pack('!H', os.getpid() & 0xFFFF)
flags = struct.pack('!H', 0x0000)
counts = struct.pack('!HHHH', 1, 0, 0, 0)
qname = _encode_qname(name)
qtype_pack = struct.pack('!H', qtype_val)
qclass = struct.pack('!H', 1) # IN
query = tx_id + flags + counts + qname + qtype_pack + qclass
print('run_one_shot_query: {} qtype={} -> {}:{}'.format(name, qtype, server, port))
for attempt in range(1, retries + 1):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
sock.setblocking(False)
sock.bind(('0.0.0.0', 0))
sock.sendto(query, (server, port))
deadline = time.time() + timeout
while time.time() < deadline:
remaining = max(0.1, deadline - time.time())
ready, _, _ = select.select([sock], [], [], min(remaining, 1.0))
if not ready:
continue
data, addr = sock.recvfrom(4096)
if len(data) < 12:
continue
ancount = struct.unpack('!H', data[6:8])[0]
offset = 12
qdcount = struct.unpack('!H', data[4:6])[0]
for _ in range(qdcount):
while offset < len(data):
length = data[offset]
if length == 0:
offset += 1
break
if (length & 0xC0) == 0xC0:
offset += 2
break
offset += 1 + length
offset += 4
results = []
for _ in range(ancount):
if offset >= len(data):
break
if (data[offset] & 0xC0) == 0xC0:
offset += 2
else:
while offset < len(data) and data[offset] != 0:
offset += 1 + data[offset]
offset += 1
if offset + 10 > len(data):
break
rtype = struct.unpack('!H', data[offset:offset + 2])[0]
rdlength = struct.unpack('!H', data[offset + 8:offset + 10])[0]
offset += 10
if qtype == 'A' and rtype == 1 and rdlength == 4 and offset + 4 <= len(data):
ip = socket.inet_ntoa(data[offset:offset + 4])
results.append(ip)
elif qtype == 'PTR' and rtype == 12 and offset + rdlength <= len(data):
ptr_name, _ = _decode_dns_name(data, offset)
results.append(ptr_name.rstrip('.'))
offset += rdlength
if results:
if qtype == 'A':
output = '\n'.join(results) + '\n'
else:
output = '\n'.join(results) + '\n'
print(' resolved: {}'.format(', '.join(results)))
return output.encode('utf-8')
print(' attempt {} timed out after {}s'.format(attempt, timeout))
except Exception as e:
print(' attempt {} exception: {}'.format(attempt, e))
finally:
sock.close()
print(' all {} attempts failed'.format(retries))
return b''
def _ip_to_reverse_name(ip_address):
"""Convert IP address to reverse DNS query name (e.g. 192.168.1.100 -> 100.1.168.192.in-addr.arpa)."""
if ':' in ip_address:
addr = ipaddress.ip_address(ip_address)
rev = addr.reverse_pointer # e.g. 0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.
return rev.rstrip('.')
parts = ip_address.split('.')
return '.'.join(reversed(parts)) + '.in-addr.arpa'
def get_dns_query_for_esp(esp_host):
dns = dpkt.dns.DNS(
b'\x00\x00\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x01'
)
dns.qd[0].name = esp_host + u'.local'
print('Created query for esp host: {} '.format(dns.__repr__()))
return dns.pack()
def get_dns_answer_to_mdns(tester_host):
dns = dpkt.dns.DNS(
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
)
dns.op = dpkt.dns.DNS_QR | dpkt.dns.DNS_AA
dns.rcode = dpkt.dns.DNS_RCODE_NOERR
arr = dpkt.dns.DNS.RR()
arr.cls = dpkt.dns.DNS_IN
arr.type = dpkt.dns.DNS_A
arr.name = tester_host
arr.ip = socket.inet_aton('127.0.0.1')
dns.an.append(arr)
print('Created answer to mdns query: {} '.format(dns.__repr__()))
return dns.pack()
def get_dns_answer_to_mdns_lwip(tester_host, id):
dns = dpkt.dns.DNS(
b'\x5e\x39\x84\x00\x00\x01\x00\x01\x00\x00\x00\x00\x0a\x64\x61\x76\x69\x64'
b'\x2d\x63\x6f\x6d\x70\x05\x6c\x6f\x63\x61\x6c\x00\x00\x01\x00\x01\xc0\x0c'
b'\x00\x01\x00\x01\x00\x00\x00\x0a\x00\x04\xc0\xa8\x0a\x6c')
dns.qd[0].name = tester_host
dns.an[0].name = tester_host
dns.an[0].ip = socket.inet_aton('127.0.0.1')
dns.an[0].rdata = socket.inet_aton('127.0.0.1')
dns.id = id
print('Created answer to mdns (lwip) query: {} '.format(dns.__repr__()))
return dns.pack()
def mdns_server(esp_host, events):
UDP_IP = '0.0.0.0'
UDP_PORT = 5353
MCAST_GRP = '224.0.0.251'
TESTER_NAME = u'tinytester.local'
TESTER_NAME_LWIP = u'tinytester-lwip.local'
QUERY_TIMEOUT = 0.2
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
sock.setblocking(False)
sock.bind((UDP_IP, UDP_PORT))
mreq = struct.pack('4sl', socket.inet_aton(MCAST_GRP), socket.INADDR_ANY)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
last_query_timepoint = time.time()
while not events['stop'].is_set():
try:
current_time = time.time()
if current_time - last_query_timepoint > QUERY_TIMEOUT:
last_query_timepoint = current_time
if not events['esp_answered'].is_set():
sock.sendto(get_dns_query_for_esp(esp_host),
(MCAST_GRP, UDP_PORT))
if not events['esp_delegated_answered'].is_set():
sock.sendto(get_dns_query_for_esp(esp_host + '-delegated'),
(MCAST_GRP, UDP_PORT))
timeout = max(
0, QUERY_TIMEOUT - (current_time - last_query_timepoint))
read_socks, _, _ = select.select([sock], [], [], timeout)
if not read_socks:
continue
data, addr = sock.recvfrom(1024)
dns = dpkt.dns.DNS(data)
if len(dns.qd) > 0:
for dns_query in dns.qd:
if dns_query.type == dpkt.dns.DNS_A:
if dns_query.name == TESTER_NAME:
print('Received query: {} '.format(dns.__repr__()))
sock.sendto(get_dns_answer_to_mdns(TESTER_NAME),
(MCAST_GRP, UDP_PORT))
elif dns_query.name == TESTER_NAME_LWIP:
print('Received query: {} '.format(dns.__repr__()))
sock.sendto(
get_dns_answer_to_mdns_lwip(TESTER_NAME_LWIP, dns.id),
addr)
if len(dns.an) > 0:
for dns_answer in dns.an:
if dns_answer.type == dpkt.dns.DNS_A:
print('Received answer from {}'.format(dns_answer.name))
if dns_answer.name == esp_host + u'.local':
print('Received answer to esp32-mdns query: {}'.format(
dns.__repr__()))
events['esp_answered'].set()
if dns_answer.name == esp_host + u'-delegated.local':
print('Received answer to esp32-mdns-delegate query: {}'.format(
dns.__repr__()))
events['esp_delegated_answered'].set()
except socket.timeout:
break
except dpkt.UnpackError:
continue
def test_examples_protocol_mdns(dut):
"""
steps: |
1. obtain IP address + init mdns example
2. get the dut host name (and IP address)
3. check the mdns name is accessible
4. check DUT output if mdns advertized host is resolved
5. check if DUT responds to dig
6. check the DUT is searchable via reverse IP lookup
"""
specific_host = dut.expect(r'mdns hostname set to: \[(.*?)\]')[1].decode()
mdns_server_events = {
'stop': Event(),
'esp_answered': Event(),
'esp_delegated_answered': Event()
}
mdns_responder = Thread(target=mdns_server,
args=(str(specific_host), mdns_server_events))
ip_addresses = []
if dut.app.sdkconfig.get('LWIP_IPV4') is True:
ipv4 = dut.expect(r'IPv4 address: (\d+\.\d+\.\d+\.\d+)[^\d]',
timeout=30)[1].decode()
ip_addresses.append(ipv4)
if dut.app.sdkconfig.get('LWIP_IPV6') is True:
ipv6_r = r':'.join((r'[0-9a-fA-F]{4}', ) * 8)
ipv6 = dut.expect(ipv6_r, timeout=30)[0].decode()
ip_addresses.append(ipv6)
print('Connected with IP addresses: {}'.format(','.join(ip_addresses)))
try:
# TODO: Add test for example disabling IPV4
mdns_responder.start()
if dut.app.sdkconfig.get('LWIP_IPV4') is True:
# 3. check the mdns name is accessible.
if not mdns_server_events['esp_answered'].wait(timeout=30):
raise ValueError(
'Test has failed: did not receive mdns answer within timeout')
if not mdns_server_events['esp_delegated_answered'].wait(timeout=30):
raise ValueError(
'Test has failed: did not receive mdns answer for delegated host within timeout'
)
# 4. check DUT output if mdns advertized host is resolved
dut.expect(
re.compile(
b'mdns-test: Query A: tinytester.local resolved to: 127.0.0.1')
)
dut.expect(
re.compile(
b'mdns-test: gethostbyname: tinytester-lwip.local resolved to: 127.0.0.1'
))
dut.expect(
re.compile(
b'mdns-test: getaddrinfo: tinytester-lwip.local resolved to: 127.0.0.1'
))
# 5. check the DUT answers to one-shot mDNS query (replaces dig)
dig_output = run_one_shot_query(
'{}.local'.format(specific_host), qtype='A'
)
print('Resolving {} using one-shot query succeeded with:\n{}'.format(
specific_host, dig_output))
if not ipv4.encode('utf-8') in dig_output:
raise ValueError(
'Test has failed: Incorrectly resolved DUT hostname using dig'
"Output should've contained DUT's IP address:{}".format(ipv4))
# 6. check the DUT reverse lookup
if dut.app.sdkconfig.get('MDNS_RESPOND_REVERSE_QUERIES') is True:
for ip_address in ip_addresses:
reverse_name = _ip_to_reverse_name(ip_address)
dig_output = run_one_shot_query(
reverse_name, qtype='PTR'
)
print('Reverse lookup for {} using one-shot query succeeded with:\n{}'.
format(ip_address, dig_output))
if specific_host not in dig_output.decode():
raise ValueError(
'Test has failed: Incorrectly resolved DUT IP address using dig'
"Output should've contained DUT's name:{}".format(
specific_host))
finally:
mdns_server_events['stop'].set()
mdns_responder.join()