rbc_wire_types.h

Go to the documentation of this file.

#ifndef RTE_EXAMPLE_RBC_WIRE_TYPES_H
#define RTE_EXAMPLE_RBC_WIRE_TYPES_H

 
#include <stdbool.h>
#include <stdint.h>
#include "rte/oal/memory/rte_mem_util.h"
 
#include "common_config.h"

typedef enum
{
    RBC_MSG_P0             = 0, 
    RBC_MSG_M136            = 1, 
    RBC_MSG_M24_M15          = 2, 
    RBC_MSG_ROUTE_ADD        = 3, 
    RBC_MSG_M3               = 4, 
    RBC_MSG_M146             = 5, 
    RBC_MSG_CTC_CONNECTED    = 6, 
    RBC_MSG_CTC_MA_GRANTED   = 7, 
    RBC_MSG_CTC_MA_EXTENDED  = 8, 
    RBC_MSG_RELAY_KEEPALIVE  = 9,
    RBC_MSG_ROUTE_RELEASE    = 10,
    RBC_MSG_TRAIN_POSITION_IN_ROUTE = 11,
    RBC_MSG_CTC_ALARM = 12,
    RBC_MSG_TSR_ADD = 13,
    RBC_MSG_TSR_REMOVE = 14,
    RBC_MSG_TEXT_MESSAGE = 15,
    RBC_MSG_TEXT_MESSAGE_ACK = 16,
    RBC_MSG_HANDOVER_ORDER = 17,
    RBC_MSG_SET_LOG_LEVEL = 18,
    RBC_MSG_SIM_STATUS = 19,
    RBC_MSG_TRAIN_DISCONNECT = 20,
    RBC_MSG_ERTMS_ENVELOPE = 22,
    RBC_MSG_ROUTE_STATUS_REPORT = 23,
    RBC_MSG_CTC_TRAIN_INFO = 24,

    RBC_MSG_IL_ROUTE_CMD = 25,
    RBC_MSG_IL_STATUS = 26,
    RBC_MSG_IL_ROUTE_INDICATION = 27,
    RBC_MSG_SAF_ENVELOPE = 28
} rbc_msg_kind_t;
 
/* ========================================================================= */
/* IL <-> RBC interface enums (dedicated IL messages 25/26/27)               */
/* All carried on the wire as a single uint8 unless noted; identity fields  */
/* (route_id/start_signal/end_signal/allocated_train_nid_engine) are int32   */
/* little-endian with -1 as the "unset" sentinel.                           */
/* ========================================================================= */

typedef enum
{
    RBC_IL_ROUTE_TYPE_NO_ROUTE = 0, 
    RBC_IL_ROUTE_TYPE_LOCKED   = 1  
} rbc_il_route_type_t;

typedef enum
{
    RBC_IL_ROUTE_STATUS_NO_STATUS = 0, 
    RBC_IL_ROUTE_STATUS_FS        = 1, 
    RBC_IL_ROUTE_STATUS_OS        = 2, 
    RBC_IL_ROUTE_STATUS_SH        = 3, 
    RBC_IL_ROUTE_STATUS_USED      = 4, 
    RBC_IL_ROUTE_STATUS_DEGRADED  = 5  
} rbc_il_route_status_t;

typedef enum
{
    RBC_IL_DEGRADED_STATUS_NO_STATUS = 0, 
    RBC_IL_DEGRADED_STATUS_LOW       = 1,
    RBC_IL_DEGRADED_STATUS_MEDIUM    = 2,
    RBC_IL_DEGRADED_STATUS_HIGH      = 3
} rbc_il_degraded_status_t;

typedef enum
{
    RBC_IL_STATUS_DOWN       = 0, 
    RBC_IL_STATUS_RESTARTING = 1, 
    RBC_IL_STATUS_UP         = 2  
} rbc_il_status_t;

typedef enum
{
    RBC_IL_EMERGENCY_TYPE_NONE = -1, 
    RBC_IL_EMERGENCY_TYPE_SAM  = 0,  
    RBC_IL_EMERGENCY_TYPE_CEM  = 1,  
    RBC_IL_EMERGENCY_TYPE_UEM  = 2   
} rbc_il_emergency_type_t;

typedef enum
{
    RBC_ALARM_SEVERITY_INFO    = 0, 
    RBC_ALARM_SEVERITY_WARNING = 1, 
    RBC_ALARM_SEVERITY_ERROR   = 2  
} rbc_alarm_severity_t;

typedef enum
{
    RBC_ROUTE_TYPE_FS = 0, 
    RBC_ROUTE_TYPE_OS = 1, 
    RBC_ROUTE_TYPE_SH = 2  
} rbc_route_type_t;

typedef enum
{
    RBC_ROUTE_STATUS_NO_TRAIN       = 0, 
    RBC_ROUTE_STATUS_TRAIN_IN_ROUTE = 1  
} rbc_route_status_t;

typedef struct
{
    rbc_msg_kind_t kind;         
    uint8_t        train_id;     
    uint8_t        nid_message;  
    uint16_t       l_message;    
    uint32_t       t_train;      
    uint32_t       cycle;        
    uint32_t       d_lrbg;       
    uint32_t       msg_type;     
    uint32_t       route_len;    
    uint32_t       ma_seq;       
    uint32_t       ma_length;    
    uint32_t       t_train_ack;  
    /* M136 only (REQ-RBC-001 revised): real Subset-026 Packet 0 "Position
     * Report" fields (SUBSET-026-7 section 7.4.3.1) - genuinely flat, no
     * N_ITER/nesting, so addable the same additive way as t_train_ack
     * above. d_lrbg (already existed) is that packet's own D_LRBG; these
     * ten are the rest of it. 0 when kind != RBC_MSG_M136 (not present on
     * the wire at all then - l_message says so). Real bit-widths are much
     * narrower than uint32 (e.g. Q_DIRLRBG is 2 bits, M_MODE is 4 bits) -
     * kept byte-aligned uint32 here for consistency with every other
     * field in this struct, not bit-packed - see this file's own header
     * for why (touching the 20+ rte_netlink_send()/_recv() call sites
     * for genuinely narrower transmitted fields is out of scope here). */
    uint32_t       nid_lrbg;     
    uint32_t       q_dirlrbg;    
    uint32_t       q_dlrbg;      
    uint32_t       l_doubtover;  
    uint32_t       l_doubtunder; 
    uint32_t       q_length;     
    uint32_t       v_train;      
    uint32_t       q_dirtrain;   
    uint32_t       m_mode;       
    uint32_t       m_level;      
    /* ROUTE_ADD/ROUTE_RELEASE/TRAIN_POSITION_IN_ROUTE only - appended
     * after the M136 block above, same additive-growth precedent
     * t_train_ack/the M136 block itself already set (this struct has
     * been grown this way twice before; never by repurposing an existing
     * field's meaning for a different kind). Route identity on the wire
     * is (start_signal, end_signal) - the signal pair a route runs
     * between (safeAPIRBC2oo2GA/include/ab_siteGA.h's own ab_site_ga_route_layout_t (route topology moved out of GP this session)), not a
     * synthetic id - ROUTE_ADD/ROUTE_RELEASE both carry it; the RBC side
     * resolves it to its own internal route_id via
     * ab_ga_il_site_has_route_by_signals() before touching db->routes[].
     * 0 when kind doesn't use a given field (not present on the wire at
     * all then - l_message says so, same convention as every field
     * above). */
    uint32_t       start_signal; 
    uint32_t       end_signal;   
    uint32_t       route_type;   
    uint32_t       route_status; 
} rbc_envelope_t;

static inline void rbc_envelope_write_keepalive(uint8_t out[RBC_ENVELOPE_WIRE_SIZE])
{
    rte_mem_set(out, 0, RBC_ENVELOPE_WIRE_SIZE);
    out[0] = (uint8_t)RBC_MSG_RELAY_KEEPALIVE;
}

static inline bool rbc_envelope_is_keepalive(const uint8_t in[RBC_ENVELOPE_WIRE_SIZE])
{
    return in[0] == (uint8_t)RBC_MSG_RELAY_KEEPALIVE;
}

static inline void rbc_envelope_write_set_log_level(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], uint8_t level)
{
    rte_mem_set(out, 0, RBC_ENVELOPE_WIRE_SIZE);
    out[0] = (uint8_t)RBC_MSG_SET_LOG_LEVEL;
    out[1] = level;
}

static inline bool rbc_envelope_is_set_log_level(const uint8_t in[RBC_ENVELOPE_WIRE_SIZE], uint8_t *out_level)
{
    bool match = (in[0] == (uint8_t)RBC_MSG_SET_LOG_LEVEL);
 
    if (match && (out_level != NULL))
    {
        *out_level = in[1];
    }
    return match;
}

static inline void rbc_envelope_write_sim_status(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], const char *payload)
{
    uint16_t n = 0U;
 
    rte_mem_set(out, 0, RBC_ENVELOPE_WIRE_SIZE);
    out[0] = (uint8_t)RBC_MSG_SIM_STATUS;
    if (payload != NULL)
    {
        while ((n < (uint16_t)(RBC_ENVELOPE_WIRE_SIZE - 2U)) && (payload[n] != '\0'))
        {
            out[2U + n] = (uint8_t)payload[n];
            n++;
        }
    }
    out[1] = (uint8_t)n;
}

static inline bool rbc_envelope_is_sim_status(const uint8_t in[RBC_ENVELOPE_WIRE_SIZE], char *out_payload,
                                              uint16_t out_size)
{
    uint16_t n;
    uint16_t i;
 
    if (in[0] != (uint8_t)RBC_MSG_SIM_STATUS)
    {
        return false;
    }
    if ((out_payload != NULL) && (out_size > 0U))
    {
        n = (uint16_t)in[1];
        if (n > (uint16_t)(RBC_ENVELOPE_WIRE_SIZE - 2U))
        {
            n = (uint16_t)(RBC_ENVELOPE_WIRE_SIZE - 2U);
        }
        if (n > (uint16_t)(out_size - 1U))
        {
            n = (uint16_t)(out_size - 1U);
        }
        for (i = 0U; i < n; i++)
        {
            out_payload[i] = (char)in[2U + i];
        }
        out_payload[n] = '\0';
    }
    return true;
}

#define RBC_ENVELOPE_QUEUE_CAPACITY 16U
 
typedef struct
{
    volatile uint32_t write_index; /* producer-owned - see this struct's own doc */
    volatile uint32_t read_index;  /* consumer-owned */
    uint8_t            entries[RBC_ENVELOPE_QUEUE_CAPACITY][RBC_ENVELOPE_WIRE_SIZE];
} rbc_envelope_queue_t;
 
static inline void rbc_envelope_queue_init(rbc_envelope_queue_t *queue)
{
    queue->write_index = 0U;
    queue->read_index = 0U;
}

static inline bool rbc_envelope_queue_push(rbc_envelope_queue_t *queue, const uint8_t bytes[RBC_ENVELOPE_WIRE_SIZE])
{
    uint32_t w = queue->write_index;
    uint32_t r = queue->read_index;
 
    if ((w - r) >= (uint32_t)RBC_ENVELOPE_QUEUE_CAPACITY)
    {
        return false;
    }
    rte_mem_copy(queue->entries[w % (uint32_t)RBC_ENVELOPE_QUEUE_CAPACITY], bytes, RBC_ENVELOPE_WIRE_SIZE);
    queue->write_index = w + 1U;
    return true;
}

static inline bool rbc_envelope_queue_pop(rbc_envelope_queue_t *queue, uint8_t out_bytes[RBC_ENVELOPE_WIRE_SIZE])
{
    uint32_t w = queue->write_index;
    uint32_t r = queue->read_index;
 
    if (r == w)
    {
        return false;
    }
    rte_mem_copy(out_bytes, queue->entries[r % (uint32_t)RBC_ENVELOPE_QUEUE_CAPACITY], RBC_ENVELOPE_WIRE_SIZE);
    queue->read_index = r + 1U;
    return true;
}
 
#endif /* RTE_EXAMPLE_RBC_WIRE_TYPES_H */