ab_ga_ctc.c

Go to the documentation of this file.

#include "ab_ga_ctc.h"
 
#include "rte/utils/buffer/rte_buffer.h"
#include "rte/oal/memory/rte_mem_util.h"
 
#include "common_config.h" /* RTE_EXAMPLE_LOG, RTE_EXAMPLE_MAX_TRAINS,
                             * RTE_EXAMPLE_MAX_ROUTES_PER_TRAIN */
#include "ga_interface.h" /* ab_gp_train_session_*() - bare calls now, see that file's own doc */
#include "ab_siteGA.h" /* ab_site_ga_get_route(), ab_site_ga_route_layout_t - GA's own
                         * static route table, see this file's own compute_train_info_signals()
                         * doc for why. */

#define CTC_WIRE_HEADER_SIZE 12U
#define CTC_WIRE_CONTENT_SIZE_BASE 24U




/* ctc_on_route_connected forward decl REMOVED - ab_ga_ctc_on_route_context_changed()
 * (ab_ga_ctc.h) is now the ONE public function GA's dispatch module
 * calls, not a GP-registered callback - see this file's own module doc. */

static bool                   g_train_info_pending[RTE_EXAMPLE_MAX_TRAINS];
static bool                   g_train_info_built[RTE_EXAMPLE_MAX_TRAINS];
static bool                   g_connected_built[RTE_EXAMPLE_MAX_TRAINS];
static bool                   g_ma_granted_built[RTE_EXAMPLE_MAX_TRAINS];
static ab_gp_train_context_t  g_last_train_ctx[RTE_EXAMPLE_MAX_TRAINS];
static bool                   g_train_ctx_known[RTE_EXAMPLE_MAX_TRAINS];
static void ctc_wire_encode(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], const rbc_envelope_t *env);
static void compute_train_info_signals(const uint16_t route_ids[RTE_EXAMPLE_MAX_ROUTES_PER_TRAIN],
                                        uint8_t route_count, uint32_t d_lrbg, uint16_t *out_front_signal,
                                        uint32_t *out_dist_to_front, uint16_t *out_target_signal);
 

/* ab_ga_ctc_init() REMOVED - its entire body was one GP registration, now
 * owned by ab_ga_dispatch.c's own single subscription (see this file's
 * own module doc and ab_ga_dispatch.h). */
 
void ab_ga_ctc_build_connected(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], uint8_t train_id, uint32_t d_lrbg)
{
    rbc_envelope_t env;
 
    rte_mem_set(&env, 0, sizeof(env));
    env.kind = RBC_MSG_CTC_CONNECTED;
    env.train_id = train_id;
    env.d_lrbg = d_lrbg;
    ctc_wire_encode(out, &env);
}
 
void ab_ga_ctc_build_ma_granted(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], uint8_t train_id, uint32_t ma_seq,
                              uint32_t ma_length)
{
    rbc_envelope_t env;
 
    rte_mem_set(&env, 0, sizeof(env));
    env.kind = RBC_MSG_CTC_MA_GRANTED;
    env.train_id = train_id;
    env.ma_seq = ma_seq;
    env.ma_length = ma_length;
    ctc_wire_encode(out, &env);
}
 
void ab_ga_ctc_build_ma_extended(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], uint8_t train_id, uint32_t ma_seq,
                               uint32_t ma_length)
{
    rbc_envelope_t env;
 
    rte_mem_set(&env, 0, sizeof(env));
    env.kind = RBC_MSG_CTC_MA_EXTENDED;
    env.train_id = train_id;
    env.ma_seq = ma_seq;
    env.ma_length = ma_length;
    ctc_wire_encode(out, &env);
}
 
/* ab_ga_ctc_build_alarm() - MOVED to GP (AB/GP/main/ab_gp_ga_hooks.c's own
 * ab_gp_build_ctc_alarm()), later session, on direct request. */
 
void ab_ga_ctc_build_train_info(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], uint8_t train_id, uint32_t d_lrbg,
                                 uint32_t ma_seq, uint32_t granted_length, bool ma_granted,
                                 uint16_t front_signal, uint32_t dist_to_front_signal, uint16_t target_signal,
                                 uint32_t nid_lrbg, uint32_t v_train, uint32_t m_mode)
{
    rbc_envelope_t env;
    int32_t         ma_offset;
 
    rte_mem_set(&env, 0, sizeof(env));
    env.kind = RBC_MSG_CTC_TRAIN_INFO;
    env.train_id = train_id;
    env.d_lrbg = d_lrbg;
    env.ma_seq = ma_seq;
    env.msg_type = ma_granted ? 1U : 0U;          /* ma_status: 0=NONE, 1=GRANTED - see this
                                                     * kind's own doc, rbc_wire_types.h. */
    env.route_len = (uint32_t)target_signal;      /* MA target signal - reuses the slot that's
                                                     * otherwise always 0 for every CTC_* kind. */
    env.t_train = (uint32_t)front_signal;         /* front signal - reuses alarm's own timestamp
                                                     * slot, 0 for every other kind. */
    env.cycle = dist_to_front_signal;             /* distance to front signal - reuses alarm's
                                                     * own cycle slot. */
    ma_offset = (int32_t)d_lrbg - (int32_t)granted_length; /* negative while approaching, 0 at
                                                              * the limit - see this kind's own
                                                              * doc for why "MA length in
                                                              * relation to balise" is not a
                                                              * separate field (it is -ma_offset). */
    env.ma_length = (uint32_t)ma_offset;          /* signed value, two's-complement bit pattern -
                                                     * decode as (int32_t) on the reading side. */
    env.nid_lrbg = nid_lrbg;                      /* appended fields (on direct request) - see
                                                     * ctc_wire_encode()'s own doc for why these
                                                     * are appended after ma_length, not inserted
                                                     * into the base 24-byte layout. */
    env.v_train = v_train;
    env.m_mode = m_mode;
    ctc_wire_encode(out, &env);
}
 
uint8_t ab_ga_ctc_build_outputs(const ab_gp_train_session_t *sessions, ab_gp_db_t *db,
                              ab_gp_ctc_pending_output_t out[AB_GP_CTC_MAX_PENDING_OUTPUTS])
{
    uint8_t count = 0U;
    uint8_t i;
 
    /* ISS-047: what an earlier, never-confirmed build marked must not be
     * applied by a later confirm of a build without that output (e.g.
     * after GP reset the latches for a new session). */
    for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
    {
        g_connected_built[i] = false;
        g_ma_granted_built[i] = false;
    }
 
    for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
    {
        uint8_t  train_id = (uint8_t)(i + 1U);
        /* Every field this loop reads below (in_use/ctc_ma_granted_sent/
         * d_lrbg/ma_pending_send/ctc_ma_notify_pending/ma_seq/
         * granted_length) now comes from this ONE context read - the
         * individual session getters this used to call one field at a
         * time are gone (later session, on direct request). */
        ab_gp_train_context_t tctx;
 
        (void)ab_gp_get_train_context(sessions, db, train_id, &tctx);
        /* CTC_CONNECTED: re-emitted every should_forward_to_c cycle from
         * connect until the train's first CTC_MA_GRANTED supersedes it
         * (was a one-shot latch on ctc_connected_sent). A one-shot fire
         * is lost outright if C's own sim-facing link is not up yet the
         * exact cycle it goes out - a real race at env startup, worse now
         * that every train's P0 co-arrives on one multiplexed link
         * (ADR-036) and C's CTC gateway is its own process (ADR-037). The
         * CTC sim de-dups by nid_engine ("not a queue", DESIGN.md 4.2),
         * and this branch stops as soon as CTC_MA_GRANTED starts, so a
         * connected train with an MA emits exactly one CTC frame/cycle -
         * count stays within AB_GP_CTC_MAX_PENDING_OUTPUTS (MAX_TRAINS*2). */
        if (tctx.in_use && !tctx.ctc_ma_granted_sent)
        {
            ab_ga_ctc_build_connected(out[count].bytes, train_id, tctx.d_lrbg);
            rte_mem_copy(out[count].tag, "CTC_CONNECTED", sizeof("CTC_CONNECTED"));
            count++;
            g_connected_built[i] = true; /* latched at confirm, not here (ISS-047) */
        }
        /* ctc_ma_notify_pending: the real Subset-026/ERTMS MA-grant path
         * (ab_gp_proc_dispatch.c's handle_msg_132()) sets THIS instead of
         * ma_pending_send, deliberately - see ab_gp_train_session_t's own
         * doc for why the two must stay separate (ma_pending_send also
         * drives the flat scheme's own ab_gp_train_build_outputs(), which
         * an ERTMS grant must NOT also trigger). Either flag is enough to
         * fire the CTC_MA_GRANTED/_EXTENDED notification below - CTC does
         * not care which scheme actually produced the grant. */
        if (tctx.ma_pending_send || tctx.ctc_ma_notify_pending)
        {
            if (!tctx.ctc_ma_granted_sent)
            {
                ab_ga_ctc_build_ma_granted(out[count].bytes, train_id, tctx.ma_seq, tctx.granted_length);
                rte_mem_copy(out[count].tag, "CTC_MA_GRANTED", sizeof("CTC_MA_GRANTED"));
                g_ma_granted_built[i] = true; /* latched at confirm, not here (ISS-047): a build
                                               * that is not forwarded is rebuilt as GRANTED */
            }
            else
            {
                ab_ga_ctc_build_ma_extended(out[count].bytes, train_id, tctx.ma_seq, tctx.granted_length);
                rte_mem_copy(out[count].tag, "CTC_MA_EXTENDED", sizeof("CTC_MA_EXTENDED"));
            }
            /* ADR-034: this CTC output (MA granted/extended) is finalized
             * here, right before GP stages it for send - see
             * ab_ga_il.c's own AB_GA_CHECKPOINT_MARK() call for why. */
            AB_GA_CHECKPOINT_MARK();
            count++;
        }
 
        /* RBC_MSG_CTC_TRAIN_INFO: reactive, not a per-cycle poll+diff scan
         * (interface-simplification pass - see this module's own header
         * doc). g_train_info_pending[]/g_last_train_ctx[] are set by
         * ab_ga_ctc_on_train_context_changed() below, itself called only
         * when GP's own push notification
         * (ab_gp_register_train_context_notify()) fires a REAL change -
         * no more per-train getter calls or "did anything change since
         * last sent" comparison here at all. */
        if (tctx.in_use && g_train_info_pending[i])
        {
            const ab_gp_train_context_t *ctx = &g_last_train_ctx[i];
            uint16_t front_signal = 0U;
            uint32_t dist_to_front = 0U;
            uint16_t target_signal = 0U;
            bool     ma_granted = ctx->has_ma;
 
            compute_train_info_signals(ctx->route_ids, ctx->route_count, ctx->d_lrbg, &front_signal, &dist_to_front,
                                        &target_signal);
            ab_ga_ctc_build_train_info(out[count].bytes, train_id, ctx->d_lrbg, ctx->ma_seq, ctx->granted_length,
                                        ma_granted, front_signal, dist_to_front, target_signal, ctx->nid_lrbg,
                                        ctx->v_train, ctx->m_mode);
            rte_mem_copy(out[count].tag, "CTC_TRAIN_INFO", sizeof("CTC_TRAIN_INFO"));
            count++;
            g_train_info_built[i] = true;
        }
    }
    return count;
}
 
void ab_ga_ctc_confirm_outputs_sent(ab_gp_train_session_t *sessions)
{
    uint8_t i;
 
    for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
    {
        uint8_t train_id = (uint8_t)(i + 1U);
 
        if (g_connected_built[i])
        {
            if (sessions != NULL)
            {
                (void)ab_gp_train_session_set_ctc_connected_sent(sessions, train_id, true);
            }
            g_connected_built[i] = false;
        }
        if (g_ma_granted_built[i])
        {
            if (sessions != NULL)
            {
                (void)ab_gp_train_session_set_ctc_ma_granted_sent(sessions, train_id, true);
            }
            g_ma_granted_built[i] = false;
        }
        if (g_train_info_built[i])
        {
            g_train_info_pending[i] = false;
            g_train_info_built[i] = false;
        }
    }
}
 
 
/****Local functions ****/
 
void ab_ga_ctc_on_route_context_changed(const ab_gp_route_context_t *ctx, ab_gp_route_update_type_t update_type)
{
    extern char *g_ga_role_tag; /* GA-wide, set once at ab_ga_ma_logic_adaptation_init() -
                                  * see that file's own definition; used for logging only,
                                  * same as every other GA module. */
 
    if (update_type != AB_ROUTE_CONNECTED)
    {
        return; /* CTC only ever logged the connect side - see this file's own module doc */
    }
    RTE_EXAMPLE_LOG("[%s] CTC notified: route %u connected to train %u\n", g_ga_role_tag,
                         (unsigned int)ctx->id, (unsigned int)ctx->train_id);
}
 
void ab_ga_ctc_on_train_context_changed(const ab_gp_train_context_t *ctx, ab_gp_train_update_type_t update_type)
{
    uint8_t  idx;
    bool     d_lrbg_changed;
    bool     nid_lrbg_changed;
    bool     v_train_changed;
    bool     m_mode_changed;
    bool     granted_length_changed;
    bool     ma_seq_changed;
    bool     has_ma_changed;
 
    (void)update_type;
    if ((ctx->train_id == 0U) || (ctx->train_id > (uint8_t)RTE_EXAMPLE_MAX_TRAINS))
    {
        return;
    }
    idx = (uint8_t)(ctx->train_id - 1U);
 
    if (!ctx->in_use)
    {
        /* Train disconnected/removed - GP's own session/db state for this
         * slot is fully zeroed by now (ab_gp_train_remove(), see
         * ab_gp_train.c's RBC_MSG_TRAIN_DISCONNECT handling), but
         * g_last_train_ctx[]/g_train_ctx_known[] are a SEPARATE, GA-local
         * comparison cache GP has no way to reach - without this reset
         * they silently survive the disconnect, so the next real
         * connection for this same train_id slot (a genuine reconnect, or
         * - in the Robot suite - the next test file reusing the same
         * nid_engine) gets its first CTC_TRAIN_INFO telemetry diffed
         * against this now-stale leftover snapshot instead of being
         * treated as a first-ever context. Found live: exactly this
         * caused CTC_TRAIN_INFO to go missing or report stale fields
         * (nid_lrbg stuck at an old value) only when a test ran after
         * another test had used the same train slot, never in isolation -
         * see ISSUES.md's cross-test state accumulation entry. */
        g_train_ctx_known[idx] = false;
        g_train_info_pending[idx] = false;
        return;
    }
 
    /* GP fires this notification on EVERY M136 (position report),
     * whether or not anything actually changed - a stationary train
     * still reports periodically. Comparing against the last-KNOWN
     * context here (not GP's own responsibility any more, see this
     * file's own module doc) is what keeps CTC_TRAIN_INFO genuinely
     * on-change - without this comparison, a stationary/idle train would
     * get re-sent every single M136 cycle, exactly the poll-and-resend
     * behavior this whole redesign was meant to remove. front_signal/
     * target_signal/dist_to_front are NOT compared here (they are not
     * part of ab_gp_train_context_t - ab_ga_ctc_build_outputs() computes
     * them fresh from the route chain each time it actually sends) - a
     * route-boundary-only change with every other field unchanged is
     * covered by AB_ROUTE_CONNECTED/_DISCONNECTED already re-arming
     * g_train_info_pending via handle_route_add()'s/_release()'s own
     * explicit AB_TRAIN_MA_CHANGED trigger (granted_length/ma_seq always
     * change alongside a route boundary change too). */
    if (!g_train_ctx_known[idx])
    {
        g_last_train_ctx[idx] = *ctx;
        g_train_ctx_known[idx] = true;
        g_train_info_pending[idx] = true; /* first-ever context for this train - always send */
        return;
    }
 
    d_lrbg_changed = (ctx->d_lrbg != g_last_train_ctx[idx].d_lrbg);
    nid_lrbg_changed = (ctx->nid_lrbg != g_last_train_ctx[idx].nid_lrbg);
    v_train_changed = (ctx->v_train != g_last_train_ctx[idx].v_train);
    m_mode_changed = (ctx->m_mode != g_last_train_ctx[idx].m_mode);
    granted_length_changed = (ctx->granted_length != g_last_train_ctx[idx].granted_length);
    ma_seq_changed = (ctx->ma_seq != g_last_train_ctx[idx].ma_seq);
    has_ma_changed = (ctx->has_ma != g_last_train_ctx[idx].has_ma);
 
    g_last_train_ctx[idx] = *ctx;
    if (d_lrbg_changed || nid_lrbg_changed || v_train_changed || m_mode_changed || granted_length_changed ||
        ma_seq_changed || has_ma_changed)
    {
        g_train_info_pending[idx] = true;
    }
}

static void compute_train_info_signals(const uint16_t route_ids[RTE_EXAMPLE_MAX_ROUTES_PER_TRAIN],
                                        uint8_t route_count, uint32_t d_lrbg, uint16_t *out_front_signal,
                                        uint32_t *out_dist_to_front, uint16_t *out_target_signal)
{
    uint32_t cumulative = 0U;
    bool     front_found = false;
    uint16_t cur_id;
    uint8_t  visited;
 
    *out_front_signal = 0U;
    *out_dist_to_front = 0U;
    *out_target_signal = 0U;
 
    if (route_count == 0U)
    {
        return;
    }
 
    /* Chain head = the held route whose prev_route_id is NOT itself held
     * - route_ids[]'s own array order is not a documented ordering
     * guarantee, so this walks ab_siteGA.h's real prev/next_route_id
     * chain instead of assuming array order matches grant/path order. */
    cur_id = 0U;
    for (visited = 0U; visited < route_count; visited++)
    {
        const ab_site_ga_route_layout_t *rt = ab_site_ga_get_route(route_ids[visited]);
        bool prev_is_held = false;
        uint8_t j;
 
        if (rt == NULL)
        {
            continue;
        }
        for (j = 0U; j < route_count; j++)
        {
            if (route_ids[j] == rt->prev_route_id)
            {
                prev_is_held = true;
            }
        }
        if (!prev_is_held)
        {
            cur_id = route_ids[visited];
        }
    }
 
    /* Walk the chain forward from the head, accumulating length, to find
     * both the front signal (first not-yet-reached boundary) and the MA
     * target signal (end of the last held route visited). Bounded by
     * route_count so a corrupt/cyclic next_route_id chain can't loop
     * forever. */
    for (visited = 0U; (visited < route_count) && (cur_id != 0U); visited++)
    {
        const ab_site_ga_route_layout_t *rt = ab_site_ga_get_route(cur_id);
        uint32_t boundary;
        uint16_t next_id;
        uint8_t  j;
 
        if (rt == NULL)
        {
            break;
        }
        boundary = cumulative + rt->length_m;
        if (!front_found && (d_lrbg < boundary))
        {
            *out_front_signal = rt->end_signal;
            *out_dist_to_front = boundary - d_lrbg;
            front_found = true;
        }
        *out_target_signal = rt->end_signal;
        cumulative = boundary;
 
        next_id = 0U;
        for (j = 0U; j < route_count; j++)
        {
            if (route_ids[j] == rt->next_route_id)
            {
                next_id = route_ids[j];
            }
        }
        cur_id = next_id;
    }
 
    if (!front_found)
    {
        /* Train already past every held route's own boundary (or the
         * held-route data disagrees with d_lrbg) - report the MA target
         * itself as the front signal, distance 0, rather than leaving
         * stale zeros that would misleadingly read as "no MA". */
        *out_front_signal = *out_target_signal;
        *out_dist_to_front = 0U;
    }
}
 
static void ctc_wire_encode(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], const rbc_envelope_t *env)
{
    rte_buffer_t buf;
    /* RBC_MSG_CTC_TRAIN_INFO alone also carries nid_lrbg/v_train/m_mode -
     * these are NOT appended after the base 24-byte content at a
     * CTC-local offset; every field in this shared envelope lives at
     * one fixed, kind-independent byte offset across EVERY kind
     * (rbc_wire_types.h's own file doc, and SimCore's rbc_wire.py's own
     * near-identical doc: "aliasing different kinds' own extension
     * fields onto the same wire bytes" is exactly what NOT branching on
     * kind for field position prevents) - so these three go at the SAME
     * offsets M136 already defines for them (40/64/72 - skipping
     * t_train_ack/q_dirlrbg-through-q_length/q_dirtrain, which this kind
     * leaves at zero), not sequential ones. Found live: an earlier
     * attempt at this exact addition used sequential CTC-local offsets
     * instead, landing nid_lrbg on top of t_train_ack's own wire slot
     * and v_train/m_mode on top of nid_lrbg/q_dirlrbg's - every existing
     * consumer of those M136 fields would have silently decoded garbage
     * had any kind ever mixed them with a CTC_TRAIN_INFO reader on the
     * same session. */
    bool     is_train_info = (env->kind == RBC_MSG_CTC_TRAIN_INFO);
    /* l_message must cover through m_mode's own offset (72-75) for
     * THIS kind - every other CTC_* kind's l_message is unchanged. */
    uint16_t l_message = is_train_info ? 76U : (uint16_t)(CTC_WIRE_HEADER_SIZE + CTC_WIRE_CONTENT_SIZE_BASE);
 
    rte_mem_set(out, 0, RBC_ENVELOPE_WIRE_SIZE);
    (void)rte_buffer_init(&buf, out, RBC_ENVELOPE_WIRE_SIZE);
    out[0] = (uint8_t)env->kind;
    out[1] = env->train_id;
    out[2] = 0U; /* no real Subset-026 nid_message for any CTC_* kind */
    out[3] = 0U; /* reserved */
    (void)rte_buffer_set_length(&buf, 4U);
    (void)rte_buffer_write_u16_le(&buf, l_message);      /* offset 4-5 */
    (void)rte_buffer_write_u16_le(&buf, 0U);              /* offset 6-7, reserved */
    (void)rte_buffer_write_u32_le(&buf, env->t_train);    /* offset 8-11 - alarm's own timestamp_ms, 0 for
                                                              * every other CTC_* kind */
    (void)rte_buffer_write_u32_le(&buf, env->cycle);      /* offset 12-15 - alarm's own cycle, 0 for every
                                                              * other CTC_* kind, see this file's own header
                                                              * for why the offset stays */
    (void)rte_buffer_write_u32_le(&buf, env->d_lrbg);     /* offset 16-19 */
    (void)rte_buffer_write_u32_le(&buf, env->msg_type);   /* offset 20-23 - alarm's own rbc_alarm_severity_t,
                                                              * 0 for every other CTC_* kind */
    (void)rte_buffer_write_u32_le(&buf, env->route_len);  /* offset 24-27 - not CTC's own field - always 0
                                                              * for every kind except TRAIN_INFO's own reuse */
    (void)rte_buffer_write_u32_le(&buf, env->ma_seq);     /* offset 28-31 - alarm's own numeric code; MA_GRANTED/
                                                              * _EXTENDED's own MA sequence number for those kinds */
    (void)rte_buffer_write_u32_le(&buf, env->ma_length);  /* offset 32-35 */
    if (is_train_info)
    {
        /* offset 36-39 (t_train_ack) left zero - not this kind's field. */
        (void)rte_buffer_set_length(&buf, 40U);
        (void)rte_buffer_write_u32_le(&buf, env->nid_lrbg); /* offset 40-43, M136's own canonical slot */
        /* offset 44-63 (q_dirlrbg/q_dlrbg/l_doubtover/l_doubtunder/
         * q_length) left zero - not this kind's fields. */
        (void)rte_buffer_set_length(&buf, 64U);
        (void)rte_buffer_write_u32_le(&buf, env->v_train);  /* offset 64-67, M136's own canonical slot */
        /* offset 68-71 (q_dirtrain) left zero - not this kind's field. */
        (void)rte_buffer_set_length(&buf, 72U);
        (void)rte_buffer_write_u32_le(&buf, env->m_mode);   /* offset 72-75, M136's own canonical slot */
    }
}