Diagnostic Message Handling

import socket, struct, time

class DoipUdsClient:
    def __init__(self, ecu_ip: str, tester_la: int = 0xE000, ecu_la: int = 0x0001):
        self.ecu_ip   = ecu_ip
        self.tester_la = tester_la
        self.ecu_la   = ecu_la
        self.sock     = None

    def connect(self) -> bool:
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.settimeout(5.0)
        try:
            self.sock.connect((self.ecu_ip, 13400))
        except ConnectionRefusedError:
            return False

        # Send RoutingActivationRequest
        payload = struct.pack(">HBI", self.tester_la, 0x00, 0)
        hdr     = struct.pack(">BBHI", 0x02, 0xFD, 0x0005, len(payload))
        self.sock.sendall(hdr + payload)

        resp = self.sock.recv(256)
        if len(resp) < 9: return False
        act_code = resp[8]   # 0x10 = routing activation accepted
        return act_code == 0x10

    def send_uds(self, uds_data: bytes) -> bytes:
        payload = struct.pack(">HH", self.tester_la, self.ecu_la) + uds_data
        hdr     = struct.pack(">BBHI", 0x02, 0xFD, 0x8001, len(payload))
        self.sock.sendall(hdr + payload)
        # Wait for DiagnosticMessage response (skip ACK 0x8002)
        while True:
            resp = self.sock.recv(65536)
            ptype = struct.unpack(">H", resp[2:4])[0]
            if ptype == 0x8001:   # DiagnosticMessage (actual UDS response)
                return resp[12:]  # skip 8-byte DoIP header + 4-byte SA/TA
            # else: 0x8002 ACK — ignore, wait for next

    def send_tester_present(self):
        uds_tp = bytes([0x3E, 0x80])   # TesterPresent suppressPosRspMsgIndicationBit
        self.send_uds(uds_tp)

# Usage:
# client = DoipUdsClient("169.254.1.100")
# client.connect()
# vin_resp = client.send_uds(bytes([0x22, 0xF1, 0x90]))  # Read VIN

import threading, socket

# Parallel DoIP sessions: connect to multiple ECUs simultaneously
# One TCP connection per ECU; run diagnostic in parallel threads

ECU_LIST = [
    {"name": "Engine",      "ip": "169.254.20.10", "la": 0x0010},
    {"name": "Transmission","ip": "169.254.20.11", "la": 0x0011},
    {"name": "Brake",       "ip": "169.254.10.20", "la": 0x0020},
    {"name": "Steering",    "ip": "169.254.10.21", "la": 0x0021},
]

results = {}
lock = threading.Lock()

def flash_ecu(ecu: dict):
    client = DoipUdsClient(ecu["ip"], ecu_la=ecu["la"])
    if not client.connect():
        with lock: results[ecu["name"]] = "CONNECT_FAILED"
        return
    # Start programming session, flash, verify...
    sw_version = client.send_uds(bytes([0x22, 0xF1, 0x89]))  # Read SW version
    with lock:
        results[ecu["name"]] = sw_version.hex()

# Start all ECUs simultaneously
threads = [threading.Thread(target=flash_ecu, args=(e,)) for e in ECU_LIST]
for t in threads: t.start()
for t in threads: t.join()

print("Results:", results)
# Total flash time ≈ single ECU time (all in parallel)
# vs CAN sequential: 4× single ECU time