AEB Test Bench for Euro NCAP Scenarios

Introduction

AEB is an advanced active safety system that helps drivers avoid or mitigate collisions with other vehicles.

The Euro NCAP is a popular car safety performance assessment program that provides an independent evaluation of the safety level for vehicles, including assessments of AEB systems. You can evaluate how effectively an AEB system prevents or mitigates collisions with other vehicles using AEB test scenarios designed per Euro NCAP. These evaluation results contribute to overall vehicle safety ratings and provide consumers with important details on AEB performance.

This example shows how to set up the AEB test bench model and simulate Safety Assist (SA) AEB Car-to-Car scenarios. To verify collision between vehicles, you can disable the AEB system. You can also enable it to verify the effectiveness of collision avoidance. In this example, you:

Set Up Environment

This section shows how to set up the test environment and how to open the project for the AEB test bench model.

Start RoadRunner interactively using the roadrunnerSetup function. In the RoadRunner Setup dialog box, specify the RoadRunner Installation Folder and RoadRunner Project Folder locations. You must use a RoadRunner Project created with Assets set to Base + Add On because this example uses assets from RoadRunner Asset Library.

rrApp = roadrunnerSetup;

The function returns a roadrunner object, rrApp, that provides functions for performing basic tasks such as opening, closing, and saving scenes and projects. After setting up the required paths, close RoadRunner. The subsequent steps in this example use rrApp, and assume the RoadRunner application is closed.

close(rrApp)

The helperSetupEuroNCAPTest helper function initializes the RoadRunner application and establishes a connection with MATLAB. It also opens the project that contains the AEB test bench, copies the required behavior and asset files into the RoadRunner project, and adds the paths needed to execute the subsequent steps.

helperSetupEuroNCAPTest

Explore Test Bench Model

In this example, you use DrivingTestBench.slx to simulate and test the performance of the AEB controller.

Open the AEB test bench model.

modelName = "DrivingTestBench";
open_system(modelName)

The test bench model contains these modules:

The Controller reference model accepts inputs such as set velocity, reference pose, current pose, tracks, and curvature deviation from the Scenario and Environment subsystem. It computes the steering angle and acceleration of the ego vehicle, and provides them as outputs to the Vehicle Dynamics subsystem.

Open the Controller reference model.

open_system("Controller")

The controller contains these modules:

The Vehicle Dynamics subsystem incorporates two distinct vehicle models, namely 3DOF and 14DOF, to dynamically update the state of the ego vehicle based on the inputs from the AEB Controller. Open the Vehicle Dynamics subsystem.

open_system(modelName + "/Vehicle Dynamics/Vehicle Dynamics")

The 3DOF bicycle model block implements a rigid two-axle single track vehicle body model to calculate the longitudinal, lateral, and yaw motion. The block also calculates the body mass, aerodynamic drag, and weight distribution between the axles due to acceleration and steering. For more information, see Bicycle Model. Open the 3DOF variant,

open_system(modelName+"/Vehicle Dynamics/Vehicle Dynamics/3DOF")

As compared to 3DOF variant, the 14DOF variant offers additional simulation aspects such as transmission dynamics, tire interactions, load shifting, braking behavior, and the vehicle's powertrain response. For more details on vehicle dynamics models, see Passenger Vehicle Dynamics Models (Vehicle Dynamics Blockset). Open 14DOF reference model,

open_system("VehDyn14DOF")

The Scenario and Environment subsystem has interfaces to interact with RoadRunner Scenario, enabling the test bench to cosimulate the AEB application with RoadRunner Scenario. It specifies sensors, reference path information of the ego vehicle, and control signals to enable AEB testing. Open the Scenario and Environment subsystem.

open_system(modelName + "/Scenario and Environment")

The Scenario and Environment subsystem contains these modules:

Note that, based on the requirements of your controller, you can extract additional signals from the Scenario and Environment subsystem and input them into the Controller reference model.

Generate and Review Scenario

In this section, you generate an SA AEB CCRm test scenario per Euro NCAP protocol. The Euro NCAP specification refers to the ego vehicle as the vehicle under test (VUT) and the target vehicle as a global vehicle target (GVT). In the SA AEB CCRm scenario, the VUT travels forward toward the GVT, which is traveling at a constant speed, causing a collision in which the front side of the VUT strikes the rear side of the GVT. You can generate 55 variant scenarios for this scenario per Euro NCAP protocol by varying the VUT speed and the impact overlap between the GVT and VUT.

Specify the NCAP test name.

testName = "SA AEB CCRm";

Get the Euro NCAP test specifications by using the ncapSpec function.

ncapSpecTable = ncapSpec(testName);

Display the Euro NCAP variations for the SA AEB CCRm test scenario.

disp(ncapSpecTable)

    EgoSpeed    ImpactOverlap
    ________    _____________

     8.3333        "-50%"    
     8.3333        "-75%"    
     8.3333        "100%"    
     8.3333        "50%"     
     8.3333        "75%"     
     9.7222        "-50%"    
     9.7222        "-75%"    
     9.7222        "100%"    
     9.7222        "50%"     
     9.7222        "75%"     
     11.111        "-50%"    
     11.111        "-75%"    
     11.111        "100%"    
     11.111        "50%"     
     11.111        "75%"     
       12.5        "-50%"    
       12.5        "-75%"    
       12.5        "100%"    
       12.5        "50%"     
       12.5        "75%"     
     13.889        "-50%"    
     13.889        "-75%"    
     13.889        "100%"    
     13.889        "50%"     
     13.889        "75%"     
     15.278        "-50%"    
     15.278        "-75%"    
     15.278        "100%"    
     15.278        "50%"     
     15.278        "75%"     
     16.667        "-50%"    
     16.667        "-75%"    
     16.667        "100%"    
     16.667        "50%"     
     16.667        "75%"     
     18.056        "-50%"    
     18.056        "-75%"    
     18.056        "100%"    
     18.056        "50%"     
     18.056        "75%"     
     19.444        "-50%"    
     19.444        "-75%"    
     19.444        "100%"    
     19.444        "50%"     
     19.444        "75%"     
     20.833        "-50%"    
     20.833        "-75%"    
     20.833        "100%"    
     20.833        "50%"     
     20.833        "75%"     
     22.222        "-50%"    
     22.222        "-75%"    
     22.222        "100%"    
     22.222        "50%"     
     22.222        "75%"     

This example uses a variant of the SA AEB CCRm scenario with an ego speed of 65 km/h and impact overlap of 75%.

egoSpeed = 18.056; % ego speed in meters per second
impactOverlap = "75%";

To generate a variant scenario, get the index of the required variant scenario using the EgoSpeed and ImpactOverlap parameters from ncapSpecTable.

egoSpeedIndices = (find(abs(ncapSpecTable{:,1}-egoSpeed) < 1e-2));
impactOverlapIndex = find(ncapSpecTable{egoSpeedIndices,2} == impactOverlap);
variantIndex = egoSpeedIndices(impactOverlapIndex);
disp(variantIndex)

    40

Specify the asset file for the ego vehicle. Then, connect to RoadRunner to get the dimensions of the ego vehicle by using the helperGetActorDimensions helper function.

egoAssetFile = "Vehicles/ADT Vehicles/SK_Sedan.fbx_rrx";
egoAssetDim = helperGetActorDimensions(egoAssetFile);

Create the Euro NCAP scenario variant using the helperCreateEuroNCAPscenario helper function. This function connects with RoadRunner to create and save the scenario. The helper function returns the saved scenario filename rrScenarioFileName and the associated test information testData.

[rrScenarioFileName,testData] = helperCreateEuroNCAPscenario(testName,variantIndex,egoAssetDim,egoAssetFile);

Generating seed scenario for SA AEB CCRm ...
Generating Euro NCAP scenario descriptors for SA AEB CCRm, variant 40...
Saved SA_AEB_CCRm_40 scene and scenario.

Open RoadRunner and the generated scenario variant.

rrApp = roadrunner;
openScenario(rrApp,rrScenarioFileName)

Note that this example saves a scenario that includes behaviors for the ego and target vehicles.

The ego vehicle has the DrivingTestBench.rrbehavior.rrmeta behavior, which contains the Simulink behavior DrivingTestBench.slx. In this example, the ego vehicle must start from rest and attain a constant speed to meet the test conditions per Euro NCAP protocol. The target vehicle has the MATLAB behavior Target.rrbehavior, which contains the TargetBehavior.m MATLAB System object™. The target vehicle continuously monitors the ego vehicle speed to adjust its timing to ensure a collision with the ego vehicle.

Disable AEB and Verify Collision

In this section, you configure the test bench model to disable AEB, simulate the SA AEB CCRm scenario using RoadRunner, observe the collision, and review if the collision occurred at the specified impact overlap.

Connect to the RoadRunner Scenario server for cosimulation using the createSimulation function, enable data logging, turn off simulation pacing, and set the maximum simulation time.

rrSim = createSimulation(rrApp);
set(rrSim,Logging="on")
set(rrSim,PacerStatus="Off")
set(rrSim,MaxSimulationTime=testData.TestEndTime)

Set the RoadRunner Scenario simulation step size to match that of the test bench model.

stepSize = 0.03;
set(rrSim,StepSize=stepSize)

You can configure the test bench model using, the configureDrivingTestBench function, which returns a configuration object drivingConfigObj.

drivingConfigObj  = configureDrivingTestBench;

Specify the vehicle variant configuration by setting the fidelity of vehicle using the VehicleParameters method of the configuration object drivingConfigObj.

vehicleVariant = drivingConfigObj.VehicleParameters("Fidelity", "3DOF");

Apply the vehicle configuration parameters and deactivate the AEB system. Configure the test bench model by using the setup method of the configuration object drivingConfigObj. The method specifies parameters such as: AEB system status, test start time, simulation step size, and the vehicle variant.

setup(drivingConfigObj,AEBEnable=0,TestStartTime=testData.TestStartTime,StepSize=stepSize,Vehicle=vehicleVariant)
fprintf("\nConfiguration of %s has been successfully completed.\n", modelName)

Configuration of DrivingTestBench has been successfully completed.

Simulate the scenario, and fetch the simulation log.

set(rrSim,SimulationCommand="Start")
while strcmp(get(rrSim,"SimulationStatus"),"Running")
    pause(1)
end
simulationLog = get(rrSim,"SimulationLog");

Verify the occurrence of a collision between the VUT and GVT using simulation log diagnostics.

diagnostics = simulationLog.get("Diagnostics");
if(strcmp(diagnostics(end).Message, ...
        "Simulation failed: Collision occurred between Actor VUT  and Actor GVT ."))
    disp("Collision occurred between VUT And GVT.")
else
    error("Collision did not occur between VUT and GVT.")
end

Collision occurred between VUT And GVT.

To visualize the VUT and GVT actor positions at collision, first, get the scenario descriptor using the getScenarioDescriptor function. Then, plot the VUT and GVT actor positions in world coordinates using impact overlap percentage at collision event.

rrScenario.SimulatorInstance = rrApp;
rrScenario.SimulationInstance = rrSim;
rrDescriptor = getScenarioDescriptor(rrScenario,Simulator="RoadRunner");
% Get impact overlap from ncapSpecTable.
impactOverlap = ncapSpecTable(variantIndex,:).("ImpactOverlap");
hfig = helperPlotActorsAtCollision(rrDescriptor,testName,ImpactOverlapPercentage=impactOverlap);

The plot illustrates the distance between the impact overlap points of the VUT and GVT. Notice the distance is near zero, which verifies the collision fraction complies with the Euro NCAP specification.

Close figure.

close(hfig)

Delete the active RoadRunner simulation object.

delete(rrSim)
pause(5)

Enable AEB and Verify Collision Avoidance

In this section, you configure the test bench to enable the AEB system and verify its effectiveness in preventing collisions.

rrSim = createSimulation(rrApp);
set(rrSim,Logging="on")
set(rrSim,PacerStatus="Off")
set(rrSim,MaxSimulationTime=testData.TestEndTime)
setup(drivingConfigObj,AEBEnable=1,TestStartTime=testData.TestStartTime,StepSize=stepSize,Vehicle=vehicleVariant)
fprintf("\nSetup of DrivingTestBench complete.\n")

Setup of DrivingTestBench complete.

Simulate the AEB test bench model.

set(rrSim,SimulationCommand="Start")
while strcmp(get(rrSim,"SimulationStatus"),"Running")
    pause(1)
end
simulationLog = get(rrSim,"SimulationLog");

Plot the simulation results by using the helperPlotAEBResults helper function.

helperPlotAEBResults(out.logsout,rrScenarioFileName)

The simulation results contain these charts:

When the ego vehicle attains the steady-state speed, this example sets the AEB Test Enable parameter to true, indicating the start of the test. Once the test starts, the ego vehicle applies brakes based on the TTC value to avoid collision with the target vehicle.

Close the active RoadRunner Scenario instance.

close(rrApp)

Explore Further

In this example, you have configured the AEB test bench model to simulate a variant of the SA AEB CCRm scenario per Euro NCAP test protocols. You can further explore this example with other variants of the SA AEB CCRm scenario by selecting different ego speeds and impact overlap values.

You can also programmatically generate other SA AEB Car-to-Car scenarios, perform automated testing, and review the consolidated Euro NCAP report using Simulink Test. For more information, see the AEB Euro NCAP Testing with RoadRunner Scenario example.