Automated Calibration & Optimization

% MATLAB + CANape COM API: automated calibration with fmincon optimizer

% Connect to CANape
canape = actxserver('CANape.Application');
device = canape.Devices.Item('ECU_Engine');
device.Open();

% Objective function: minimise HC_ppm at operating point
% x = [egr_pct, inj_timing_offset_deg]
function J = objective(x, canape, device)
    % Write parameters to ECU
    device.Variables.Item('EGR_MAX_PCT').SetValue(x(1));
    device.Variables.Item('IGN_TIMING_OFFSET').SetValue(x(2));
    
    pause(3.0);  % wait for ECU to reach steady state
    
    % Measure response
    HC  = device.Variables.Item('HC_ppm').GetValue();
    NOx = device.Variables.Item('NOx_ppm').GetValue();
    fuel = device.Variables.Item('fuel_cons_l100km').GetValue();
    
    % Weighted objective (minimise)
    J = 0.5*HC/150 + 0.3*NOx/60 + 0.2*fuel/5.0;
end

% Run optimisation
x0     = [25.0, 0.0];   % initial: EGR=25%, timing offset=0
lb     = [0.0, -5.0];   % lower bounds
ub     = [40.0, 5.0];   % upper bounds
options = optimoptions('fmincon','Display','iter','MaxIter',50);
x_opt  = fmincon(@(x) objective(x, canape, device), x0, [],[],[],[],lb,ub,[],options);

fprintf('Optimal: EGR=%.1f%%, timing_offset=%.1f deg\n', x_opt(1), x_opt(2));
device.Close();

# Automated EVC offset sweep with stability constraint
import canape_com as canape, time, numpy as np

device = canape.OpenDevice("ECU_Engine")
device.Connect()

best_hc = float('inf'); best_evc = 0
for evc in range(0, 20, 2):  # sweep 0 to 18 CAD in 2-step increments
    device.SetValue("EVC_offset", float(evc))
    time.sleep(5.0)  # settle
    hc = device.MeasureAverage("HC_ppm", seconds=3)
    roughness = device.MeasureStdDev("engine_torque_Nm", seconds=3)
    print(f"EVC={evc:2d} CAD: HC={hc:.0f} ppm, roughness={roughness:.3f} Nm")
    if roughness < 0.50 and hc < best_hc:  # constraint check
        best_hc = hc; best_evc = evc

print(f"Optimal EVC_offset = {best_evc} CAD → HC = {best_hc:.0f} ppm")
device.SetValue("EVC_offset", float(best_evc))
device.CopyCalPage(src=0, dst=1)  # save to Flash

#!/usr/bin/env python3
# Overnight OBD-cycle automated calibration: unattended WLTP run + map update

import inca_automation as inca_auto, time, json, datetime

def run_wltp_cycle(inca_auto):
    # Send WLTP speed profile to dyno controller
    inca_auto.dyno.LoadCycle("WLTP_Class3.csv")
    inca_auto.inca.StartRecording(f"wltp_run_{datetime.datetime.now():%Y%m%d_%H%M}.mf4")
    inca_auto.dyno.StartCycle()
    inca_auto.dyno.WaitForCycleComplete(timeout_s=2000)
    inca_auto.inca.StopRecording()
    return inca_auto.inca.GetLastRecordingPath()

def evaluate_emissions(mf4_path):
    rec = inca_auto.mda.Load(mf4_path)
    return {
        "NOx_mg_km": rec.IntegrateOverCycle("NOx_ppm") / 1000,
        "HC_mg_km":  rec.IntegrateOverCycle("HC_ppm") / 1000,
        "fuel_l100": rec.CalculateFuelConsumption(),
    }

# Main overnight loop
inca_auto.inca.Connect()
for iteration in range(20):  # max 20 iterations
    mf4 = run_wltp_cycle(inca_auto)
    results = evaluate_emissions(mf4)
    print(f"Iter {iteration}: NOx={results['NOx_mg_km']:.1f} mg/km, "
          f"HC={results['HC_mg_km']:.1f} mg/km, fuel={results['fuel_l100']:.2f} L/100km")

    if results['NOx_mg_km'] < 60 and results['HC_mg_km'] < 100:
        print("OBD targets met — stopping optimisation")
        break

    # Update injection timing map (gradient step toward lower NOx)
    inca_auto.inca.optimizer.StepGradient("injection_timing_MAP",
                                          objective="NOx_mg_km",
                                          step_size=0.5)  # 0.5 degree per iteration

inca_auto.inca.Disconnect()