Boost-Pressure
Control Model

/* boost_params.h — one parameter set (mirrors matlab/params.m).
 * Controller executes at Ts = 0.01 s (100 Hz). */
#define TS          0.01F    /* sample time [s] */

/* plant — MIL simulation stand-in, NOT code-generated */
#define TAU         0.30F    /* air-path time constant [s] */
#define K_ACT       180.0F   /* actuator effectiveness [kPa/unit] */
#define P_AMB       100.0F   /* ambient / baseline pressure [kPa] */

/* PI controller + back-calculation anti-windup */
#define KP          0.010F   /* proportional gain [1/kPa] */
#define KI          0.050F   /* integral gain [1/(kPa*s)] */
#define KAW         2.0F     /* anti-windup gain */
#define DU_MAX      0.05F    /* max actuator step / sample */
#define U_MIN       0.0F
#define U_MAX       1.0F

/* open-loop actuator value per mode */
#define U_OFF       0.0F
#define U_CRANK     0.3F
#define U_SAFE      0.3F     /* FAULT limp */
#define N_CRANK     600.0F   /* rpm to permit RUN */

/* sensor rationality */
#define P_MIN       90.0F
#define P_MAX       350.0F
#define DP_MAX      60.0F    /* max plausible step [kPa] */
#define T_DEBOUNCE  0.05F    /* fault/recovery debounce [s] */

/* setpoint-map bounds (p_max set by drive mode) */
#define PREF_MIN    110.0F
#define PREF_MAX    275.0F   /* RACE ceiling; <= P_AMB + K_ACT */
#define N_REF_MAX   4000.0F  /* map speed normaliser [rpm] */

/* turbo authority (lag):
 *   K_eff = K_ACT*(A_MIN + (1-A_MIN)*min(n/N_SPOOL,1)) */
#define N_SPOOL     2200.0F
#define A_MIN       0.35F

/* drive-mode presets (HMI):  pref_max / rev-limit / top speed
 *   ECO   : 200 kPa | 4000 rpm | 150 km/h
 *   SPORT : 250 kPa | 5000 rpm | 205 km/h
 *   RACE  : 275 kPa | 6000 rpm | 255 km/h */

/* boost_controller_step — discrete PI + feed-forward + back-calc anti-windup.
 * Executed at Ts = 0.01 s. Closed loop active only in RUN mode. */
void boost_controller_step(const BoostCtrlIn *const in,
                           BoostCtrlOut *const out)
{
    static real32_T integ = 0.0F;          /* integrator state */
    const real32_T u_ff = (in->p_ref - P_AMB) / K_ACT;

    /* sensor rationality: range + rate, result drives the supervisor */
    boolean_T range_bad = (in->p_meas < P_MIN) || (in->p_meas > P_MAX);
    boolean_T rate_bad  = fabsf(in->p_meas - in->p_meas_prev) > DP_MAX;
    out->fault_code = (uint8_T)range_bad | ((uint8_T)rate_bad << 1);

    if (in->mode == MODE_RUN) {
        real32_T e       = in->p_ref - in->p_meas;
        real32_T u_unsat = u_ff + (KP * e) + integ;

        /* rate limit around the feed-forward operating point */
        real32_T du      = u_unsat - u_ff;
        du = (du > DU_MAX) ? DU_MAX : ((du < -DU_MAX) ? -DU_MAX : du);
        real32_T u_rl    = u_ff + du;

        /* saturate to actuator limits */
        out->u_act = (u_rl > U_MAX) ? U_MAX : ((u_rl < U_MIN) ? U_MIN : u_rl);

        /* back-calculation anti-windup (REQ-BP-004) */
        integ += TS * ((KI * e) + (KAW * (out->u_act - u_unsat)));
    } else {
        out->u_act = u_ff;   /* open-loop modes; supervisor sets actual command */
        integ      = 0.0F;  /* seed for bumpless transfer into RUN */
    }
}

/* boost_supervisor_step — INIT->OFF->CRANK->RUN->FAULT (Stateflow).
 * Closed loop runs only in RUN (REQ-BP-010); Ts = 0.01 s. */
void boost_supervisor_step(const SupIn *const in, SupState *const s)
{
    /* debounce sensor health before latching (REQ-BP-003) */
    if (in->sensor_bad) { s->db_fault += TS; s->db_valid = 0.0F; }
    else               { s->db_valid += TS; s->db_fault = 0.0F; }
    boolean_T s_fault = (s->db_fault >= T_DEBOUNCE);
    boolean_T s_valid = (s->db_valid >= T_DEBOUNCE);

    switch (s->mode) {
    case MODE_INIT:
        s->integ_reset = true; s->mode = MODE_OFF;        /* REQ-BP-009 */
        break;
    case MODE_OFF:
        if (in->key_on && in->rpm > 0.0F) s->mode = MODE_CRANK;
        break;
    case MODE_CRANK:
        if (!in->key_on || in->rpm <= 0.0F) s->mode = MODE_OFF;
        else if (in->rpm >= N_CRANK && !s_fault) {
            s->mode = MODE_RUN; s->integ_reset = true;     /* bumpless */
        }
        break;
    case MODE_RUN:
        if (!in->key_on || in->rpm <= 0.0F) s->mode = MODE_OFF;
        else if (s_fault)                  s->mode = MODE_FAULT; /* latched */
        break;
    case MODE_FAULT:
        if (!in->key_on || in->rpm <= 0.0F) s->mode = MODE_OFF;
        else if (s_valid) {                              /* REQ-BP-011 */
            s->mode = MODE_RUN; s->integ_reset = true;
        }
        break;
    default: s->mode = MODE_INIT; break;
    }
}

/* boost_controller_types.h — I/O contract (REQ-BP-005). */
typedef enum { MODE_INIT = 0, MODE_OFF, MODE_CRANK,
               MODE_RUN,  MODE_FAULT } BoostMode;   /* 0 … 4 */

typedef enum { DRIVE_ECO = 0, DRIVE_SPORT,
               DRIVE_RACE } DriveMode;

typedef struct {
    real32_T  p_meas;        /* measured boost [kPa] 90 … 350 */
    real32_T  p_meas_prev;   /* previous sample (rate check) */
    real32_T  p_ref;         /* target from setpoint map */
    real32_T  engine_speed;  /* [rpm] 0 … 6000 */
    real32_T  torque_demand; /* [%]   0 … 100 */
    boolean_T key_on;        /* ignition / run request */
    DriveMode drive_mode;    /* ECO / SPORT / RACE */
    BoostMode mode;          /* supervisor state (gates loop) */
} BoostCtrlIn;

typedef struct {
    real32_T  u_act;         /* actuator cmd 0 … 1 (VGT/wastegate) */
    BoostMode mode;          /* current supervisor mode */
    uint8_T   fault_code;    /* 0 = OK; bit0 range, bit1 rate */
} BoostCtrlOut;