ab_gp_proc_tsr.c

Go to the documentation of this file.

 
#include "ab_gp_proc_tsr.h"
#include "rte/oal/memory/rte_mem_util.h"
#include "rte/utils/cast/rte_cast.h"
 
/* REQ-ID: RBC_ERTMS_TSR_001 - Static TSR Table Initialization */
void ab_gp_proc_tsr_init(ab_gp_ertms_train_context_t *ctx)
{
    uint8_t i;
 
    if (ctx == NULL)
    {
        return;
    }
 
    for (i = 0U; i < (uint8_t)RBC_MAX_TSR_ITEMS; i++)
    {
        ctx->tsrs[i].is_active = false;
        ctx->tsrs[i].nid_tsr = 0U;
        ctx->tsrs[i].v_tsr_kmh = 0U;
        ctx->tsrs[i].d_tsr_start_m = 0U;
        ctx->tsrs[i].d_tsr_end_m = 0U;
    }
}
 
/* REQ-ID: RBC_ERTMS_TSR_002 - Add TSR to Supervised Path */
bool ab_gp_proc_tsr_add(ab_gp_ertms_train_context_t *ctx,
                        uint8_t nid_tsr,
                        uint32_t v_tsr_kmh,
                        uint32_t d_start_m,
                        uint32_t d_end_m)
{
    uint8_t i;
    int32_t free_slot = -1;
 
    if ((ctx == NULL) || (nid_tsr == 0U) || (d_end_m <= d_start_m))
    {
        return false;
    }
 
    /* Check if already present to update, or find free slot */
    for (i = 0U; i < (uint8_t)RBC_MAX_TSR_ITEMS; i++)
    {
        if (ctx->tsrs[i].is_active && (ctx->tsrs[i].nid_tsr == nid_tsr))
        {
            /* Update existing TSR */
            ctx->tsrs[i].v_tsr_kmh = v_tsr_kmh;
            ctx->tsrs[i].d_tsr_start_m = d_start_m;
            ctx->tsrs[i].d_tsr_end_m = d_end_m;
            return true;
        }
        if (!ctx->tsrs[i].is_active && (free_slot < 0))
        {
            free_slot = (int32_t)i;
        }
    }
 
    if (free_slot < 0)
    {
        return false; /* TSR table full */
    }
 
    ctx->tsrs[(uint32_t)free_slot].is_active = true;
    ctx->tsrs[(uint32_t)free_slot].nid_tsr = nid_tsr;
    ctx->tsrs[(uint32_t)free_slot].v_tsr_kmh = v_tsr_kmh;
    ctx->tsrs[(uint32_t)free_slot].d_tsr_start_m = d_start_m;
    ctx->tsrs[(uint32_t)free_slot].d_tsr_end_m = d_end_m;
 
    return true;
}
 
/* REQ-ID: RBC_ERTMS_TSR_003 - Revoke TSR from Path */
bool ab_gp_proc_tsr_remove(ab_gp_ertms_train_context_t *ctx, uint8_t nid_tsr)
{
    uint8_t i;
 
    if ((ctx == NULL) || (nid_tsr == 0U))
    {
        return false;
    }
 
    for (i = 0U; i < (uint8_t)RBC_MAX_TSR_ITEMS; i++)
    {
        if (ctx->tsrs[i].is_active && (ctx->tsrs[i].nid_tsr == nid_tsr))
        {
            ctx->tsrs[i].is_active = false;
            ctx->tsrs[i].nid_tsr = 0U;
            ctx->tsrs[i].v_tsr_kmh = 0U;
            ctx->tsrs[i].d_tsr_start_m = 0U;
            ctx->tsrs[i].d_tsr_end_m = 0U;
            return true;
        }
    }
 
    return false;
}
 
/* REQ-ID: RBC_ERTMS_TSR_004 - Packet 65 Generation */
bool ab_gp_proc_tsr_generate_packet_65(const ab_gp_ertms_train_context_t *ctx,
                                       uint8_t nid_tsr,
                                       rbc_packet_65_tsr_t *out_p65)
{
    uint8_t i;
 
    if ((ctx == NULL) || (out_p65 == NULL) || (nid_tsr == 0U))
    {
        return false;
    }
 
    for (i = 0U; i < (uint8_t)RBC_MAX_TSR_ITEMS; i++)
    {
        if (ctx->tsrs[i].is_active && (ctx->tsrs[i].nid_tsr == nid_tsr))
        {
            out_p65->nid_tsr = nid_tsr;
            out_p65->d_tsr = ctx->tsrs[i].d_tsr_start_m;
            (void)rte_cast_checked_sub_u32(ctx->tsrs[i].d_tsr_end_m, ctx->tsrs[i].d_tsr_start_m, &out_p65->l_tsr);
            if (rte_cast_u32_to_u16(ctx->tsrs[i].v_tsr_kmh, &out_p65->v_tsr) != RTE_STATUS_OK)
            {
                return false; /* speed does not fit the 16-bit wire field */
            }
            out_p65->q_front = RBC_Q_FRONT_TRAIN_LENGTH_DELAY;
            return true;
        }
    }
 
    return false;
}
 
/* REQ-ID: RBC_ERTMS_TSR_005 - Packet 66 Generation */
bool ab_gp_proc_tsr_generate_packet_66(uint8_t nid_tsr,
                                       rbc_packet_66_tsr_revoke_t *out_p66)
{
    if ((out_p66 == NULL) || (nid_tsr == 0U))
    {
        return false;
    }
 
    out_p66->nid_tsr = nid_tsr;
    return true;
}
 
/* REQ-ID: RBC_ERTMS_TSR_006 - Active Count Query */
uint8_t ab_gp_proc_tsr_get_active_count(const ab_gp_ertms_train_context_t *ctx)
{
    uint8_t i;
    uint8_t count = 0U;
 
    if (ctx == NULL)
    {
        return 0U;
    }
 
    for (i = 0U; i < (uint8_t)RBC_MAX_TSR_ITEMS; i++)
    {
        if (ctx->tsrs[i].is_active)
        {
            count++;
        }
    }
 
    return count;
}