ab_gp_ertms_engine.c

Go to the documentation of this file.

 
#include "ab_gp_ertms_engine.h"
#include "rte/oal/memory/rte_mem_util.h"
 
static ab_gp_ertms_train_context_t s_train_contexts[RTE_EXAMPLE_MAX_TRAINS];
 
void ab_gp_ertms_engine_init(ab_gp_db_t *db)
{
    uint8_t i;
 
    (void)db;
    for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
    {
        ab_gp_proc_session_init(&s_train_contexts[i], (uint8_t)(i + 1U), 0U);
        ab_gp_proc_tsr_init(&s_train_contexts[i]);
        ab_gp_proc_text_message_init(&s_train_contexts[i]);
        ab_gp_proc_handover_init(&s_train_contexts[i]);
    }
}
 
/* REQ-RBC-005: the only index into s_train_contexts[] by train_id; an out-of-range value returns NULL and never
 * indexes. The wire-supplied train_id reaching it was already range-checked, and an out-of-range one logged and
 * dropped, upstream (ab_gp_proc_dispatch_train_inbound(), ab_gp_train_apply_envelope()). */
ab_gp_ertms_train_context_t *ab_gp_ertms_engine_get_train_context(uint8_t train_id)
{
    if (train_id < 1U || train_id > (uint8_t)RTE_EXAMPLE_MAX_TRAINS)
    {
        return NULL;
    }
    return &s_train_contexts[train_id - 1U];
}
 
void ab_gp_ertms_engine_step(ab_gp_db_t *db, uint32_t cycle, uint32_t timestamp_ms, uint32_t elapsed_ms)
{
    uint8_t i;
    ab_gp_ertms_train_context_t *ctx;
 
    (void)cycle;
    (void)timestamp_ms;
 
    for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
    {
        ctx = &s_train_contexts[i];
 
        if (db != NULL)
        {
            bool db_connected = ab_gp_db_train_is_connected(db, (uint8_t)(i + 1U));
            /* Deliberately does NOT auto-drive session_state to INITIATED
             * off db_connected alone (that was this function's own prior
             * behaviour, removed once ab_gp_proc_dispatch.c started
             * reacting to a REAL inbound Msg 155 instead) - db_connected
             * only means the transport slot exists (P0/TRAIN_CONNECT,
             * transport-layer), which is deliberately independent of and
             * underneath the real Subset-026 application session this
             * state machine tracks; auto-driving here would report
             * INITIATED before the train ever actually sends Msg 155.
             * Termination stays symmetric with the OLD transport-level
             * disconnect, though - a dropped slot must still tear down
             * whatever session state was riding on it, real Msg 156 or
             * not. */
            if (!db_connected && ctx->session_state != AB_GP_ERTMS_SESSION_IDLE)
            {
                (void)ab_gp_proc_session_handle_termination(ctx, db);
            }
        }
 
        if (ctx->session_state != AB_GP_ERTMS_SESSION_IDLE)
        {
            /* Check contact supervision timer (T_NVCONTACT) - real bug fixed
             * here: this used to pass a literal 0U for timeout_limit_ms,
             * which check_timeout()'s own "0 = supervision off" guard
             * silently accepted forever, so the timer accumulated
             * (contact_timer_ms += elapsed_ms) but never once compared
             * against anything - see RTE_EXAMPLE_ERTMS_CONTACT_TIMEOUT_MS's
             * own doc (common_config.h) for the found-live account and why
             * this default is a placeholder pending real per-train National
             * Values storage. */
            (void)ab_gp_proc_session_check_timeout(ctx, elapsed_ms, RTE_EXAMPLE_ERTMS_CONTACT_TIMEOUT_MS, db);
        }
    }
}
 
bool ab_gp_ertms_calc_ma_for_route(uint8_t train_id, uint16_t route_id, uint32_t ma_seq)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    const ab_site_ga_route_layout_t *layout;
 
    if (ctx == NULL)
    {
        return false;
    }
 
    layout = ab_site_ga_get_route(route_id);
    if (layout == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_ma_compute(ctx, layout, ma_seq);
}
 
bool ab_gp_ertms_extend_ma_for_route(uint8_t train_id, uint16_t route_id)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    const ab_site_ga_route_layout_t *layout;
 
    if (ctx == NULL)
    {
        return false;
    }
 
    layout = ab_site_ga_get_route(route_id);
    if (layout == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_ma_extend(ctx, layout);
}
 
bool ab_gp_ertms_validate_train_data(uint8_t train_id,
                                     uint32_t l_train_m,
                                     uint32_t v_maxtrain_kmh,
                                     uint8_t m_axleload,
                                     uint8_t m_loadinggauge,
                                     bool m_airtight,
                                     uint32_t timestamp_ms)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_train_data_validate(ctx, l_train_m, v_maxtrain_kmh, m_axleload, m_loadinggauge, m_airtight, timestamp_ms);
}
 
bool ab_gp_ertms_update_train_position(uint8_t train_id,
                                       uint32_t nid_lrbg,
                                       uint32_t d_lrbg_m,
                                       rbc_q_dirlrbg_t q_dirlrbg,
                                       uint32_t v_train_kmh,
                                       uint32_t m_mode,
                                       uint32_t m_level,
                                       uint32_t cycle,
                                       uint32_t timestamp_ms)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_position_update(ctx, nid_lrbg, d_lrbg_m, q_dirlrbg, v_train_kmh, m_mode, m_level, cycle, timestamp_ms);
}
 
bool ab_gp_ertms_trigger_emergency_stop(uint8_t train_id,
                                        bool is_conditional,
                                        uint8_t nid_em,
                                        uint32_t d_ref_m,
                                        uint32_t d_es_m)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    if (is_conditional)
    {
        return ab_gp_proc_emergency_stop_issue_ces(ctx, nid_em, d_ref_m, d_es_m);
    }
    else
    {
        return ab_gp_proc_emergency_stop_issue_ues(ctx, nid_em);
    }
}
 
bool ab_gp_ertms_revoke_emergency_stop(uint8_t train_id, uint8_t nid_em)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_emergency_stop_revoke(ctx, nid_em);
}
 
bool ab_gp_ertms_request_shunting(uint8_t train_id)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_shunting_request(ctx);
}
 
bool ab_gp_ertms_authorize_shunting(uint8_t train_id, bool authorized)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_shunting_authorize(ctx, authorized);
}
 
bool ab_gp_ertms_terminate_mission(uint8_t train_id, ab_gp_db_t *db)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_eom_handle(ctx, db);
}
 
bool ab_gp_ertms_add_tsr(uint8_t train_id,
                         uint8_t nid_tsr,
                         uint32_t v_tsr_kmh,
                         uint32_t d_start_m,
                         uint32_t d_end_m)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_tsr_add(ctx, nid_tsr, v_tsr_kmh, d_start_m, d_end_m);
}
 
bool ab_gp_ertms_remove_tsr(uint8_t train_id, uint8_t nid_tsr)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_tsr_remove(ctx, nid_tsr);
}
 
bool ab_gp_ertms_send_text_message(uint8_t train_id,
                                   uint8_t nid_textmessage,
                                   uint8_t q_textclass,
                                   uint8_t q_textconfirm,
                                   uint32_t duration_s,
                                   const char *text,
                                   rbc_packet_72_text_message_t *out_p72)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_text_message_send(ctx, nid_textmessage, q_textclass, q_textconfirm, duration_s, text, out_p72);
}
 
bool ab_gp_ertms_handle_text_ack(uint8_t train_id,
                                 uint8_t nid_textmessage,
                                 uint32_t timestamp_ms)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_text_message_handle_ack(ctx, nid_textmessage, timestamp_ms);
}
 
bool ab_gp_ertms_announce_handover(uint8_t train_id,
                                   uint16_t target_nid_c,
                                   uint16_t target_nid_rbc,
                                   uint64_t target_nid_radio,
                                   uint32_t d_rbctr_m)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_handover_announce(ctx, target_nid_c, target_nid_rbc, target_nid_radio, d_rbctr_m);
}
 
bool ab_gp_ertms_complete_handover(uint8_t train_id)
{
    ab_gp_ertms_train_context_t *ctx = ab_gp_ertms_engine_get_train_context(train_id);
    if (ctx == NULL)
    {
        return false;
    }
 
    return ab_gp_proc_handover_complete(ctx);
}