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>
This commit is contained in:
1 parent
47f4eba0d6
commit
4cd3bc7973
294 files changed
+48954
-301
No files matched your search
@@ -0,0 +1,341 @@
|
||||
# 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()
|
||||
Reference in new issue
Block a user