ab_gp_ertms_train_message_codec.c

Go to the documentation of this file.

 
#include "ab_gp_ertms_train_message_codec.h"
 
#include "ab_gp_ertms_train_packet_codec.h"
#include "rte/oal/memory/rte_mem_util.h"

static void write_track_to_train_header(uint8_t *buf, size_t cap, size_t *offset,
                                        const rbc_track_to_train_header_t *h)
{
    (void)rbc_codec_write_u8(buf, cap, offset, h->nid_message);
    (void)rbc_codec_write_u16_be(buf, cap, offset, h->l_message);
    (void)rbc_codec_write_u32_be(buf, cap, offset, (uint32_t)(h->t_train & 0xFFFFFFFFU)); /* wire field is 32-bit (wraps) */
    (void)rbc_codec_write_u8(buf, cap, offset, (uint8_t)h->m_ack);
    (void)rbc_codec_write_u16_be(buf, cap, offset, h->nid_lrbg.nid_c);
    (void)rbc_codec_write_u16_be(buf, cap, offset, h->nid_lrbg.nid_bg);
}
 
bool rbc_train_codec_encode_track_to_train(const rbc_train_outbound_msg_t *msg,
                                           uint8_t *out_buffer,
                                           size_t buffer_size,
                                           size_t *out_bytes_written)
{
    size_t offset = 0U;
 
    if (msg == NULL || out_buffer == NULL || out_bytes_written == NULL || buffer_size < 32U)
    {
        return false;
    }
 
    switch (msg->nid_message)
    {
        case RBC_MSG_TRACK_TO_TRAIN_MOVEMENT_AUTHORITY:
        {
            const rbc_msg_3_movement_authority_t *m3 = &msg->payload.msg_3;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m3->header);
            (void)rbc_packet_write_15_ma(out_buffer, buffer_size, &offset, &m3->ma);
            if (m3->has_gradient)
            {
                (void)rbc_packet_write_21_gradient_profile(out_buffer, buffer_size, &offset, &m3->gradient);
            }
            if (m3->has_ssp)
            {
                (void)rbc_packet_write_27_ssp(out_buffer, buffer_size, &offset, &m3->ssp);
            }
            if (m3->has_linking)
            {
                (void)rbc_packet_write_5_linking(out_buffer, buffer_size, &offset, &m3->linking);
            }
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_CONDITIONAL_EMERGENCY_STOP:
        {
            const rbc_msg_15_ces_t *m15 = &msg->payload.msg_15;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m15->header);
            (void)rbc_codec_write_u8(out_buffer, buffer_size, &offset, m15->nid_em);
            (void)rbc_codec_write_u8(out_buffer, buffer_size, &offset, (uint8_t)m15->q_scale);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, m15->d_ref);
            (void)rbc_codec_write_u8(out_buffer, buffer_size, &offset, (uint8_t)m15->q_dir);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, m15->d_emergencystop);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_UNCONDITIONAL_EMERGENCY_STOP:
        {
            const rbc_msg_16_ues_t *m16 = &msg->payload.msg_16;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m16->header);
            (void)rbc_codec_write_u8(out_buffer, buffer_size, &offset, m16->nid_em);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_REVOCATION_EMERGENCY_STOP:
        {
            const rbc_msg_18_ces_revocation_t *m18 = &msg->payload.msg_18;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m18->header);
            (void)rbc_codec_write_u8(out_buffer, buffer_size, &offset, m18->nid_em);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_GENERAL_MESSAGE:
        {
            const rbc_msg_24_general_message_t *m24 = &msg->payload.msg_24;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m24->header);
            if (m24->has_national_values)
            {
                (void)rbc_packet_write_3_national_values(out_buffer, buffer_size, &offset, &m24->national_values);
            }
            if (m24->has_ma_request_params)
            {
                (void)rbc_packet_write_57_ma_request_params(out_buffer, buffer_size, &offset,
                                                             &m24->ma_request_params);
            }
            if (m24->has_pr_params)
            {
                (void)rbc_packet_write_58_pr_params(out_buffer, buffer_size, &offset, &m24->pr_params);
            }
            if (m24->has_tsr)
            {
                (void)rbc_packet_write_65_tsr(out_buffer, buffer_size, &offset, &m24->tsr);
            }
            if (m24->has_tsr_revoke)
            {
                (void)rbc_packet_write_66_tsr_revoke(out_buffer, buffer_size, &offset, &m24->tsr_revoke);
            }
            if (m24->has_text_message)
            {
                (void)rbc_packet_write_72_text_message(out_buffer, buffer_size, &offset, &m24->text_message);
            }
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_RBC_TRANSITION_ORDER:
        {
            /* NOTE (Subset-026 conformance): this codebase's own NID_MESSAGE 33
             * carries transition-target fields shaped like Packet 131 (RBC
             * transition order), not the real Subset-026 Message 33 ("MA with
             * Shifted Location Reference"). Per the real spec, RBC transition
             * is carried as a PACKET (131, or 31 for FRMCS) inside Message 24
             * (General Message), never a standalone NID_MESSAGE of its own.
             * Encoding here preserves this codebase's existing (pre-existing,
             * not introduced by this change) simplified numbering rather than
             * silently reassigning wire-visible message IDs - flagged for a
             * dedicated conformance pass, not fixed blind. */
            const rbc_msg_33_transition_order_t *m33 = &msg->payload.msg_33;
            rbc_packet_131_rbc_transition_t p131;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m33->header);
            p131.d_rbctr = m33->d_rbctr;
            p131.nid_c = m33->nid_c;
            p131.nid_rbc = m33->nid_rbc;
            p131.nid_radio = m33->nid_radio;
            p131.q_sleepingsession = false; /* not modeled by Msg 33's own field set */
            (void)rbc_packet_write_131_rbc_transition(out_buffer, buffer_size, &offset, &p131);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_SR_AUTHORISATION:
        {
            const rbc_msg_2_sr_authorisation_t *m2 = &msg->payload.msg_2;
            uint32_t d_sr_wire = m2->d_sr_unlimited ? 0xFFFFFFFFU : m2->d_sr;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m2->header);
            (void)rbc_codec_write_u8(out_buffer, buffer_size, &offset, (uint8_t)m2->q_scale);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, d_sr_wire);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_RECOGNITION_EXIT_SR:
        {
            /* NOTE: this codebase's own constant name is "RECOGNITION_EXIT_SR"
             * for NID_MESSAGE 6, while Subset-026 8.7.3 names Message 6
             * "Recognition of exit from TRIP mode" (SR has no "recognition of
             * exit" message of its own). Header-only either way, so the wire
             * bytes below are correct regardless of which reading is meant;
             * left the existing constant name alone rather than guess. */
            const rbc_msg_6_recognition_exit_trip_t *m6 = &msg->payload.msg_6;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m6->header);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_ACK_TRAIN_DATA:
        {
            const rbc_msg_8_ack_train_data_t *m8 = &msg->payload.msg_8;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m8->header);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, (uint32_t)m8->t_train_ref);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_SH_REFUSED:
        {
            const rbc_msg_27_sh_refused_t *m27 = &msg->payload.msg_27;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m27->header);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, (uint32_t)m27->t_train_ref);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_SH_AUTHORISED:
        {
            const rbc_msg_28_sh_authorised_t *m28 = &msg->payload.msg_28;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m28->header);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, (uint32_t)m28->t_train_ref);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_REQUEST_SHORTEN_MA:
        {
            const rbc_msg_9_request_shorten_ma_t *m9 = &msg->payload.msg_9;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m9->header);
            /* Packet 15: (shortened) MA - same rbc_packet_write_15_ma() call
             * Msg 3 already uses. */
            (void)rbc_packet_write_15_ma(out_buffer, buffer_size, &offset, &m9->ma);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_TRACK_AHEAD_FREE_REQUEST:
        {
            const rbc_msg_34_track_ahead_free_request_t *m34 = &msg->payload.msg_34;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m34->header);
            (void)rbc_codec_write_u8(out_buffer, buffer_size, &offset, (uint8_t)m34->q_scale);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, m34->d_ref);
            (void)rbc_codec_write_u8(out_buffer, buffer_size, &offset, (uint8_t)m34->q_dir);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, m34->d_tafdisplay);
            (void)rbc_codec_write_u32_be(out_buffer, buffer_size, &offset, m34->l_tafdisplay);
            break;
        }
 
        case RBC_MSG_TRACK_TO_TRAIN_SESSION_TERMINATION_ORDER:
        {
            /* NOTE (Subset-026 conformance, same posture as Msg 33/Msg 6 above):
             * this codebase's own NID_MESSAGE 41 is header-only, matching what
             * a "session termination order" would minimally need; the real
             * spec's own Message 41 is "Train Accepted" (also header-only, so
             * the wire bytes happen to coincide either way). Flagged, not
             * silently renumbered. */
            const rbc_msg_41_session_termination_order_t *m41 = &msg->payload.msg_41;
 
            write_track_to_train_header(out_buffer, buffer_size, &offset, &m41->header);
            break;
        }
 
        default:
            return false;
    }
 
    /* l_message is computed HERE, from the real total bytes written, not
     * trusted from the caller's own header.l_message (which every
     * handler in ab_gp_proc_dispatch.c leaves at 0, per this struct's
     * own zero-initialization) - same "l_message computed here, not
     * caller-supplied" discipline train_wire_encode() already applies to
     * the flat scheme. Patches bytes[1:3] (big-endian, right after the
     * 1-byte nid_message already written at bytes[0]) after the fact,
     * since the real length isn't known until encoding completes. */
    out_buffer[1] = (uint8_t)((offset >> 8) & 0xFFU);
    out_buffer[2] = (uint8_t)(offset & 0xFFU);
 
    *out_bytes_written = offset;
    return true;
}
 
 
bool rbc_train_codec_decode_train_to_track(const uint8_t *in_buffer,
                                           size_t buffer_size,
                                           rbc_train_inbound_msg_t *out_msg)
{
    size_t offset = 0U;
    uint8_t nid_message = 0U;
    uint16_t l_message = 0U;
    uint32_t t_train = 0U;
    uint32_t nid_engine = 0U;
 
    if (in_buffer == NULL || out_msg == NULL || buffer_size < 11U)
    {
        return false;
    }
 
    rte_mem_set(out_msg, 0, sizeof(*out_msg));
 
    /* Read Train-to-Track Header */
    if (!rbc_codec_read_u8(in_buffer, buffer_size, &offset, &nid_message) ||
        !rbc_codec_read_u16_be(in_buffer, buffer_size, &offset, &l_message) ||
        !rbc_codec_read_u32_be(in_buffer, buffer_size, &offset, &t_train) ||
        !rbc_codec_read_u32_be(in_buffer, buffer_size, &offset, &nid_engine))
    {
        return false;
    }
 
    out_msg->nid_message = nid_message;
 
    switch (nid_message)
    {
        case RBC_MSG_TRAIN_TO_TRACK_VALIDATED_TRAIN_DATA:
        {
            rbc_msg_129_validated_train_data_t *m129 = &out_msg->payload.msg_129;
            uint32_t l_train = 0U;
            uint16_t v_max = 0U;
            uint8_t m_load = 0U;
            uint8_t m_axle = 0U;
            uint8_t m_air = 0U;
 
            m129->header.nid_message = nid_message;
            m129->header.l_message = l_message;
            m129->header.t_train = t_train;
            m129->header.nid_engine = nid_engine;
 
            /* Packet 0 (Position Report) precedes the train-data fields
             * on the wire - same field subset RBC_MSG_TRAIN_TO_TRACK_POSITION_REPORT's
             * own decode below reads, for consistency. */
            if (!rbc_packet_read_0_position_report(in_buffer, buffer_size, &offset, &m129->position_report))
            {
                return false;
            }
 
            (void)rbc_codec_read_u32_be(in_buffer, buffer_size, &offset, &l_train);
            (void)rbc_codec_read_u16_be(in_buffer, buffer_size, &offset, &v_max);
            (void)rbc_codec_read_u8(in_buffer, buffer_size, &offset, &m_load);
            (void)rbc_codec_read_u8(in_buffer, buffer_size, &offset, &m_axle);
            (void)rbc_codec_read_u8(in_buffer, buffer_size, &offset, &m_air);
 
            m129->l_train = l_train;
            m129->v_maxtrain = (rbc_speed_kmh_t)v_max;
            m129->m_loadinggauge = m_load;
            m129->m_axleload = m_axle;
            m129->m_airtight = (m_air != 0U);
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_MA_REQUEST:
        {
            rbc_msg_132_ma_request_t *m132 = &out_msg->payload.msg_132;
            uint8_t q_marqst = 0U;
 
            m132->header.nid_message = nid_message;
            m132->header.l_message = l_message;
            m132->header.t_train = t_train;
            m132->header.nid_engine = nid_engine;
 
            (void)rbc_codec_read_u8(in_buffer, buffer_size, &offset, &q_marqst);
            m132->q_marqstreason = (rbc_q_marqstreason_t)q_marqst;
 
            /* Packet 0 (Position Report) follows Q_MARQSTREASON - same
             * field subset as Msg 129/136's own decode. */
            if (!rbc_packet_read_0_position_report(in_buffer, buffer_size, &offset, &m132->position_report))
            {
                return false;
            }
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_POSITION_REPORT:
        {
            rbc_msg_136_position_report_t *m136 = &out_msg->payload.msg_136;
            uint8_t nid_packet = 0U;
 
            m136->header.nid_message = nid_message;
            m136->header.l_message = l_message;
            m136->header.t_train = t_train;
            m136->header.nid_engine = nid_engine;
 
            /* Real Subset-026 8.6.4: Msg 136 carries "Packet 0 or 1" - a
             * leading NID_PACKET byte says which. Msg 129/132's own
             * Packet 0 (above) has no such choice, so their own decode
             * stays a bare rbc_packet_read_0_position_report() call,
             * unchanged. */
            if (!rbc_codec_read_u8(in_buffer, buffer_size, &offset, &nid_packet))
            {
                return false;
            }
 
            if (nid_packet == (uint8_t)RBC_PACKET_1_POSITION_REPORT_2BG)
            {
                m136->has_packet1 = true;
                if (!rbc_packet_read_1_position_report_2bg(in_buffer, buffer_size, &offset, &m136->packet1))
                {
                    return false;
                }
                /* Mirror Packet 1's own core fields into position_report
                 * too (see rbc_msg_136_position_report_t's own doc) - every
                 * EXISTING reader that only ever looks at position_report
                 * (written before Packet 1 existed) keeps working
                 * unchanged; only a caller that specifically cares about
                 * the Packet 0-vs-1 distinction needs has_packet1. */
                m136->position_report.nid_lrbg = m136->packet1.nid_lrbg;
                m136->position_report.d_lrbg = m136->packet1.d_lrbg;
                m136->position_report.v_train = m136->packet1.v_train;
                m136->position_report.m_mode = m136->packet1.m_mode;
                m136->position_report.m_level = m136->packet1.m_level;
            }
            else if (nid_packet == (uint8_t)RBC_PACKET_0_POSITION_REPORT)
            {
                m136->has_packet1 = false;
                if (!rbc_packet_read_0_position_report(in_buffer, buffer_size, &offset, &m136->position_report))
                {
                    return false;
                }
            }
            else
            {
                /* REQ-RBC-002: an unrecognized NID_PACKET on Msg 136 is
                 * rejected, not silently decoded as if it were Packet 0. */
                return false;
            }
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_ACKNOWLEDGEMENT:
        {
            rbc_msg_146_ack_t *m146 = &out_msg->payload.msg_146;
            uint32_t t_ack = 0U;
 
            m146->header.nid_message = nid_message;
            m146->header.l_message = l_message;
            m146->header.t_train = t_train;
            m146->header.nid_engine = nid_engine;
 
            (void)rbc_codec_read_u32_be(in_buffer, buffer_size, &offset, &t_ack);
            m146->t_train_ack = t_ack;
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_ACK_EMERGENCY_STOP:
        {
            rbc_msg_147_ack_emergency_stop_t *m147 = &out_msg->payload.msg_147;
            uint8_t nid_em = 0U;
            uint8_t accepted = 0U;
 
            m147->header.nid_message = nid_message;
            m147->header.l_message = l_message;
            m147->header.t_train = t_train;
            m147->header.nid_engine = nid_engine;
 
            (void)rbc_codec_read_u8(in_buffer, buffer_size, &offset, &nid_em);
            (void)rbc_codec_read_u8(in_buffer, buffer_size, &offset, &accepted);
 
            m147->nid_em = nid_em;
            m147->ces_accepted = (accepted != 0U);
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_INIT_SESSION:
        {
            rbc_msg_155_init_session_t *m155 = &out_msg->payload.msg_155;
            m155->header.nid_message = nid_message;
            m155->header.l_message = l_message;
            m155->header.t_train = t_train;
            m155->header.nid_engine = nid_engine;
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_TERMINATE_SESSION:
        {
            rbc_msg_156_terminate_session_t *m156 = &out_msg->payload.msg_156;
            m156->header.nid_message = nid_message;
            m156->header.l_message = l_message;
            m156->header.t_train = t_train;
            m156->header.nid_engine = nid_engine;
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_SESSION_ESTABLISHED:
        {
            rbc_msg_159_session_established_t *m159 = &out_msg->payload.msg_159;
            uint8_t m_version = 0U;
 
            m159->header.nid_message = nid_message;
            m159->header.l_message = l_message;
            m159->header.t_train = t_train;
            m159->header.nid_engine = nid_engine;
 
            (void)rbc_codec_read_u8(in_buffer, buffer_size, &offset, &m_version);
            m159->m_version = m_version;
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_REQUEST_FOR_SHUNTING:
        {
            rbc_msg_130_request_for_shunting_t *m130 = &out_msg->payload.msg_130;
 
            m130->header.nid_message = nid_message;
            m130->header.l_message = l_message;
            m130->header.t_train = t_train;
            m130->header.nid_engine = nid_engine;
 
            /* Bare position report, no leading NID_PACKET byte - same
             * convention Msg 129/132's own decode already use above. */
            if (!rbc_packet_read_0_position_report(in_buffer, buffer_size, &offset, &m130->position_report))
            {
                return false;
            }
            break;
        }
 
        case RBC_MSG_TRAIN_TO_TRACK_END_OF_MISSION:
        {
            rbc_msg_150_end_of_mission_t *m150 = &out_msg->payload.msg_150;
            uint8_t q_desk = 0U;
 
            m150->header.nid_message = nid_message;
            m150->header.l_message = l_message;
            m150->header.t_train = t_train;
            m150->header.nid_engine = nid_engine;
 
            if (!rbc_codec_read_u8(in_buffer, buffer_size, &offset, &q_desk))
            {
                return false;
            }
            m150->desk_open = (q_desk != 0U);
 
            if (!rbc_packet_read_0_position_report(in_buffer, buffer_size, &offset, &m150->position_report))
            {
                return false;
            }
            break;
        }
 
        default:
            return false;
    }
 
    return true;
}