ga_interface.h

Go to the documentation of this file.

#ifndef RTE_EXAMPLE_GA_INTERFACE_H
#define RTE_EXAMPLE_GA_INTERFACE_H
 
#include <stdbool.h>
#include <stdint.h>
 
#include "rte/app/appmanager/rte_appmanager.h" /* RTE_CHECKPOINT_MARK() - AB_GA_CHECKPOINT_MARK() below */
#include "rte/utils/status/rte_status.h"
 
#include "common_config.h" /* RBC_ENVELOPE_WIRE_SIZE - the GP-calls-into-GA surface below */
#include "site_config.h"   /* rte_example_site_t - same */
#include "ab_siteGA.h"      /* ab_site_ga_route_layout_t - ab_gp_proc_ma_remaining_length_m()
                              * below, GA-calls-into-GP direction, needs GA's own route type */
 
/* Genuinely shared between GP (ab_gp_db.h/.c's own route-per-train
 * tracking) and GA (this header's own ab_gp_db_train_get_routes field
 * signature below) - guarded, not `#include`d from common_config.h, so
 * this header stays a self-contained export GA's separate build doesn't
 * need any other GP-internal header for. Matched by an identical guarded
 * copy in common_config.h - whichever is included first wins, same
 * pattern this file's own opaque-type guards already use. */
#ifndef RTE_EXAMPLE_MAX_ROUTES_PER_TRAIN
#define RTE_EXAMPLE_MAX_ROUTES_PER_TRAIN 4U
#endif

#ifndef AB_GP_DB_T_DEFINED
#define AB_GP_DB_T_DEFINED
typedef struct ab_gp_db_s ab_gp_db_t;
#endif

#ifndef TRAIN_SESSION_T_DEFINED
#define TRAIN_SESSION_T_DEFINED
typedef struct train_session_s ab_gp_train_session_t;
#endif

#ifndef AB_GP_DB_ROUTE_IL_STATUS_T_DEFINED
#define AB_GP_DB_ROUTE_IL_STATUS_T_DEFINED
typedef enum
{
    AB_GP_DB_ROUTE_IL_STATUS_UNKNOWN = 0,
    AB_GP_DB_ROUTE_IL_STATUS_FREE,
    AB_GP_DB_ROUTE_IL_STATUS_RESERVED,
    AB_GP_DB_ROUTE_IL_STATUS_LOCKED
} ab_gp_db_route_il_status_t;
#endif

#ifndef AB_GP_ROUTE_UPDATE_TYPE_T_DEFINED
#define AB_GP_ROUTE_UPDATE_TYPE_T_DEFINED
typedef enum
{
    AB_ROUTE_ADDED,
    AB_ROUTE_STATUS_CHANGED,
    AB_ROUTE_CONNECTED,
    AB_ROUTE_DISCONNECTED
} ab_gp_route_update_type_t;
#endif
 
#ifndef AB_GP_ROUTE_CONTEXT_T_DEFINED
#define AB_GP_ROUTE_CONTEXT_T_DEFINED
typedef struct
{
    uint16_t                   id;
    uint16_t                   start_signal;
    uint16_t                   end_signal;
    ab_gp_db_route_il_status_t il_status;
    uint32_t                   route_type;
    bool                       used_in_ma;
    uint8_t                    train_id;
} ab_gp_route_context_t;
#endif
 
#ifndef AB_GP_DB_ROUTE_NOTIFY_FN_DEFINED
#define AB_GP_DB_ROUTE_NOTIFY_FN_DEFINED
typedef void (*ab_gp_route_context_notify_fn)(const void *context, const ab_gp_route_context_t *ctx,
                                            ab_gp_route_update_type_t update_type);
#endif

#ifndef AB_GP_TRAIN_UPDATE_TYPE_T_DEFINED
#define AB_GP_TRAIN_UPDATE_TYPE_T_DEFINED
typedef enum
{
    AB_TRAIN_REGISTERED,
    AB_TRAIN_REMOVED,
    AB_TRAIN_POSITION,
    AB_TRAIN_MA_CHANGED,
    AB_TRAIN_EMERGENCY_REACTION_RAISED
} ab_gp_train_update_type_t;
#endif
 
#ifndef AB_GP_TRAIN_CONTEXT_T_DEFINED
#define AB_GP_TRAIN_CONTEXT_T_DEFINED
typedef struct
{
    uint8_t  train_id;
    bool     in_use;
    uint32_t cycle;
    uint32_t d_lrbg;
    uint32_t nid_lrbg;
    uint32_t v_train;
    uint32_t m_mode;
    uint32_t granted_length;
    uint32_t ma_seq;
    bool     ma_acked;
    bool     has_ma;
    bool     ma_pending_send;
    bool     ctc_connected_sent;
    bool     ctc_ma_granted_sent;
    bool     ctc_ma_notify_pending;
    uint16_t route_ids[RTE_EXAMPLE_MAX_ROUTES_PER_TRAIN];
    uint8_t  route_count;
} ab_gp_train_context_t;
#endif
 
#ifndef AB_GP_TRAIN_NOTIFY_FN_DEFINED
#define AB_GP_TRAIN_NOTIFY_FN_DEFINED
typedef void (*ab_gp_train_context_notify_fn)(const void *context, const ab_gp_train_context_t *ctx,
                                            ab_gp_train_update_type_t update_type);
#endif
 
#ifndef AB_GP_LOGIC_ROUTE_VALIDATOR_FN_DEFINED
#define AB_GP_LOGIC_ROUTE_VALIDATOR_FN_DEFINED
typedef bool (*ab_gp_logic_route_validator_fn)(void *context, uint16_t route_id, uint8_t train_id);
#endif


bool ab_gp_db_route_exists(const ab_gp_db_t *db, uint16_t route_id);
bool ab_gp_db_route_add(ab_gp_db_t *db, uint16_t route_id, uint16_t start_signal, uint16_t end_signal);
bool ab_gp_db_route_remove(ab_gp_db_t *db, uint16_t route_id);
bool ab_gp_db_route_set_status(ab_gp_db_t *db, uint16_t route_id, ab_gp_db_route_il_status_t status);
bool ab_gp_db_route_set_type(ab_gp_db_t *db, uint16_t route_id, uint32_t route_type);
bool ab_gp_db_route_set_fsm_state(ab_gp_db_t *db, uint16_t route_id, uint32_t fsm_state);
uint32_t ab_gp_db_route_get_fsm_state(const ab_gp_db_t *db, uint16_t route_id);
bool ab_gp_db_route_connect_train(ab_gp_db_t *db, uint16_t route_id, uint8_t train_id);
bool ab_gp_db_route_disconnect_train(ab_gp_db_t *db, uint16_t route_id);

bool ab_gp_train_set_has_ma(ab_gp_db_t *db, uint8_t train_id, bool has_ma);
bool ab_gp_train_get_last_position(const ab_gp_db_t *db, uint8_t train_id, uint32_t *out_nid_lrbg);

rte_status_t ab_gp_db_register_route_context_notify(ab_gp_route_context_notify_fn fn, const void *context);
bool ab_gp_db_get_route_context(const ab_gp_db_t *db, uint16_t route_id, ab_gp_route_context_t *out_ctx);

uint32_t ab_gp_proc_ma_remaining_length_m(const ab_site_ga_route_layout_t *route, uint32_t nid_lrbg, uint32_t d_lrbg_m);

bool ab_gp_train_session_add_granted_length(ab_gp_train_session_t *sessions, uint8_t train_id, uint32_t delta);
bool ab_gp_train_session_set_granted_length(ab_gp_train_session_t *sessions, uint8_t train_id,
                                             uint32_t granted_length);
bool ab_gp_train_session_increment_ma_seq(ab_gp_train_session_t *sessions, uint8_t train_id);
bool ab_gp_train_session_set_ma_pending_send(ab_gp_train_session_t *sessions, uint8_t train_id, bool pending);
bool ab_gp_train_session_set_ma_acked(ab_gp_train_session_t *sessions, uint8_t train_id, bool acked);
bool ab_gp_train_session_set_ctc_connected_sent(ab_gp_train_session_t *sessions, uint8_t train_id, bool sent);
bool ab_gp_train_session_set_ctc_ma_granted_sent(ab_gp_train_session_t *sessions, uint8_t train_id, bool sent);
bool ab_gp_train_session_set_ctc_ma_notify_pending(ab_gp_train_session_t *sessions, uint8_t train_id, bool pending);

rte_status_t ab_gp_register_train_context_notify(ab_gp_train_context_notify_fn fn, const void *context);
bool ab_gp_get_train_context(const ab_gp_train_session_t *sessions, const ab_gp_db_t *db, uint8_t train_id,
                              ab_gp_train_context_t *out_ctx);
void ab_gp_train_notify_context_changed(const ab_gp_train_session_t *sessions, const ab_gp_db_t *db,
                                         uint8_t train_id, ab_gp_train_update_type_t update_type);

rte_status_t ab_gp_ga_register_init(ab_gp_logic_route_validator_fn fn, void *context);

#ifndef AB_GP_LOGIC_SHUNTING_VALIDATOR_FN_DEFINED
#define AB_GP_LOGIC_SHUNTING_VALIDATOR_FN_DEFINED
typedef bool (*ab_gp_logic_shunting_validator_fn)(void *context, uint8_t train_id);
#endif
rte_status_t ab_gp_ga_register_shunting_validator(ab_gp_logic_shunting_validator_fn fn, void *context);



rte_status_t ab_ga_ma_adaptation_init(ab_gp_train_session_t *sessions, ab_gp_db_t *db, rte_example_site_t site,
                                        const char *role_tag);

#ifndef AB_GP_IL_ENVELOPE_HANDLER_FN_DEFINED
#define AB_GP_IL_ENVELOPE_HANDLER_FN_DEFINED
typedef bool (*ab_gp_il_envelope_handler_fn)(const void *context, ab_gp_train_session_t *sessions, ab_gp_db_t *db,
                                              const uint8_t env_bytes[RBC_ENVELOPE_WIRE_SIZE], uint32_t cycle,
                                              rte_example_site_t site, const char *role_tag);
#endif
rte_status_t ab_gp_register_il_envelope_handler(ab_gp_il_envelope_handler_fn fn, const void *context);

#ifndef AB_GP_IL_PENDING_OUTPUT_T_DEFINED
#define AB_GP_IL_PENDING_OUTPUT_T_DEFINED
typedef struct
{
    uint8_t bytes[RBC_ENVELOPE_WIRE_SIZE];
    char    tag[16];
    uint8_t index; /* which IL relay channel (train slot) this entry goes out on */
} ab_gp_il_pending_output_t;
#endif
#ifndef AB_GP_IL_MAX_PENDING_OUTPUTS
/* x2: each route change now emits BOTH a legacy TRAIN_POSITION_IN_ROUTE
 * frame AND a richer RBC_MSG_IL_ROUTE_INDICATION frame (ab_ga_il.c's own
 * build_outputs()) - same "widen the cap for a second per-item output"
 * step ab_ga_ctc.c's AB_GA_CTC_MAX_PENDING_OUTPUTS already took. */
#define AB_GP_IL_MAX_PENDING_OUTPUTS (RTE_EXAMPLE_MAX_ROUTES * 2U)
#endif
#ifndef AB_GP_IL_OUTPUT_PRODUCER_FN_DEFINED
#define AB_GP_IL_OUTPUT_PRODUCER_FN_DEFINED
typedef uint8_t (*ab_gp_il_output_producer_fn)(const void *context,
                                                ab_gp_il_pending_output_t out[AB_GP_IL_MAX_PENDING_OUTPUTS]);
typedef void (*ab_gp_il_output_confirm_fn)(const void *context);
#endif
rte_status_t ab_gp_register_il_output_producer(ab_gp_il_output_producer_fn fn, ab_gp_il_output_confirm_fn confirm_fn,
                                                 const void *context);
 
#ifndef AB_GP_CTC_PENDING_OUTPUT_T_DEFINED
#define AB_GP_CTC_PENDING_OUTPUT_T_DEFINED
typedef struct
{
    uint8_t bytes[RBC_ENVELOPE_WIRE_SIZE];
    char    tag[16];
} ab_gp_ctc_pending_output_t;
#endif
#ifndef AB_GP_CTC_MAX_PENDING_OUTPUTS
#define AB_GP_CTC_MAX_PENDING_OUTPUTS ((uint8_t)(RTE_EXAMPLE_MAX_TRAINS * 3U))
#endif
#ifndef AB_GP_CTC_OUTPUT_PRODUCER_FN_DEFINED
#define AB_GP_CTC_OUTPUT_PRODUCER_FN_DEFINED
typedef uint8_t (*ab_gp_ctc_output_producer_fn)(const void *context,
                                                 ab_gp_ctc_pending_output_t out[AB_GP_CTC_MAX_PENDING_OUTPUTS]);
typedef void (*ab_gp_ctc_output_confirm_fn)(const void *context);
#endif
rte_status_t ab_gp_register_ctc_output_producer(ab_gp_ctc_output_producer_fn fn,
                                                  ab_gp_ctc_output_confirm_fn confirm_fn, const void *context);


#define AB_GA_CHECKPOINT_MARK() RTE_CHECKPOINT_MARK()
 
#endif /* RTE_EXAMPLE_GA_INTERFACE_H */