Hands-On: Multi-ECU HIL Configuration

#!/usr/bin/env python3
# Configure multi-ECU HIL network using Vector CANoe Python API
# Three ECUs: ADAS Controller, Brake ECU, Gateway

import win32com.client as win32

def configure_multi_ecu_network(dbc_files):
    canoe = win32.Dispatch("CANoe.Application")

    # Load network databases
    for dbc in dbc_files:
        canoe.Configuration.Networks[0].Databases.Add(dbc)

    # Configure rest-bus: simulate absent nodes
    # All nodes except ADAS, Brake ECU, Gateway are simulated
    absent_nodes = [
        "InstrumentCluster",
        "BodyControlModule",
        "TransmissionECU",
        "SteeringAngleSensor",
    ]
    for node in absent_nodes:
        canoe.Configuration.SimulationSetup.SimulatedNodes.Add(node)

    # Set up measurement variables for cross-ECU monitoring
    signals = [
        ("AEB_Request",     "ADAS_to_Brake",  "CAN_FD_1"),
        ("Brake_Pressure",  "Brake_Status",   "CAN_HS_1"),
        ("ABS_Active",      "Brake_Status",   "CAN_HS_1"),
        ("Vehicle_Speed",   "BCM_Status",     "CAN_HS_1"),
    ]
    for sig, msg, bus in signals:
        canoe.Measurement.Signals.Add(bus, msg, sig)

    print(f"Configured {len(absent_nodes)} simulated nodes")
    print(f"Monitoring {len(signals)} cross-ECU signals")

#!/usr/bin/env python3
# Test: ADAS ECU loses radar; verify Brake ECU enters correct fallback

import time

class CrossEcuFaultTest:
    def __init__(self, hil, canoe):
        self.hil   = hil    # HIL plant model control
        self.canoe = canoe  # bus monitoring

    def run(self):
        print("Test: ADAS radar loss -> Brake ECU fallback")

        # Step 1: establish steady-state at 100 km/h
        self.hil.set("Plant/Speed_kph", 100.0)
        self.hil.set("Plant/RadarActive", 1.0)
        time.sleep(5)

        # Step 2: inject radar CAN timeout (stop sending radar messages)
        print("  Injecting radar CAN silence...")
        self.hil.set("FaultInjection/RadarCanSilence", 1.0)
        t_inject = time.time()

        # Step 3: monitor ADAS for AEB inhibit signal
        deadline_ms = 200  # ADAS must inhibit AEB within 200 ms
        aeb_inhibited = False
        while (time.time() - t_inject) * 1000 < deadline_ms + 50:
            aeb_allowed = self.canoe.get_signal("AEB_Request_Allowed")
            if aeb_allowed < 0.5:
                t_detect = (time.time() - t_inject) * 1000
                print(f"  ADAS inhibited AEB at {t_detect:.1f} ms")
                aeb_inhibited = True
                break
            time.sleep(0.01)

        # Step 4: verify Brake ECU received inhibit and deactivated AEB
        brake_aeb_active = self.canoe.get_signal("Brake_AEB_Active")
        result = aeb_inhibited and brake_aeb_active < 0.5
        print(f"  Result: {"PASS" if result else "FAIL"}")
        return result