ab_ga_il_wire.c

Go to the documentation of this file.

 
#include "ab_ga_il_wire.h"
 
#include "safeapi/oal/memory/sapi_mem_util.h"
#include "safeapi/utils/buffer/sapi_buffer.h"
 
/* ---- little-endian int32 helpers (the flat IL codec uses sapi_buffer for
 *      u16/u32 and raw byte indexing for u8; do the same here, plus this
 *      one wrapper so the -1 sentinel round-trips as a bit pattern). ---- */
 
static bool read_i32_le(const uint8_t *frame, size_t off, int32_t *out)
{
    sapi_buffer_t buf;
    uint32_t raw = 0U;
 
    if (sapi_buffer_init(&buf, (uint8_t *)frame, RBC_ENVELOPE_WIRE_SIZE) != SAPI_STATUS_OK)
    {
        return false;
    }
    (void)sapi_buffer_set_length(&buf, RBC_ENVELOPE_WIRE_SIZE);
    if (sapi_buffer_read_u32_le(&buf, off, &raw) != SAPI_STATUS_OK)
    {
        return false;
    }
    *out = (int32_t)raw;
    return true;
}
 
static void write_i32_le(uint8_t *frame, size_t off, int32_t value)
{
    sapi_buffer_t buf;
 
    if (sapi_buffer_init(&buf, frame, RBC_ENVELOPE_WIRE_SIZE) != SAPI_STATUS_OK)
    {
        return;
    }
    (void)sapi_buffer_set_length(&buf, off);
    (void)sapi_buffer_write_u32_le(&buf, (uint32_t)value);
}
 
/* ---- range checks -------------------------------------------------------- */
 
static bool id_field_valid(int32_t v)
{
    /* -1 (unset) or any non-negative id. */
    return (v >= -1);
}
 
static bool flag_valid(uint8_t v)
{
    return (v <= 1U);
}
 
/* ---- decode ------------------------------------------------------------- */
 
bool ab_ga_il_wire_decode_route_cmd(const uint8_t frame[RBC_ENVELOPE_WIRE_SIZE],
                                    ab_ga_il_route_cmd_t *out)
{
    ab_ga_il_route_cmd_t d;
    uint8_t route_type;
    uint8_t route_status;
    uint8_t degraded_status;
    uint8_t release_req;
    uint8_t first_in_path;
 
    if ((frame == NULL) || (out == NULL) || (frame[0] != (uint8_t)RBC_MSG_IL_ROUTE_CMD))
    {
        return false;
    }
 
    route_type      = frame[2];
    route_status    = frame[3];
    degraded_status = frame[4];
    release_req     = frame[5];
    first_in_path   = frame[6];
 
    if (route_type > (uint8_t)RBC_IL_ROUTE_TYPE_LOCKED)
    {
        return false;
    }
    if (route_status > (uint8_t)RBC_IL_ROUTE_STATUS_DEGRADED)
    {
        return false;
    }
    if (degraded_status > (uint8_t)RBC_IL_DEGRADED_STATUS_HIGH)
    {
        return false;
    }
    if (!flag_valid(release_req) || !flag_valid(first_in_path))
    {
        return false;
    }
 
    if (!read_i32_le(frame, 8U, &d.route_id) ||
        !read_i32_le(frame, 12U, &d.start_signal) ||
        !read_i32_le(frame, 16U, &d.end_signal))
    {
        return false;
    }
    if (!id_field_valid(d.route_id) || !id_field_valid(d.start_signal) || !id_field_valid(d.end_signal))
    {
        return false;
    }
 
    d.route_type            = (rbc_il_route_type_t)route_type;
    d.route_status          = (rbc_il_route_status_t)route_status;
    d.degraded_status       = (rbc_il_degraded_status_t)degraded_status;
    d.release_route_request = (release_req == 1U);
    d.first_route_in_path   = (first_in_path == 1U);
 
    *out = d;
    return true;
}
 
bool ab_ga_il_wire_decode_status(const uint8_t frame[RBC_ENVELOPE_WIRE_SIZE],
                                 ab_ga_il_status_msg_t *out)
{
    uint8_t il_status;
 
    if ((frame == NULL) || (out == NULL) || (frame[0] != (uint8_t)RBC_MSG_IL_STATUS))
    {
        return false;
    }
    il_status = frame[1];
    if (il_status > (uint8_t)RBC_IL_STATUS_UP)
    {
        return false;
    }
    out->il_status = (rbc_il_status_t)il_status;
    return true;
}
 
/* ---- encode ----------------------------------------------------------- */
 
void ab_ga_il_wire_encode_route_indication(uint8_t frame[RBC_ENVELOPE_WIRE_SIZE],
                                           const ab_ga_il_route_indication_t *in)
{
    if ((frame == NULL) || (in == NULL))
    {
        return;
    }
 
    sapi_mem_set(frame, 0, RBC_ENVELOPE_WIRE_SIZE);
    frame[0] = (uint8_t)RBC_MSG_IL_ROUTE_INDICATION;
    frame[1] = 0U;
    frame[2] = in->train_in_route ? 1U : 0U;
    frame[3] = in->train_has_ma_in_route ? 1U : 0U;
    frame[4] = in->emergency_in_route ? 1U : 0U;
    /* emergency_type is a SIGNED int8 on the wire (-1 = none). */
    frame[5] = (uint8_t)(int8_t)in->emergency_type;
    frame[6] = in->route_fsm_state;
    frame[7] = in->route_fsm_is_stub ? 1U : 0U;
 
    write_i32_le(frame, 8U, in->route_id);
    write_i32_le(frame, 12U, in->start_signal);
    write_i32_le(frame, 16U, in->end_signal);
    write_i32_le(frame, 20U, in->allocated_train_nid_engine);
}