ab_gp_dispatch.c

Go to the documentation of this file.

 
#include "ab_gp_dispatch.h"
 
#include "session/ab_gp_session_fsm.h"
#include "train_data/ab_gp_train_data_fsm.h"
#include "ma/ab_gp_ma_fsm.h"
#include "shunting/ab_gp_shunting_fsm.h"
#include "emergency_stop/ab_gp_emergency_stop_fsm.h"
#include "position/ab_gp_position_fsm.h"
#include "eom/ab_gp_eom_fsm.h"
#include "handover/ab_gp_handover_fsm.h"
#include "tsr/ab_gp_tsr_fsm.h"
#include "text_message/ab_gp_text_message_fsm.h"
 
#include "rte/oal/log/rte_log.h"
#include "rte/utils/string/rte_string.h"

static const struct
{
    ab_gp_event_t        event;
    ab_gp_fsm_handler_fn handler;
} s_subscriptions[] = {
    /* Session lifecycle - ab_gp_session_fsm.c is the sole subscriber for
     * all of these (so ab_gp_dispatch()'s bool == this FSM's result). */
    { AB_GP_SESSION_EVENT_SESSION_INITIATION_REQUESTED,       ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_SESSION_ESTABLISHED_CONFIRMED,      ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_TRAIN_DATA_VALIDATED,               ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_MA_GRANTED,                         ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_MA_REVOKED,                         ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_SHUNTING_AUTHORIZED,                ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_SHUNTING_DEAUTHORIZED,              ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_EMERGENCY_STOP_ISSUED,              ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_EMERGENCY_STOP_REVOKED_TO_FS,       ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_EMERGENCY_STOP_REVOKED_TO_STANDBY,  ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_EMERGENCY_STOP_REVOKED_TO_ESTABLISHED, ab_gp_session_fsm_handle_event },
    { AB_GP_SESSION_EVENT_SESSION_TERMINATED,                 ab_gp_session_fsm_handle_event },
 
    /* Validated Train Data - ab_gp_train_data_fsm.c. It ALSO subscribes to
     * the shared _TRAIN_DATA_VALIDATED event above (the "accepted" case),
     * so that event has two rows: session FSM first, then this one. */
    { AB_GP_SESSION_EVENT_TRAIN_DATA_VALIDATED,               ab_gp_train_data_fsm_handle_event },
    { AB_GP_EVENT_TRAIN_DATA_RECEIVED,                        ab_gp_train_data_fsm_handle_event },
    { AB_GP_EVENT_TRAIN_DATA_REJECTED,                        ab_gp_train_data_fsm_handle_event },
 
    /* ---- STUB per-entity FSMs (ab_gp_fsm_stub.h) ------------------- */
    /* The wiring is complete - each event below reaches its FSM - but
     * these handlers only log "not implemented yet" and return false
     * (changed=0), so they never affect ab_gp_dispatch()'s bool. Where
     * an event also has a real subscriber above (MA_GRANTED etc.), that
     * one still runs first and still decides the return. */
 
    /* Movement Authority. */
    { AB_GP_SESSION_EVENT_MA_GRANTED,                         ab_gp_ma_fsm_handle_event },
    { AB_GP_SESSION_EVENT_MA_REVOKED,                         ab_gp_ma_fsm_handle_event },
    { AB_GP_EVENT_MA_REQUESTED,                               ab_gp_ma_fsm_handle_event },
    { AB_GP_EVENT_MA_ACKNOWLEDGED,                            ab_gp_ma_fsm_handle_event },
 
    /* Shunting. */
    { AB_GP_SESSION_EVENT_SHUNTING_AUTHORIZED,                ab_gp_shunting_fsm_handle_event },
    { AB_GP_SESSION_EVENT_SHUNTING_DEAUTHORIZED,              ab_gp_shunting_fsm_handle_event },
 
    /* Emergency stop. */
    { AB_GP_SESSION_EVENT_EMERGENCY_STOP_ISSUED,              ab_gp_emergency_stop_fsm_handle_event },
    { AB_GP_SESSION_EVENT_EMERGENCY_STOP_REVOKED_TO_FS,       ab_gp_emergency_stop_fsm_handle_event },
    { AB_GP_SESSION_EVENT_EMERGENCY_STOP_REVOKED_TO_STANDBY,  ab_gp_emergency_stop_fsm_handle_event },
    { AB_GP_SESSION_EVENT_EMERGENCY_STOP_REVOKED_TO_ESTABLISHED, ab_gp_emergency_stop_fsm_handle_event },
 
    /* Supervised position. */
    { AB_GP_EVENT_POSITION_REPORTED,                          ab_gp_position_fsm_handle_event },
 
    /* End of Mission. */
    { AB_GP_EVENT_END_OF_MISSION,                             ab_gp_eom_fsm_handle_event },
 
    /* RBC handover (no raise site yet). */
    { AB_GP_EVENT_HANDOVER_ANNOUNCED,                         ab_gp_handover_fsm_handle_event },
    { AB_GP_EVENT_HANDOVER_CONFIRMED,                         ab_gp_handover_fsm_handle_event },
 
    /* Temporary Speed Restriction (no raise site yet). */
    { AB_GP_EVENT_TSR_IMPOSED,                                ab_gp_tsr_fsm_handle_event },
    { AB_GP_EVENT_TSR_REVOKED,                                ab_gp_tsr_fsm_handle_event },
 
    /* Driver text message (no raise site yet). */
    { AB_GP_EVENT_TEXT_MESSAGE_SENT,                          ab_gp_text_message_fsm_handle_event },
    { AB_GP_EVENT_TEXT_MESSAGE_ACKNOWLEDGED,                  ab_gp_text_message_fsm_handle_event }
};
 
#define AB_GP_DISPATCH_SUBSCRIPTION_COUNT \
    (sizeof(s_subscriptions) / sizeof(s_subscriptions[0]))

static void log_dispatch(const ab_gp_ertms_train_context_t *ctx, ab_gp_event_t event,
                         uint32_t reached, uint32_t changed)
{
    char storage[96];
    rte_string_t line;
    const char *out_cstr = NULL;
 
    if (rte_string_init(&line, storage, sizeof(storage)) != RTE_STATUS_OK)
    {
        return;
    }
    (void)rte_string_copy(&line, "train=");
    (void)rte_string_append_u32(&line, (uint32_t)ctx->train_id);
    (void)rte_string_concat(&line, " event=");
    (void)rte_string_append_u32(&line, (uint32_t)event);
    (void)rte_string_concat(&line, " reached=");
    (void)rte_string_append_u32(&line, reached);
    (void)rte_string_concat(&line, " changed=");
    (void)rte_string_append_u32(&line, changed);
 
    if (rte_string_c_str(&line, &out_cstr) == RTE_STATUS_OK)
    {
        rte_log_write(RTE_LOG_LEVEL_DEBUG, "GP_DISPATCH", out_cstr);
    }
}
 
bool ab_gp_dispatch(ab_gp_ertms_train_context_t *ctx, ab_gp_event_t event)
{
    uint32_t i;
    uint32_t reached = 0U;
    uint32_t changed = 0U;
 
    if (ctx == NULL)
    {
        return false;
    }
    if ((uint32_t)event >= (uint32_t)AB_GP_EVENT_COUNT)
    {
        return false;
    }
 
    for (i = 0U; i < (uint32_t)AB_GP_DISPATCH_SUBSCRIPTION_COUNT; i++)
    {
        if (s_subscriptions[i].event == event)
        {
            reached++;
            if (s_subscriptions[i].handler(ctx, event))
            {
                changed++;
            }
        }
    }
 
    log_dispatch(ctx, event, reached, changed);
    return (changed > 0U);
}