ab_gp_proc_shunting.c

Go to the documentation of this file.

 
#include "ab_gp_proc_shunting.h"
#include "../state_machines/ab_gp_dispatch.h"
#include "../state_machines/session/ab_gp_session_fsm.h" /* ab_gp_session_fsm_can_handle() */
#include "../ma_logic/ab_gp_logic.h"                     /* ab_gp_logic_shunting_allowed() - GA veto */
 
#include "rte/oal/memory/rte_mem_util.h"
 
bool ab_gp_proc_shunting_request(ab_gp_ertms_train_context_t *ctx)
{
    if (ctx == NULL)
    {
        return false;
    }
 
    ctx->shunting_requested = true;
    return true;
}
 
bool ab_gp_proc_shunting_authorize(ab_gp_ertms_train_context_t *ctx, bool authorized)
{
    if (ctx == NULL)
    {
        return false;
    }
 
    ctx->shunting_requested = false;
 
    if (authorized)
    {
        /* Handled from ESTABLISHED/DATA_VALIDATED/STANDBY/FS
         * (ab_gp_session_fsm.c's own table - ESTABLISHED included for the
         * same reason ab_gp_proc_ma_compute() needs it, see that function's
         * own doc: this codebase's real connect path never reaches
         * DATA_VALIDATED at all) - a real, deliberate tightening versus the
         * old unconditional assignment: shunting can no longer be
         * authorized for a train with no session at all (IDLE/INITIATED),
         * mid-emergency-stop, or mid-termination. Reports failure back to
         * the caller instead of silently claiming authorization that was
         * never actually granted. */
        if (!ab_gp_dispatch(ctx, AB_GP_SESSION_EVENT_SHUNTING_AUTHORIZED))
        {
            ctx->shunting_authorized = false;
            return false;
        }
        ctx->shunting_authorized = true;
        return true;
    }
 
    ctx->shunting_authorized = false;
    /* No outer guard needed - the table only defines an outcome for this
     * event from SHUNTING, so it is a harmless no-op from anywhere else. */
    (void)ab_gp_dispatch(ctx, AB_GP_SESSION_EVENT_SHUNTING_DEAUTHORIZED);
    return true;
}
 
ab_gp_shunting_decision_t ab_gp_proc_shunting_handle_request(ab_gp_ertms_train_context_t *ctx, uint8_t train_id,
                                                              uint32_t v_train_kmh)
{
    if (ctx == NULL)
    {
        return AB_GP_SHUNTING_REFUSED_INVALID;
    }
 
    (void)ab_gp_proc_shunting_request(ctx);
 
    /* A repeated Msg 130 (the train did not get the first answer) is answered again, with no state change. */
    if (ctx->session_state == AB_GP_ERTMS_SESSION_SHUNTING)
    {
        ctx->shunting_requested = false;
        return AB_GP_SHUNTING_AUTHORISED;
    }
 
    /* Msg 130 needs a communication session. The session table also lets IDLE take SHUNTING_AUTHORIZED, for the
     * flat-scheme connect path; an ERTMS request from a train with no session is refused here instead. */
    if ((ctx->session_state == AB_GP_ERTMS_SESSION_IDLE) || (ctx->session_state == AB_GP_ERTMS_SESSION_INITIATED))
    {
        ctx->shunting_requested = false;
        return AB_GP_SHUNTING_REFUSED_NO_SESSION;
    }
 
    /* The on-board lets the driver select SH only at standstill; the RBC checks the reported speed as well. */
    if (v_train_kmh != 0U)
    {
        ctx->shunting_requested = false;
        return AB_GP_SHUNTING_REFUSED_NOT_AT_STANDSTILL;
    }
 
    if (!ab_gp_session_fsm_can_handle(ctx->session_state, AB_GP_SESSION_EVENT_SHUNTING_AUTHORIZED, NULL))
    {
        ctx->shunting_requested = false;
        return AB_GP_SHUNTING_REFUSED_SESSION_STATE;
    }
 
    if (!ab_gp_logic_shunting_allowed(train_id))
    {
        ctx->shunting_requested = false;
        return AB_GP_SHUNTING_REFUSED_BY_GA;
    }
 
    if (!ab_gp_proc_shunting_authorize(ctx, true))
    {
        return AB_GP_SHUNTING_REFUSED_SESSION_STATE;
    }
    return AB_GP_SHUNTING_AUTHORISED;
}
 
bool ab_gp_proc_shunting_build_reply(ab_gp_shunting_decision_t decision, rbc_timestamp_ms_t t_train_reply,
                                     rbc_timestamp_ms_t t_train_request, rbc_nid_lrbg_t nid_lrbg,
                                     rbc_train_outbound_msg_t *out)
{
    rbc_track_to_train_header_t *header;
 
    if (out == NULL)
    {
        return false;
    }
 
    rte_mem_set(out, 0, sizeof(*out));
    if (decision == AB_GP_SHUNTING_AUTHORISED)
    {
        out->nid_message = RBC_MSG_TRACK_TO_TRAIN_SH_AUTHORISED;
        out->payload.msg_28.t_train_ref = t_train_request;
        header = &out->payload.msg_28.header;
    }
    else
    {
        out->nid_message = RBC_MSG_TRACK_TO_TRAIN_SH_REFUSED;
        out->payload.msg_27.t_train_ref = t_train_request;
        header = &out->payload.msg_27.header;
    }
    header->nid_message = out->nid_message;
    header->t_train = t_train_reply;
    header->m_ack = RBC_M_ACK_NOT_REQUIRED;
    header->nid_lrbg = nid_lrbg;
    return true;
}
 
const char *ab_gp_proc_shunting_decision_name(ab_gp_shunting_decision_t decision)
{
    switch (decision)
    {
        case AB_GP_SHUNTING_AUTHORISED:                return "AUTHORISED";
        case AB_GP_SHUNTING_REFUSED_NO_SESSION:        return "NO_SESSION";
        case AB_GP_SHUNTING_REFUSED_NOT_AT_STANDSTILL: return "NOT_AT_STANDSTILL";
        case AB_GP_SHUNTING_REFUSED_SESSION_STATE:     return "SESSION_STATE";
        case AB_GP_SHUNTING_REFUSED_BY_GA:             return "REFUSED_BY_GA";
        case AB_GP_SHUNTING_REFUSED_INVALID:           return "INVALID";
        default:                                       return "UNKNOWN";
    }
}