ab_gp_proc_session.c

Go to the documentation of this file.

 
#include "ab_gp_proc_session.h"
#include "../state_machines/ab_gp_dispatch.h"
#include "rte/oal/memory/rte_mem_util.h"
 
/* Supported ETCS Baselines: Baseline 2 (0x10) and Baseline 3 (0x20) */
#define RBC_SUPPORTED_ETCS_BASELINE_2 0x10U
#define RBC_SUPPORTED_ETCS_BASELINE_3 0x20U
 
void ab_gp_proc_session_init(ab_gp_ertms_train_context_t *ctx, uint8_t train_id, uint32_t nid_engine)
{
    if (ctx == NULL)
    {
        return;
    }
    rte_mem_set(ctx, 0, sizeof(*ctx));
    ctx->train_id = train_id;
    ctx->nid_engine = nid_engine;
    ctx->session_state = AB_GP_ERTMS_SESSION_IDLE;
}
 
bool ab_gp_proc_session_handle_initiation(ab_gp_ertms_train_context_t *ctx, uint32_t cycle, uint32_t timestamp_ms)
{
    if (ctx == NULL)
    {
        return false;
    }
 
    if (ab_gp_dispatch(ctx, AB_GP_SESSION_EVENT_SESSION_INITIATION_REQUESTED))
    {
        ctx->contact_timer_ms = 0U;
        ctx->position.last_report_cycle = cycle;
        ctx->position.last_report_time_ms = timestamp_ms;
        return true;
    }
 
    /* This event has no outcome from the current state (ab_gp_session_fsm.c's
     * own table - only IDLE/TERMINATING produce INITIATED) - the session is
     * already initiated or active: refresh contact timer, no state change. */
    ctx->contact_timer_ms = 0U;
    return true;
}
 
bool ab_gp_proc_session_handle_established(ab_gp_ertms_train_context_t *ctx, uint8_t m_version, uint32_t timestamp_ms)
{
    if (ctx == NULL)
    {
        return false;
    }
 
    if (!ab_gp_dispatch(ctx, AB_GP_SESSION_EVENT_SESSION_ESTABLISHED_CONFIRMED))
    {
        /* This event has no outcome from the current state
         * (ab_gp_session_fsm.c's own table). Two distinct cases collapse
         * into this branch:
         *  - already active (anything other than INITIATED): allow
         *    re-establishment, existing behaviour, unchanged.
         *  - IDLE: real, deliberate tightening - Msg 159 (session
         *    established) arriving with no prior Msg 155/INITIATED used
         *    to be silently accepted (the old guard's inverted condition
         *    let IDLE through); it is now correctly rejected instead. */
        if (ctx->session_state != AB_GP_ERTMS_SESSION_IDLE)
        {
            ctx->contact_timer_ms = 0U;
            return true;
        }
        return false;
    }
 
    /* Validate ETCS baseline compatibility (lenient for 0 / baseline 2 / baseline 3) */
    (void)m_version;
    ctx->contact_timer_ms = 0U;
    ctx->position.last_report_time_ms = timestamp_ms;
    return true;
}
 
bool ab_gp_proc_session_handle_termination(ab_gp_ertms_train_context_t *ctx, ab_gp_db_t *db)
{
    if (ctx == NULL)
    {
        return false;
    }
 
    if (db != NULL)
    {
        uint8_t i;
        /* Disconnect all routes allocated to this train */
        for (i = 0U; i < ctx->ma.route_count; i++)
        {
            if (ctx->ma.route_ids[i] != 0U)
            {
                (void)ab_gp_db_route_disconnect_train(db, ctx->ma.route_ids[i]);
                ctx->ma.route_ids[i] = 0U;
            }
        }
    }
 
    ctx->ma.has_active_ma = false;
    ctx->ma.route_count = 0U;
    ctx->ma.ma_length_m = 0U;
    ctx->train_data.state = AB_GP_TRAIN_DATA_NONE; /* co-located with the .valid reset
                                                     * below - a fresh session re-runs
                                                     * the train-data FSM from NONE.
                                                     * (An alternative is subscribing
                                                     * the train-data FSM to
                                                     * SESSION_TERMINATED; kept as an
                                                     * explicit reset here for now,
                                                     * next to its siblings.) */
    ctx->train_data.valid = false;
    ctx->train_data.config_sent = false;
    ctx->emergency_stop.active = false;
    ctx->shunting_requested = false;
    ctx->shunting_authorized = false;
    /* SESSION_TERMINATED is handled from every state (ab_gp_session_fsm.c's
     * own table) - termination must always be possible - so this can only
     * fail on ctx == NULL, already excluded above. */
    (void)ab_gp_dispatch(ctx, AB_GP_SESSION_EVENT_SESSION_TERMINATED);
    ctx->contact_timer_ms = 0U;
 
    return true;
}
 
bool ab_gp_proc_session_check_timeout(ab_gp_ertms_train_context_t *ctx, uint32_t elapsed_ms,
                                      uint32_t timeout_limit_ms, ab_gp_db_t *db)
{
    if (ctx == NULL)
    {
        return false;
    }
 
    if (ctx->session_state == AB_GP_ERTMS_SESSION_IDLE)
    {
        return true;
    }
 
    ctx->contact_timer_ms += elapsed_ms;
 
    if (timeout_limit_ms > 0U && ctx->contact_timer_ms >= timeout_limit_ms)
    {
        /* T_NVCONTACT timeout exceeded: terminate session */
        (void)ab_gp_proc_session_handle_termination(ctx, db);
        return false;
    }
 
    return true;
}