ab_ga_ma_logic_adaptation.c

Go to the documentation of this file.

#include "ab_ga_ma_logic_adaptation.h"
 
#include "rte/oal/log/rte_log.h"
 
#include "common_config.h" /* RTE_EXAMPLE_LOG - this module's own setup-failure log, see
                                              * ab_ga_ma_adaptation_init()'s own doc, ga_interface.h */
#include "ab_siteGA.h" /* ab_site_ga_route_layout_t - GA's own reduced site header, implemented by
                         * safeAPIRBC2oo2SA (sa::site::ga), same direct-include posture as every
                         * other GA module (ga_interface.h's own doc) */
#include "../main/ab_ga_dispatch.h" /* ab_ga_dispatch_init() - GA's single GP-notification
                                      * subscriber, see that file's own doc */
#include "../il/ab_ga_il.h"           /* ab_ga_il_site_has_route()/_route_exists() - used by
                                        * this file's own validate_route_assignment() below */


typedef struct
{
    const ab_gp_train_session_t *sessions;
    const ab_gp_db_t            *db;
} ab_ga_shunting_context_t;

/* One GA instance per process/channel, set once by ab_ga_ma_adaptation_init() during setup. */
static ab_ga_shunting_context_t g_shunting_context;

const char *g_ga_role_tag = "";

static bool train_holds_preceding_route(const ab_gp_db_t *db, const ab_site_ga_route_layout_t *layout, uint8_t train_id);
static bool validate_route_assignment(void *context, uint16_t route_id, uint8_t train_id);
static bool validate_shunting_request(void *context, uint8_t train_id);
 

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)
{
    rte_status_t status;
 
    g_ga_role_tag = role_tag;
 
    status = ab_gp_ga_register_init(validate_route_assignment, (void *)db);
    if (status == RTE_STATUS_OK)
    {
        g_shunting_context.sessions = sessions;
        g_shunting_context.db = db;
        status = ab_gp_ga_register_shunting_validator(validate_shunting_request, (void *)&g_shunting_context);
    }
    if (status == RTE_STATUS_OK)
    {
        /* GA's single dispatch module (ab_ga_dispatch.c) - the only
         * thing that registers a route-context/train-context/IL-envelope/
         * IL-CTC-output-producer subscription with GP now, fanning out to
         * il/ctc internally. Replaces the old
         * ab_ga_il_init(role_tag)/ab_ga_ctc_init(role_tag) pair
         * (interface-simplification pass). */
        status = ab_ga_dispatch_init(sessions, db);
    }
    if (status != RTE_STATUS_OK)
    {
        RTE_EXAMPLE_LOG("[%s] GA registration -> %s\n", role_tag, rte_status_to_string(status));
        rte_log_write_event(RTE_LOG_LEVEL_ERROR, site_config_name(site), 0U, role_tag, "-", "GA",
                              "GA registration failed", NULL);
    }
    return status;
}
 
 
/****Local functions ****/

static bool train_holds_preceding_route(const ab_gp_db_t *db, const ab_site_ga_route_layout_t *layout, uint8_t train_id)
{
    ab_gp_route_context_t prev_ctx;
    size_t i;
 
    /* 1. Direct predecessor by prev_route_id */
    if (layout->prev_route_id != 0U)
    {
        if (ab_gp_db_get_route_context(db, layout->prev_route_id, &prev_ctx))
        {
            if (prev_ctx.used_in_ma && (prev_ctx.train_id == train_id))
            {
                return true;
            }
        }
    }
 
    /* 2. Any route ending at candidate route's start signal held by this train */
    for (i = 0U; i < ab_site_ga_track_layout_count; i++)
    {
        if (ab_site_ga_track_layout[i].end_signal == layout->start_signal)
        {
            if (ab_gp_db_get_route_context(db, ab_site_ga_track_layout[i].id, &prev_ctx))
            {
                if (prev_ctx.used_in_ma && (prev_ctx.train_id == train_id))
                {
                    return true;
                }
            }
        }
    }
 
    return false;
}

static bool validate_route_assignment(void *context, uint16_t route_id, uint8_t train_id)
{
    const ab_gp_db_t             *db = (const ab_gp_db_t *)context;
    const ab_site_ga_route_layout_t *layout = NULL;
    uint32_t                     last_nid_lrbg = 0U;
    bool                         balise_found = false;
    uint8_t                      b;
 
    if (!ab_ga_il_site_has_route(route_id, &layout))
    {
        return false; /* not a route this site's own layout knows about */
    }
    if (!ab_gp_db_route_exists(db, route_id))
    {
        return false; /* route not set/locked by Interlocking in DB */
    }
    /*  If train has a last position inside the route then allow to send MA */
    if (ab_gp_train_get_last_position(db, train_id, &last_nid_lrbg) && (last_nid_lrbg != 0U))
    {
        if (layout->balise_count == 0U)
        {
            return true;
        }
        for (b = 0U; b < layout->balise_count; b++)
        {
            if (layout->balise_nid_lrbgs[b] == last_nid_lrbg)
            {
                rte_log_write_event(RTE_LOG_LEVEL_INFO, g_ga_role_tag,
                                      0U, "GA", "GP", "ROUTE_VALIDATION",
                                      "train's last position matches route balise", NULL);
                balise_found = true;
                break;
            }
        }
        if (!balise_found)
        {
            if (train_holds_preceding_route(db, layout, train_id))
            {
                rte_log_write_event(RTE_LOG_LEVEL_INFO, g_ga_role_tag,
                                      0U, "GA", "GP", "ROUTE_VALIDATION",
                                      "route is extension of route held by train", NULL);
                return true;
            }
 
            rte_log_write_event(RTE_LOG_LEVEL_WARNING, g_ga_role_tag,
                                  0U, "GA", "GP", "ROUTE_VALIDATION",
                                  "train's last position does NOT match any route balise and not an extension", NULL);
            return false; /* reported balise does not match this route */
        }
    }
 
    return true;
}

static bool validate_shunting_request(void *context, uint8_t train_id)
{
    const ab_ga_shunting_context_t *sc = (const ab_ga_shunting_context_t *)context;
    ab_gp_train_context_t          train_ctx;
 
    if ((sc == NULL) || (sc->sessions == NULL) || (sc->db == NULL)
        || !ab_gp_get_train_context(sc->sessions, sc->db, train_id, &train_ctx))
    {
        return false;
    }
    if ((train_ctx.route_count > 0U) || train_ctx.has_ma)
    {
        rte_log_write_event(RTE_LOG_LEVEL_INFO, g_ga_role_tag, 0U, "GA", "GP", "SHUNTING_VALIDATION",
                            "SH refused: train holds a route or an active MA", NULL);
        return false;
    }
    return true;
}