/* ========================================================================= */
/* 1. Includes                                                               */
/* ========================================================================= */
#include "main.h"

/* ========================================================================= */
/* 2. Local Macros & Constants (내부 전용 매크로 및 상수)                          */
/* ========================================================================= */

/* ========================================================================= */
/* 3. Local Typedefs & Structures (내부 전용 사용자 정의 자료형)                     */
/* ========================================================================= */
static CTx100 Tx100;
static CTx101 Tx101;
static CTx102 Tx102; // Command Data
static CTx103 Tx103; // Command Data
static CTx110 Tx110;
static CTx120 Tx120;
static CTx121 Tx121;
static CTx122 Tx122;
static CTx123 Tx123;
static CTx124 Tx124;

static CTx700 Tx700;
static CTx701 Tx701;
static CTx710 Tx710;
static CTx720 Tx720;
static CTx730 Tx730;
static CTx731 Tx731;
static CTx732 Tx732;
static CTx733 Tx733;
static CTx734 Tx734;
static CTx740 Tx740;
static CTx741 Tx741;
static CTx750 Tx750;
static CTx751 Tx751;
static CTx752 Tx752;

static CRx201 Rx201;

/* ========================================================================= */
/* 4. Internal Linkage Function Declarations (내부 동작용 Static 함수 선언)        */
/* ========================================================================= */
static void CInitECanA(void);
static void CInitECanB(void);
static void CECanASetMbox(void);
static void CECanBSetMbox(void);
static void CInitECanStructure(void);
static inline Uint16 CPackBit(Uint16 data, Uint16 pos);
static inline Uint16 CPackField(Uint16 data, Uint16 mask, Uint16 pos);

/* ========================================================================= */
/* 5. Global Variables & Structure Initialization (전역 변수 및 구조체 초기화)      */
/* ========================================================================= */
CCommCheck CommCheck;

// Rx - GCU
CRx200 Rx200;
CRx210 Rx210;
CRx220 Rx220;
CRx221 Rx221;

// Rx - ECU
CRx300 Rx300;
CRx301 Rx301;
CRx310 Rx310;
CRx320 Rx320;
CRx321 Rx321;
CRx322 Rx322;

#ifdef AUX_TEST
// Rx - For Aux Test
CRx400 Rx400;
#endif

/* ========================================================================= */
/*                           Function Definitions                            */
/* ========================================================================= */
interrupt void CECanInterruptA(void)
{
    struct ECAN_REGS ECanShadow;
    ECanShadow.CANRMP.all = ECanaRegs.CANRMP.all;
    
    GeneralOperValue.Conection.CarComputer = 1U; // 한번이라도 통신이 수신되었다면 해당 장치가 연결되었다고 판단.
    CommCheck.CarComputer = 0U; // 송신 시 타임아웃 카운트 클리어

    ECanaRegs.CANRMP.all = ECanShadow.CANRMP.all;
}

static inline Uint32 CPackMboxData(Uint16 b0, Uint16 b1, Uint16 b2, Uint16 b3)
{
    return (((Uint32)b0 << 24U) | ((Uint32)b1 << 16U) | ((Uint32)b2 << 8U) | (Uint32)b3);
}

void CSendECanDataA(void)
{
    Uint16 uiTemp = 0U;
    float32 fTemp = 0.0F;

    // ---------------------------------------------------------
    // [700h - MBOX0]
    // ---------------------------------------------------------
    Tx700.HeartBit = (Tx700.HeartBit + 1U) % 65535U;

    // BYTE 0~1(HeartBit), BYTE 2(DCUversionMajor), BYTE 3(DCUversionMinor), BYTE 4(GCUversionMajor), BYTE 5(GCUversionMinor), BYTE 6(ECUversionMajor), BYTE 7(ECUversionMinor)
    ECanaMboxes.MBOX0.MDL.all = CPackMboxData((Uint16)((Tx700.HeartBit >> 0U) & 0xFFU), (Uint16)((Tx700.HeartBit >> 8U) & 0xFFU),
                                              (Uint16)FIRMWARE_VERSION_MAJOR, (Uint16)FIRMWARE_VERSION_MINOR);
    ECanaMboxes.MBOX0.MDH.all = CPackMboxData(Rx200.VersionMajor, Rx200.VersionMinor, Rx300.VersionMajor, Rx300.VersionMinor);

    // ---------------------------------------------------------
    // [701h - MBOX1]
    // ---------------------------------------------------------
    Tx701.DcuPlayState = (Uint16)(GeneralOperValue.uiApuState & 0x7U);

    uiTemp = 0U;
    uiTemp |= CPackBit(GeneralOperValue.uiFaultOccured, 0U);
    uiTemp |= CPackBit(GeneralOperValue.uiEmergency, 1U);
    uiTemp |= CPackBit(KeyOperValue.KeyList.MainPower, 2U);
    uiTemp |= CPackBit((GPIO_FAIL_SAFE_READ() == false) ? 1U : 0U, 3U);
    Tx701.DcuState = uiTemp;

    Tx701.GcuPlayState = Rx201.PlayState;
    Tx701.GcuState = Rx201.State;
    Tx701.EcuState = Rx301.State;

    // BYTE 0(DcuPlayState), BYTE 1(DcuState), BYTE 2(GcuPlayState), BYTE 3(GcuState), BYTE 4(EcuState), BYTE 5~7(Rsvd)
    ECanaMboxes.MBOX1.MDL.all = CPackMboxData(Tx701.DcuPlayState, Tx701.DcuState, Tx701.GcuPlayState, Tx701.GcuState);
    ECanaMboxes.MBOX1.MDH.all = CPackMboxData(Tx701.EcuState, 0U, 0U, 0U);

    // ---------------------------------------------------------
    // [710h - MBOX5]
    // ---------------------------------------------------------
    Tx710.GcuWarning = Rx210.GcuWarning;
    Tx710.EcuWarning = Rx310.EcuWarning;

    // BYTE 0(GcuWarning), BYTE 1(EcuWarning), BYTE 2~7(Rsvd)
    ECanaMboxes.MBOX5.MDL.all = CPackMboxData(Tx710.GcuWarning, Tx710.EcuWarning, 0U, 0U);
    ECanaMboxes.MBOX5.MDH.all = CPackMboxData(0U, 0U, 0U, 0U);

    // ---------------------------------------------------------
    // [720h - MBOX10]
    // ---------------------------------------------------------
    Tx720.DcuFault0 = (Uint16)((ulDcuTotalAlarm >> 0U)  & 0xFFU);
    Tx720.DcuFault1 = (Uint16)((ulDcuTotalAlarm >> 8U)  & 0xFFU);
    Tx720.DcuFault2 = (Uint16)((ulDcuTotalAlarm >> 16U) & 0xFFU);
    Tx720.DcuFault3 = (Uint16)((ulDcuTotalAlarm >> 24U) & 0xFFU);

    Tx720.GcuFault0 = (Uint16)((Rx210.GcuFault >> 0U) & 0xFFU);
    Tx720.GcuFault1 = (Uint16)((Rx210.GcuFault >> 8U) & 0xFFU);
    Tx720.EcuFault  = Rx310.EcuFault;

    // BYTE 0~3(DcuFault0~3), BYTE 4~5(GcuFault0~1), BYTE 6(Rsvd), BYTE 7(EcuFault)
    ECanaMboxes.MBOX10.MDL.all = CPackMboxData(Tx720.DcuFault0, Tx720.DcuFault1, Tx720.DcuFault2, Tx720.DcuFault3);
    ECanaMboxes.MBOX10.MDH.all = CPackMboxData(Tx720.GcuFault0, Tx720.GcuFault1, 0U, Tx720.EcuFault);

    // ---------------------------------------------------------
    // [730h - MBOX15]
    // ---------------------------------------------------------
    Tx730.AuxState = (Uint16)GET_ALL_AUX_STATUS();

    // BYTE 0(AuxState), BYTE 1~7(Rsvd)
    ECanaMboxes.MBOX15.MDL.all = CPackMboxData(Tx730.AuxState, 0U, 0U, 0U);
    ECanaMboxes.MBOX15.MDH.all = CPackMboxData(0U, 0U, 0U, 0U);

    // ---------------------------------------------------------
    // [731h - MBOX16]
    // ---------------------------------------------------------
    fTemp = Adc_EngineHeater_V.fLpfValue * 10.0F;
    Tx731.EngineHeaterVoltage = (Uint16)fTemp;

    fTemp = Adc_EngineHeater_I.fLpfValue * 10.0F;
    Tx731.EngineHeaterCurrent = (Uint16)fTemp;

    fTemp = Adc_GlowPlug_V.fLpfValue * 10.0F;
    Tx731.GlowPlugVoltage = (Uint16)fTemp;

    fTemp = Adc_GlowPlug_I.fLpfValue * 10.0F;
    Tx731.GlowPlugCurrent = (Uint16)fTemp;

    // BYTE 0~1(EngineHeaterVoltage), BYTE 2~3(EngineHeaterCurrent), BYTE 4~5(GlowPlugVoltage), BYTE 6~7(GlowPlugCurrent)
    ECanaMboxes.MBOX16.MDL.all = CPackMboxData((Uint16)((Tx731.EngineHeaterVoltage >> 0U) & 0xFFU), (Uint16)((Tx731.EngineHeaterVoltage >> 8U) & 0xFFU),
                                               (Uint16)((Tx731.EngineHeaterCurrent >> 0U) & 0xFFU), (Uint16)((Tx731.EngineHeaterCurrent >> 8U) & 0xFFU));
    ECanaMboxes.MBOX16.MDH.all = CPackMboxData((Uint16)((Tx731.GlowPlugVoltage >> 0U) & 0xFFU), (Uint16)((Tx731.GlowPlugVoltage >> 8U) & 0xFFU),
                                               (Uint16)((Tx731.GlowPlugCurrent >> 0U) & 0xFFU), (Uint16)((Tx731.GlowPlugCurrent >> 8U) & 0xFFU));

    // ---------------------------------------------------------
    // [732h - MBOX17]
    // ---------------------------------------------------------
    fTemp = Adc_Solenoid_V.fLpfValue * 10.0F;
    Tx732.SolenoidVoltage = (Uint16)fTemp;

    fTemp = Adc_Solenoid_I.fLpfValue * 10.0F;
    Tx732.SolenoidCurrent = (Uint16)fTemp;

    fTemp = Adc_FuelPump_V.fLpfValue * 10.0F;
    Tx732.FuelPumpVoltage = (Uint16)fTemp;

    fTemp = Adc_FuelPump_I.fLpfValue * 10.0F;
    Tx732.FuelPumpCurrent = (Uint16)fTemp;

    // BYTE 0~1(SolenoidVoltage), BYTE 2~3(SolenoidCurrent), BYTE 4~5(FuelPumpVoltage), BYTE 6~7(FuelPumpCurrent)
    ECanaMboxes.MBOX17.MDL.all = CPackMboxData((Uint16)((Tx732.SolenoidVoltage >> 0U) & 0xFFU), (Uint16)((Tx732.SolenoidVoltage >> 8U) & 0xFFU),
                                               (Uint16)((Tx732.SolenoidCurrent >> 0U) & 0xFFU), (Uint16)((Tx732.SolenoidCurrent >> 8U) & 0xFFU));
    ECanaMboxes.MBOX17.MDH.all = CPackMboxData((Uint16)((Tx732.FuelPumpVoltage >> 0U) & 0xFFU), (Uint16)((Tx732.FuelPumpVoltage >> 8U) & 0xFFU),
                                               (Uint16)((Tx732.FuelPumpCurrent >> 0U) & 0xFFU), (Uint16)((Tx732.FuelPumpCurrent >> 8U) & 0xFFU));

    // ---------------------------------------------------------
    // [733h - MBOX18]
    // ---------------------------------------------------------
    fTemp = Adc_CoolantPump_V.fLpfValue * 10.0F;
    Tx733.CoolantPumpVoltage = (Uint16)fTemp;

    fTemp = Adc_CoolantPump_I.fLpfValue * 10.0F;
    Tx733.CoolantPumpCurrent = (Uint16)fTemp;

    fTemp = Adc_Fan1_V.fLpfValue * 10.0F;
    Tx733.Fan1Voltage = (Uint16)fTemp;

    fTemp = Adc_Fan1_I.fLpfValue * 10.0F;
    Tx733.Fan1Current = (Uint16)fTemp;

    // BYTE 0~1(CoolantPumpVoltage), BYTE 2~3(CoolantPumpCurrent), BYTE 4~5(Fan1Voltage), BYTE 6~7(Fan1Current)
    ECanaMboxes.MBOX18.MDL.all = CPackMboxData((Uint16)((Tx733.CoolantPumpVoltage >> 0U) & 0xFFU), (Uint16)((Tx733.CoolantPumpVoltage >> 8U) & 0xFFU),
                                               (Uint16)((Tx733.CoolantPumpCurrent >> 0U) & 0xFFU), (Uint16)((Tx733.CoolantPumpCurrent >> 8U) & 0xFFU));
    ECanaMboxes.MBOX18.MDH.all = CPackMboxData((Uint16)((Tx733.Fan1Voltage >> 0U) & 0xFFU), (Uint16)((Tx733.Fan1Voltage >> 8U) & 0xFFU),
                                               (Uint16)((Tx733.Fan1Current >> 0U) & 0xFFU), (Uint16)((Tx733.Fan1Current >> 8U) & 0xFFU));

    // ---------------------------------------------------------
    // [734h - MBOX19]
    // ---------------------------------------------------------
    fTemp = Adc_Fan2_V.fLpfValue * 10.0F;
    Tx734.Fan2Voltage = (Uint16)fTemp;

    fTemp = Adc_Fan2_I.fLpfValue * 10.0F;
    Tx734.Fan2Current = (Uint16)fTemp;

    // BYTE 0~1(Fan2Voltage), BYTE 2~3(Fan2Current), BYTE 4~7(Rsvd)
    ECanaMboxes.MBOX19.MDL.all = CPackMboxData((Uint16)((Tx734.Fan2Voltage >> 0U) & 0xFFU), (Uint16)((Tx734.Fan2Voltage >> 8U) & 0xFFU),
                                               (Uint16)((Tx734.Fan2Current >> 0U) & 0xFFU), (Uint16)((Tx734.Fan2Current >> 8U) & 0xFFU));
    ECanaMboxes.MBOX19.MDH.all = CPackMboxData(0U, 0U, 0U, 0U);

    // ---------------------------------------------------------
    // [740h - MBOX20]
    // ---------------------------------------------------------
    Tx740.Voltage = Rx220.DcVoltage;
    Tx740.Current = Rx220.DcCurrent;
    Tx740.Rpm     = Rx220.Rpm;
    Tx740.Power   = Rx220.Power;

    // BYTE 0~1(Voltage), BYTE 2~3(Current), BYTE 4~5(Rpm), BYTE 6~7(Power)
    ECanaMboxes.MBOX20.MDL.all = CPackMboxData((Uint16)((Tx740.Voltage >> 0U) & 0xFFU), (Uint16)((Tx740.Voltage >> 8U) & 0xFFU),
                                               (Uint16)((Tx740.Current >> 0U) & 0xFFU), (Uint16)((Tx740.Current >> 8U) & 0xFFU));
    ECanaMboxes.MBOX20.MDH.all = CPackMboxData((Uint16)((Tx740.Rpm >> 0U) & 0xFFU), (Uint16)((Tx740.Rpm >> 8U) & 0xFFU),
                                               (Uint16)((Tx740.Power >> 0U) & 0xFFU), (Uint16)((Tx740.Power >> 8U) & 0xFFU));

    // ---------------------------------------------------------
    // [741h - MBOX21]
    // ---------------------------------------------------------
    Tx741.PcbTemperature = Rx221.PcbTemperature;
    Tx741.FetTemperature = Rx221.FetTemperature;
    Tx741.Winding1Temperature = Rx221.GenTemperature1;
    Tx741.Winding2Temperature = Rx221.GenTemperature2;

    // BYTE 0(PcbTemperature), BYTE 1(FetTemperature), BYTE 2(Winding1Temperature), BYTE 3(Winding2Temperature), BYTE 4~7(Rsvd)
    ECanaMboxes.MBOX21.MDL.all = CPackMboxData(Tx741.PcbTemperature, Tx741.FetTemperature, Tx741.Winding1Temperature, Tx741.Winding2Temperature);
    ECanaMboxes.MBOX21.MDH.all = CPackMboxData(0U, 0U, 0U, 0U);

    // ---------------------------------------------------------
    // [750h - MBOX25]
    // ---------------------------------------------------------
    Tx750.ActualRpm = Rx320.ActualRpm;
    Tx750.SetRpm = Rx320.SetRpm;
    Tx750.ActualTorque = Rx320.ActualTorque;
    Tx750.SetTorque = Rx320.SetTorque;
    Tx750.SystemVoltage = Rx320.SystemVoltage;

    // BYTE 0~1(ActualRpm), BYTE 2~3(SetRpm), BYTE 4(ActualTorque), BYTE 5(SetTorque), BYTE 6~7(SystemVoltage)
    ECanaMboxes.MBOX25.MDL.all = CPackMboxData((Uint16)((Tx750.ActualRpm >> 0U) & 0xFFU), (Uint16)((Tx750.ActualRpm >> 8U) & 0xFFU),
                                               (Uint16)((Tx750.SetRpm >> 0U) & 0xFFU), (Uint16)((Tx750.SetRpm >> 8U) & 0xFFU));
    ECanaMboxes.MBOX25.MDH.all = CPackMboxData(Tx750.ActualTorque, Tx750.SetTorque,
                                               (Uint16)((Tx750.SystemVoltage >> 0U) & 0xFFU), (Uint16)((Tx750.SystemVoltage >> 8U) & 0xFFU));

    // ---------------------------------------------------------
    // [751h - MBOX26]
    // ---------------------------------------------------------
    Tx751.CoolantTemperature = Rx321.CoolantTemperature;
    Tx751.Fan1Speed = Rx321.Fan1Speed;
    Tx751.Fan2Speed = Rx321.Fan2Speed;
    Tx751.CoolantPumpSpeed = Rx321.CoolantPumpSpeed;
    Tx751.Barometric = Rx321.BarometricPressure;

    // BYTE 0(CoolantTemperature), BYTE 1(Fan1Speed), BYTE 2(Fan2Speed), BYTE 3(CoolantPumpSpeed), BYTE 4~5(Barometric), BYTE 6~7(Rsvd)
    ECanaMboxes.MBOX26.MDL.all = CPackMboxData(Tx751.CoolantTemperature, Tx751.Fan1Speed, Tx751.Fan2Speed, Tx751.CoolantPumpSpeed);
    ECanaMboxes.MBOX26.MDH.all = CPackMboxData((Uint16)((Tx751.Barometric >> 0U) & 0xFFU), (Uint16)((Tx751.Barometric >> 8U) & 0xFFU), 0U, 0U);

    // ---------------------------------------------------------
    // [752h - MBOX27]
    // ---------------------------------------------------------
    Tx752.OperationTimeL = Rx322.TotalOperTimeL;
    Tx752.OperationTimeH = Rx322.TotalOperTimeH;

    // BYTE 0~1(OperationTimeL), BYTE 2~3(OperationTimeH), BYTE 4~7(Rsvd)
    ECanaMboxes.MBOX27.MDL.all = CPackMboxData((Uint16)((Tx752.OperationTimeL >> 0U) & 0xFFU), (Uint16)((Tx752.OperationTimeL >> 8U) & 0xFFU),
                                               (Uint16)((Tx752.OperationTimeH >> 0U) & 0xFFU), (Uint16)((Tx752.OperationTimeH >> 8U) & 0xFFU));
    ECanaMboxes.MBOX27.MDH.all = CPackMboxData(0U, 0U, 0U, 0U);

    // ---------------------------------------------------------
    // 송신 메일박스 마스크 설정 및 전송 트리거
    // MBOX 마스크 (0, 1, 5, 10, 15, 16, 17, 18, 19, 20, 21, 25, 26, 27)
    // ---------------------------------------------------------
    Uint32 ulTxMask = 0x0E3F8423UL;

    ECanaRegs.CANTRS.all = ulTxMask;
    ECanaRegs.CANTA.all  = ulTxMask;
}

static void CInitECanA(void)
{
    /* Create a shadow register structure for the CAN control registers. This is
    needed, since only 32-bit access is allowed to these registers. 16-bit access
    to these registers could potentially corrupt the register contents or return
    false data. This is especially true while writing to/reading from a bit
    (or group of bits) among bits 16 - 31 */

    struct ECAN_REGS ECanaShadow = {};

    EALLOW;     // EALLOW enables access to protected bits

    /* Enable internal pull-up for the selected CAN pins */
    // Pull-ups can be enabled or disabled by the user.
    // This will enable the pullups for the specified pins.
    // Comment out other unwanted lines.

    GpioCtrlRegs.GPAPUD.bit.GPIO18 = 0x00U;      // Enable pull-up CANRXA
    GpioCtrlRegs.GPAPUD.bit.GPIO19 = 0x00U;      // Enable pull-up CANTXA

    /* Set qualification for selected CAN pins to asynch only */
    // Inputs are synchronized to SYSCLKOUT by default.
    // This will select asynch (no qualification) for the selected pins.

    GpioCtrlRegs.GPAQSEL2.bit.GPIO18 = 0x03U;    // Asynch qual for CANRXA

    /* Configure eCAN-A pins using GPIO regs*/
    // This specifies which of the possible GPIO pins will be eCAN functional pins.

    GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 0x03U;     // Configure CANRXA operation
    GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 0x03U;     // Configure CANTXA operation

    /* Configure eCAN RX and TX pins for CAN operation using eCAN regs*/

    ECanaShadow.CANTIOC.all = ECanaRegs.CANTIOC.all;
    ECanaShadow.CANTIOC.bit.TXFUNC = 1U;
    ECanaRegs.CANTIOC.all = ECanaShadow.CANTIOC.all;

    ECanaShadow.CANRIOC.all = ECanaRegs.CANRIOC.all;
    ECanaShadow.CANRIOC.bit.RXFUNC = 1U;
    ECanaRegs.CANRIOC.all = ECanaShadow.CANRIOC.all;

    /* Configure eCAN for HECC mode - (reqd to access mailboxes 16 thru 31) */
                                    // HECC mode also enables time-stamping feature

    ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
    ECanaShadow.CANMC.bit.SCB = 1;
    ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;

    // TAn, RMPn, GIFn bits are all zero upon reset and are cleared again
    //  as a matter of precaution.

    ECanaRegs.CANTA.all   = 0xFFFFFFFFU;   /* Clear all TAn bits */
    ECanaRegs.CANRMP.all  = 0xFFFFFFFFU;   /* Clear all RMPn bits */
    ECanaRegs.CANGIF0.all = 0xFFFFFFFFU;   /* Clear all interrupt flag bits */
    ECanaRegs.CANGIF1.all = 0xFFFFFFFFU;

    /* Configure bit timing parameters for eCANB*/
    ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
    ECanaShadow.CANMC.bit.CCR = 1U; // Set CCR = 1
    ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;

    ECanaShadow.CANES.all = ECanaRegs.CANES.all;

    do
    {
        ECanaShadow.CANES.all = ECanaRegs.CANES.all;
    } while(ECanaShadow.CANES.bit.CCE != 1U); // Wait for CCE bit to be set..

    ECanaShadow.CANBTC.all = 0U;

    // 250 [Kbps]
    ECanaShadow.CANBTC.bit.BRPREG = 19U;
    ECanaShadow.CANBTC.bit.TSEG1REG = 10U;
    ECanaShadow.CANBTC.bit.TSEG2REG = 2U;

    ECanaShadow.CANBTC.bit.SAM = 1U;
    ECanaShadow.CANBTC.bit.SJWREG = 2U;
    ECanaRegs.CANBTC.all = ECanaShadow.CANBTC.all;

    ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
    ECanaShadow.CANMC.bit.CCR = 0U;
    ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;

    ECanaShadow.CANES.all = ECanaRegs.CANES.all;

    do
    {
        ECanaShadow.CANES.all = ECanaRegs.CANES.all;
    } while (ECanaShadow.CANES.bit.CCE != 0U); // Wait for CCE bit to be cleared..

    /* Disable all Mailboxes */
    ECanaRegs.CANME.all = 0U; // Required before writing the MSGIDs

    EDIS;
    CECanASetMbox();
}

static void CECanASetMbox(void)
{
    struct ECAN_REGS ECanShadow = {};

    /* Tx Can MBox */
    ECanaMboxes.MBOX0.MSGID.bit.IDE = 0U; // ID ECANa 식별자 - 11bit ID 스탠다드
    ECanaMboxes.MBOX0.MSGID.bit.STDMSGID = 0x700U;
    ECanaMboxes.MBOX0.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX0.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX0.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX0.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX0.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX1.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX1.MSGID.bit.STDMSGID = 0x701U;
    ECanaMboxes.MBOX1.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX1.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX1.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX1.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX1.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX5.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX5.MSGID.bit.STDMSGID = 0x710U;
    ECanaMboxes.MBOX5.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX5.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX5.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX5.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX5.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX10.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX10.MSGID.bit.STDMSGID = 0x720U;
    ECanaMboxes.MBOX10.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX10.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX10.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX10.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX10.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX15.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX15.MSGID.bit.STDMSGID = 0x730U;
    ECanaMboxes.MBOX15.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX15.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX15.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX15.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX15.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX16.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX16.MSGID.bit.STDMSGID = 0x731U;
    ECanaMboxes.MBOX16.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX16.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX16.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX16.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX16.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX17.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX17.MSGID.bit.STDMSGID = 0x732U;
    ECanaMboxes.MBOX17.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX17.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX17.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX17.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX17.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX18.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX18.MSGID.bit.STDMSGID = 0x733U;
    ECanaMboxes.MBOX18.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX18.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX18.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX18.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX18.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX19.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX19.MSGID.bit.STDMSGID = 0x734U;
    ECanaMboxes.MBOX19.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX19.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX19.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX19.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX19.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX20.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX20.MSGID.bit.STDMSGID = 0x740U;
    ECanaMboxes.MBOX20.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX20.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX20.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX20.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX20.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX21.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX21.MSGID.bit.STDMSGID = 0x741U;
    ECanaMboxes.MBOX21.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX21.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX21.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX21.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX21.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX25.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX25.MSGID.bit.STDMSGID = 0x750U;
    ECanaMboxes.MBOX25.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX25.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX25.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX25.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX25.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX26.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX26.MSGID.bit.STDMSGID = 0x751U;
    ECanaMboxes.MBOX26.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX26.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX26.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX26.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX26.MDL.all = 0x00000000U;

    ECanaMboxes.MBOX27.MSGID.bit.IDE = 0U;
    ECanaMboxes.MBOX27.MSGID.bit.STDMSGID = 0x752U;
    ECanaMboxes.MBOX27.MSGID.bit.AME = 0U;
    ECanaMboxes.MBOX27.MSGCTRL.bit.DLC = 8U;
    ECanaMboxes.MBOX27.MSGCTRL.bit.RTR = 0U;
    ECanaMboxes.MBOX27.MDH.all = 0x00000000U;
    ECanaMboxes.MBOX27.MDL.all = 0x00000000U;

    // Transe, Receive, 0 is Transe, 1 is Receive
    ECanShadow.CANMD.all = ECanaRegs.CANMD.all;
    ECanShadow.CANMD.all = 0x0U; // USE MBOX0, MBOX1, MBOX5, MBOX10, MBOX15, MBOX16, MBOX17, MBOX18, MBOX19, MBOX20, MBOX21, MBOX25, MBOX26, MBOX27
    ECanaRegs.CANMD.all = ECanShadow.CANMD.all;

    // MailBox Enable/Disable, 0 is Disable, 1 is Enable
    ECanShadow.CANME.all = ECanaRegs.CANME.all;
    ECanShadow.CANME.all = 0xE3F8413UL; // USE MBOX0, MBOX1, MBOX5, MBOX10, MBOX15, MBOX16, MBOX17, MBOX18, MBOX19, MBOX20, MBOX21, MBOX25, MBOX26, MBOX27
    ECanaRegs.CANME.all = ECanShadow.CANME.all;

    EALLOW;
    ECanShadow.CANMC.all = ECanaRegs.CANMC.all;
    ECanShadow.CANMC.bit.STM = 0U;                   // '1' CAN Self-test Mode ¼³A¤
    ECanShadow.CANMC.bit.ABO = 1U;                   // '1' CAN Auto Bus On
    ECanaRegs.CANMC.all = ECanShadow.CANMC.all;

    // Groble Interrupt
    ECanShadow.CANGIM.all = ECanaRegs.CANGIM.all;
    ECanShadow.CANGIM.bit.I0EN = 1U;             // Line 0 Interrupt Enable
    ECanShadow.CANGIM.bit.GIL = 0U;              // All global interrupts are mapped to the ECAN0INT interrupt line.
    ECanaRegs.CANGIM.all = ECanShadow.CANGIM.all;
    EDIS;
}

interrupt void CECanInterruptB(void)
{
    Uint32 ECanRMPbit;
    Uint32 uiMBOXMdl = 0UL;
    Uint32 uiMBOXMdh = 0UL;

    ECanRMPbit = ECanbRegs.CANRMP.all;

    // ---------------------------------------------------------
    // MBOX15 - 200h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 15U)) != 0U)
    {
        GeneralOperValue.Conection.Gcu = 1U;
        CommCheck.Gcu = 0U; // GCU 타임아웃 카운트 초기화

        uiMBOXMdl = ECanbMboxes.MBOX15.MDL.all;
        uiMBOXMdh = ECanbMboxes.MBOX15.MDH.all;

        Uint16 uiByte0 = (Uint16)((uiMBOXMdl >> 24U) & 0xFFU);
        Uint16 uiByte1 = (Uint16)((uiMBOXMdl >> 16U) & 0xFFU);

        Rx200.HeartBit = uiByte0 | (uiByte1 << 8U);

        Rx200.VersionMajor = (Uint16)((uiMBOXMdh >> 16U) & 0xFFU); // Byte 5
        Rx200.VersionMinor = (Uint16)((uiMBOXMdh >> 8U) & 0xFFU);  // Byte 6
        Rx200.VersionPatch = (Uint16)((uiMBOXMdh >> 0U) & 0xFFU);  // Byte 7
    }

    // ---------------------------------------------------------
    // MBOX16 - 201h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 16U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX16.MDL.all;

        Rx201.PlayState = (Uint16)((uiMBOXMdl >> 24U) & 0x7U);
        Rx201.State     = (Uint16)((uiMBOXMdl >> 16U) & 0xFFU);
    }
    // ---------------------------------------------------------
    // MBOX17 - 210h (비트 필드 매핑 반전)
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 17U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX17.MDL.all;

        Rx210.GcuWarning = (Uint16)(((uiMBOXMdl >> 24U) & 0xFFU) | (((uiMBOXMdl >> 16U) & 0xFFU) << 8U));
        Rx210.GcuFault   = (Uint16)(((uiMBOXMdl >> 8U) & 0xFFU)  | ((uiMBOXMdl & 0xFFU) << 8U));
    }

    // ---------------------------------------------------------
    // MBOX18 - 220h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 18U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX18.MDL.all;
        uiMBOXMdh = ECanbMboxes.MBOX18.MDH.all;

        // [Reverse]
        // Byte 0(>>24), Byte 1(>>16)
        Uint16 uiVoltL = (Uint16)((uiMBOXMdl >> 24U) & 0xFFU);
        Uint16 uiVoltH = (Uint16)((uiMBOXMdl >> 16U) & 0xFFU);
        Rx220.DcVoltage = uiVoltL | (uiVoltH << 8U);

        // Byte 2(>>8), Byte 3(>>0)
        Uint16 uiCurrL = (Uint16)((uiMBOXMdl >> 8U) & 0xFFU);
        Uint16 uiCurrH = (Uint16)((uiMBOXMdl >> 0U) & 0xFFU);
        Rx220.DcCurrent = uiCurrL | (uiCurrH << 8U);

        // Byte 4(>>24), Byte 5(>>16)
        Uint16 uiRpmL = (Uint16)((uiMBOXMdh >> 24U) & 0xFFU);
        Uint16 uiRpmH = (Uint16)((uiMBOXMdh >> 16U) & 0xFFU);
        Rx220.Rpm = uiRpmL | (uiRpmH << 8U);

        // Byte 6(>>24), Byte 7(>>16)
        Uint16 uiPwrL = (Uint16)((uiMBOXMdh >> 8U) & 0xFFU);
        Uint16 uiPwrH = (Uint16)((uiMBOXMdh >> 0U) & 0xFFU);
        Rx220.Power = uiPwrL | (uiPwrH << 8U);
    }

    // ---------------------------------------------------------
    // MBOX19 - 221h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 19U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX19.MDL.all;

        // [Reverse] 0(24), 1(16), 2(8), 3(0)
        Rx221.PcbTemperature  = (Uint16)((uiMBOXMdl >> 24U) & 0xFFU);
        Rx221.FetTemperature  = (Uint16)((uiMBOXMdl >> 16U) & 0xFFU);
        Rx221.GenTemperature1 = (Uint16)((uiMBOXMdl >> 8U) & 0xFFU);
        Rx221.GenTemperature2 = (Uint16)((uiMBOXMdl >> 0U) & 0xFFU);
    }

    // ---------------------------------------------------------
    // MBOX25 - 300h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 25U)) != 0U)
    {
        GeneralOperValue.Conection.Ecu = 1U;
        CommCheck.Ecu = 0U; // ECU 타임아웃 카운트 초기화
        uiMBOXMdl = ECanbMboxes.MBOX25.MDL.all;

        // [Reverse]
        Rx300.VersionMajor = (Uint8)((uiMBOXMdl >> 24U) & 0xFFU);
        Rx300.VersionMinor = (Uint8)((uiMBOXMdl >> 16U) & 0xFFU);
        Rx300.VersionPatch = (Uint8)((uiMBOXMdl >> 8U) & 0xFFU);
    }

    // ---------------------------------------------------------
    // MBOX26 - 301h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 26U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX26.MDL.all;

        // [Reverse] Byte 0 -> >> 24U
        Rx301.State = (Uint16)((uiMBOXMdl >> 24U) & 0xFFU);
    }

    // ---------------------------------------------------------
    // MBOX27 - 310h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 27U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX27.MDL.all;

        // [Reverse] Byte 0 -> >> 24
        Rx310.EcuWarning = (Uint16)((uiMBOXMdl >> 24U) & 0xFFU);
        Rx310.EcuFault = (Uint16)((uiMBOXMdl >> 8U) & 0x3FU);
    }

    // ---------------------------------------------------------
    // MBOX28 - 320h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 28U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX28.MDL.all;
        uiMBOXMdh = ECanbMboxes.MBOX28.MDH.all;

        // [Reverse] Byte 0(>>24), 1(>>16)
        Uint16 uiActRpmL = (Uint16)((uiMBOXMdl >> 24U) & 0xFFU);
        Uint16 uiActRpmH = (Uint16)((uiMBOXMdl >> 16U) & 0xFFU);
        Rx320.ActualRpm = uiActRpmL | (uiActRpmH << 8U);

        // [Reverse] Byte 2(>>8), 3(>>0)
        Uint16 uiSetRpmL = (Uint16)((uiMBOXMdl >> 8U) & 0xFFU);
        Uint16 uiSetRpmH = (Uint16)((uiMBOXMdl >> 0U) & 0xFFU);
        Rx320.SetRpm = uiSetRpmL | (uiSetRpmH << 8U);

        // [Reverse] Byte 4(>>24), 5(>>16) (MDH)
        Rx320.ActualTorque = (Uint16)((uiMBOXMdh >> 24U) & 0xFFU);
        Rx320.SetTorque    = (Uint16)((uiMBOXMdh >> 16U) & 0xFFU);

        // [Reverse] Byte 6(>>8), 7(>>0)
        Uint16 uiSysVoltL = (Uint16)((uiMBOXMdh >> 8U) & 0xFFU);
        Uint16 uiSysVoltH = (Uint16)((uiMBOXMdh >> 0U) & 0xFFU);
        Rx320.SystemVoltage = uiSysVoltL | (uiSysVoltH << 8U);
    }

    // ---------------------------------------------------------
    // MBOX29 - 321h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 29U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX29.MDL.all;
        uiMBOXMdh = ECanbMboxes.MBOX29.MDH.all;

        // [Reverse]
        Rx321.CoolantTemperature = (Uint16)((uiMBOXMdl >> 24U) & 0xFFU);
        Rx321.Fan1Speed          = (Uint16)((uiMBOXMdl >> 16U) & 0xFFU);
        Rx321.Fan2Speed          = (Uint16)((uiMBOXMdl >> 8U) & 0xFFU);
        Rx321.CoolantPumpSpeed   = (Uint16)((uiMBOXMdl >> 0U) & 0xFFU);

        // Byte 4(>>24), 5(>>16)
        Uint16 uiBarL = (Uint16)((uiMBOXMdh >> 24U) & 0xFFU);
        Uint16 uiBarH = (Uint16)((uiMBOXMdh >> 16U) & 0xFFU);
        Rx321.BarometricPressure = uiBarL | (uiBarH << 8U);
    }

    // ---------------------------------------------------------
    // MBOX30 - 322h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 30U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX30.MDL.all;

        // [Reverse] Byte 0(>>24), 1(>>16) -> TimeL
        Uint16 uiTimeLL = (Uint16)((uiMBOXMdl >> 24U) & 0xFFU);
        Uint16 uiTimeLH = (Uint16)((uiMBOXMdl >> 16U) & 0xFFU);
        Rx322.TotalOperTimeL = uiTimeLL | (uiTimeLH << 8U);

        // [Reverse] Byte 2(>>8), 3(>>0) -> TimeH
        Uint16 uiTimeHL = (Uint16)((uiMBOXMdl >> 8U) & 0xFFU);
        Uint16 uiTimeHH = (Uint16)((uiMBOXMdl >> 0U) & 0xFFU);
        Rx322.TotalOperTimeH = uiTimeHL | (uiTimeHH << 8U);
    }

#ifdef AUX_TEST
    // ---------------------------------------------------------
    // MBOX31 - 400h
    // ---------------------------------------------------------
    if ((ECanRMPbit & (1UL << 31U)) != 0U)
    {
        uiMBOXMdl = ECanbMboxes.MBOX31.MDL.all;

        // [Reverse] Byte 0 -> >> 24
        Rx400.AuxControl.EngineHeater = (Uint16)((uiMBOXMdl >> 24U) & 0x1U);
        Rx400.AuxControl.GlowPlug     = (Uint16)((uiMBOXMdl >> 25U) & 0x1U);
        Rx400.AuxControl.Solenoid     = (Uint16)((uiMBOXMdl >> 26U) & 0x1U);
        Rx400.AuxControl.FuelPump     = (Uint16)((uiMBOXMdl >> 27U) & 0x1U);
        Rx400.AuxControl.CoolantPump  = (Uint16)((uiMBOXMdl >> 28U) & 0x1U);
        Rx400.AuxControl.Fan1         = (Uint16)((uiMBOXMdl >> 29U) & 0x1U);
        Rx400.AuxControl.Fan2         = (Uint16)((uiMBOXMdl >> 30U) & 0x1U);
        Rx400.AuxControl.AuxTestStart = (Uint16)((uiMBOXMdl >> 31U) & 0x1U);
    }
#endif

    ECanbRegs.CANRMP.all = ECanRMPbit;
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP9;
}

void CSendECanDataB(void)
{
    struct ECAN_REGS ECanShadow;
    static Uint16 uiTxDivid = 0U; // 분산 송신
    float32 fTemp = 0.0F;
    Uint16 uiTemp = 0U;

    Uint16 EmergencySig = ((GeneralOperValue.uiEmergency > 0U) || (KeyOperValue.KeyList.Emergency > 0U)) ? 1U : 0U;

    // 10ms
    // [101h]
    // --- BYTE 0 ---
    Tx101.PlayState = GeneralOperValue.uiApuState;

    // --- BYTE 1 ---
    uiTemp = 0U;
    uiTemp |= CPackBit(GeneralOperValue.uiFaultOccured, 0U);
    uiTemp |= CPackBit(GeneralOperValue.uiEmergency, 1U);
    uiTemp |= CPackBit(KeyOperValue.KeyList.MainPower, 2U);
    uiTemp |= CPackBit((GPIO_FAIL_SAFE_READ() == false) ? 1U : 0U, 3U);
    Tx101.DcuState = uiTemp;

    ECanbMboxes.MBOX1.MDL.byte.BYTE0 = Tx101.PlayState;
    ECanbMboxes.MBOX1.MDL.byte.BYTE1 = Tx101.DcuState;
    ECanbMboxes.MBOX1.MDL.byte.BYTE2 = 0x0U;
    ECanbMboxes.MBOX1.MDL.byte.BYTE3 = 0x0U;
    ECanbMboxes.MBOX1.MDH.byte.BYTE4 = 0x0U;
    ECanbMboxes.MBOX1.MDH.byte.BYTE5 = 0x0U;
    ECanbMboxes.MBOX1.MDH.byte.BYTE6 = 0x0U;
    ECanbMboxes.MBOX1.MDH.byte.BYTE7 = 0x0U;

    // [102h]
    // --- BYTE 0 ---
    uiTemp = 0U;
    uiTemp |= CPackField(GeneralOperValue.GcuCommand.PlayCmd, 0xFU, 0U);
    uiTemp |= CPackBit(GeneralOperValue.uiAlarmReset, 4U);
    uiTemp |= CPackBit(EmergencySig, 5U);
    Tx102.GcuCommand = uiTemp;

    ECanbMboxes.MBOX2.MDL.byte.BYTE0 = Tx102.GcuCommand;
    ECanbMboxes.MBOX2.MDL.byte.BYTE1 = 0x0U;
    ECanbMboxes.MBOX2.MDL.byte.BYTE2 = 0x0U;
    ECanbMboxes.MBOX2.MDL.byte.BYTE3 = 0x0U;
    ECanbMboxes.MBOX2.MDH.byte.BYTE4 = 0x0U;
    ECanbMboxes.MBOX2.MDH.byte.BYTE5 = 0x0U;
    ECanbMboxes.MBOX2.MDH.byte.BYTE6 = 0x0U;
    ECanbMboxes.MBOX2.MDH.byte.BYTE7 = 0x0U;

    // [103h]
    // --- BYTE 0~7 ---
    uiTemp = 0U;
    Tx103.EngineStart    = GeneralOperValue.EcuCommand.EngineStart;
    Tx103.EngineStop     = GeneralOperValue.EcuCommand.EngineStop;
    Tx103.FaultReset     = GeneralOperValue.uiAlarmReset;
    Tx103.RpmSetpoint    = GeneralOperValue.EcuCommand.RpmSetPoint;
    Tx103.ActiveOverride = KeyOperValue.KeyList.BattleMode;
    Tx103.EmergencyStop  = EmergencySig;

    ECanbMboxes.MBOX3.MDL.byte.BYTE0 = Tx103.EngineStart;
    ECanbMboxes.MBOX3.MDL.byte.BYTE1 = Tx103.EngineStop;
    ECanbMboxes.MBOX3.MDL.byte.BYTE2 = Tx103.FaultReset;
    ECanbMboxes.MBOX3.MDL.byte.BYTE3 = 0x0U;
    ECanbMboxes.MBOX3.MDH.byte.BYTE4 = ((Tx103.RpmSetpoint >> 0U) & 0xFFU);
    ECanbMboxes.MBOX3.MDH.byte.BYTE5 = ((Tx103.RpmSetpoint >> 8U) & 0xFFU);
    ECanbMboxes.MBOX3.MDH.byte.BYTE6 = Tx103.ActiveOverride;
    ECanbMboxes.MBOX3.MDH.byte.BYTE7 = Tx103.EmergencyStop;

    ECanShadow.CANTRS.all = ECanbRegs.CANTRS.all;
    ECanShadow.CANTRS.bit.TRS1 = 1U; // 101h
    ECanShadow.CANTRS.bit.TRS2 = 1U; // 102h
    ECanShadow.CANTRS.bit.TRS3 = 1U; // 103h
    ECanbRegs.CANTRS.all = ECanShadow.CANTRS.all;

    ECanShadow.CANTA.all = ECanbRegs.CANTA.all;
    ECanShadow.CANTA.bit.TA1 = 1U; // 101h
    ECanShadow.CANTA.bit.TA2 = 1U; // 102h
    ECanShadow.CANTA.bit.TA3 = 1U; // 103h
    ECanbRegs.CANTA.all = ECanShadow.CANTA.all;

    ECanShadow.CANTRS.all = ECanbRegs.CANTRS.all;
    ECanShadow.CANTA.all = ECanbRegs.CANTA.all;

    switch (uiTxDivid)
    {
        case 0U:
        {
            // [100h]
            Tx100.Heartbit = (Tx100.Heartbit + 1U) % 65535U;
            Tx100.VersionMajor = (Uint16)FIRMWARE_VERSION_MAJOR;
            Tx100.VersionMinor = (Uint16)FIRMWARE_VERSION_MINOR;
            Tx100.VersionPatch = (Uint16)FIRMWARE_VERSION_PATCH;

            ECanbMboxes.MBOX0.MDL.byte.BYTE0 = ((Tx100.Heartbit >> 0U) & 0xFFU);
            ECanbMboxes.MBOX0.MDL.byte.BYTE1 = ((Tx100.Heartbit >> 8U) & 0xFFU);
            ECanbMboxes.MBOX0.MDL.byte.BYTE2 = 0x0U;
            ECanbMboxes.MBOX0.MDL.byte.BYTE3 = 0x0U;
            ECanbMboxes.MBOX0.MDH.byte.BYTE4 = 0x0U;
            ECanbMboxes.MBOX0.MDH.byte.BYTE5 = Tx100.VersionMajor;
            ECanbMboxes.MBOX0.MDH.byte.BYTE6 = Tx100.VersionMinor;
            ECanbMboxes.MBOX0.MDH.byte.BYTE7 = Tx100.VersionPatch;

            ECanShadow.CANTRS.bit.TRS0  = 1U;
            ECanShadow.CANTA.bit.TA0  = 1U;
            break;
        }
        case 1U:
        {
            // [110h]
            Tx110.DcuFaultB0 = ((Uint16)(ulDcuTotalAlarm >> 0U)  & 0xFFU); // Apu Fault Byte 0
            Tx110.DcuFaultB1 = ((Uint16)(ulDcuTotalAlarm >> 8U)  & 0xFFU); // Apu Fault Byte 1
            Tx110.DcuFaultB2 = ((Uint16)(ulDcuTotalAlarm >> 16U) & 0xFFU); // Apu Fault Byte 2
            Tx110.DcuFaultB3 = ((Uint16)(ulDcuTotalAlarm >> 24U) & 0xFFU); // Apu Fault Byte 3

            ECanbMboxes.MBOX4.MDL.byte.BYTE0 = Tx110.DcuFaultB0;
            ECanbMboxes.MBOX4.MDL.byte.BYTE1 = Tx110.DcuFaultB1;
            ECanbMboxes.MBOX4.MDL.byte.BYTE2 = Tx110.DcuFaultB2;
            ECanbMboxes.MBOX4.MDL.byte.BYTE3 = Tx110.DcuFaultB3;
            ECanbMboxes.MBOX4.MDH.byte.BYTE4 = 0x0U;
            ECanbMboxes.MBOX4.MDH.byte.BYTE5 = 0x0U;
            ECanbMboxes.MBOX4.MDH.byte.BYTE6 = 0x0U;
            ECanbMboxes.MBOX4.MDH.byte.BYTE7 = 0x0U;

            ECanShadow.CANTRS.bit.TRS4  = 1U;
            ECanShadow.CANTA.bit.TA4  = 1U;
            break;
        }
        case 2U:
        {
            // [120h]
            Tx120.AuxTotal = (Uint16)GET_ALL_AUX_STATUS();

            ECanbMboxes.MBOX5.MDL.byte.BYTE0 = Tx120.AuxTotal;
            ECanbMboxes.MBOX5.MDL.byte.BYTE1 = 0x0U;
            ECanbMboxes.MBOX5.MDL.byte.BYTE2 = 0x0U;
            ECanbMboxes.MBOX5.MDL.byte.BYTE3 = 0x0U;
            ECanbMboxes.MBOX5.MDH.byte.BYTE4 = 0x0U;
            ECanbMboxes.MBOX5.MDH.byte.BYTE5 = 0x0U;
            ECanbMboxes.MBOX5.MDH.byte.BYTE6 = 0x0U;
            ECanbMboxes.MBOX5.MDH.byte.BYTE7 = 0x0U;

            ECanShadow.CANTRS.bit.TRS5  = 1U;
            ECanShadow.CANTA.bit.TA5  = 1U;
            break;
        }
        case 3U:
        {
            // [121h]
            fTemp = Adc_EngineHeater_V.fLpfValue * 10.0F;
            Tx121.EngHeatVoltage  = (Uint16)fTemp;

            fTemp = Adc_EngineHeater_I.fLpfValue * 10.0F;
            Tx121.EngHeatCurrent  = (Uint16)fTemp;

            fTemp = Adc_GlowPlug_V.fLpfValue * 10.0F;
            Tx121.GlowPlugVoltage = (Uint16)fTemp;

            fTemp = Adc_GlowPlug_I.fLpfValue * 10.0F;
            Tx121.GlowPlugCurrent = (Uint16)fTemp;

            ECanbMboxes.MBOX6.MDL.byte.BYTE0 = ((Tx121.EngHeatVoltage  >> 0U) & 0xFFU);
            ECanbMboxes.MBOX6.MDL.byte.BYTE1 = ((Tx121.EngHeatVoltage  >> 8U) & 0xFFU);
            ECanbMboxes.MBOX6.MDL.byte.BYTE2 = ((Tx121.EngHeatCurrent  >> 0U) & 0xFFU);
            ECanbMboxes.MBOX6.MDL.byte.BYTE3 = ((Tx121.EngHeatCurrent  >> 8U) & 0xFFU);
            ECanbMboxes.MBOX6.MDH.byte.BYTE4 = ((Tx121.GlowPlugVoltage >> 0U) & 0xFFU);
            ECanbMboxes.MBOX6.MDH.byte.BYTE5 = ((Tx121.GlowPlugVoltage >> 8U) & 0xFFU);
            ECanbMboxes.MBOX6.MDH.byte.BYTE6 = ((Tx121.GlowPlugCurrent >> 0U) & 0xFFU);
            ECanbMboxes.MBOX6.MDH.byte.BYTE7 = ((Tx121.GlowPlugCurrent >> 8U) & 0xFFU);

            ECanShadow.CANTRS.bit.TRS6  = 1U;
            ECanShadow.CANTA.bit.TA6  = 1U;
            break;
        }
        case 4U:
        {
            // [122h]
            fTemp = Adc_Solenoid_V.fLpfValue * 10.0F;
            Tx122.SolenoidVoltage = (Uint16)fTemp;

            fTemp = Adc_Solenoid_I.fLpfValue * 10.0F;
            Tx122.SolenoidCurrent = (Uint16)fTemp;

            fTemp = Adc_FuelPump_V.fLpfValue * 10.0F;
            Tx122.FuelPumpVoltage = (Uint16)fTemp;

            fTemp = Adc_FuelPump_I.fLpfValue * 10.0F;
            Tx122.FuelPumpCurrent = (Uint16)fTemp;

            ECanbMboxes.MBOX7.MDL.byte.BYTE0 = ((Tx122.SolenoidVoltage >> 0U) & 0xFFU);
            ECanbMboxes.MBOX7.MDL.byte.BYTE1 = ((Tx122.SolenoidVoltage >> 8U) & 0xFFU);
            ECanbMboxes.MBOX7.MDL.byte.BYTE2 = ((Tx122.SolenoidCurrent >> 0U) & 0xFFU);
            ECanbMboxes.MBOX7.MDL.byte.BYTE3 = ((Tx122.SolenoidCurrent >> 8U) & 0xFFU);
            ECanbMboxes.MBOX7.MDH.byte.BYTE4 = ((Tx122.FuelPumpVoltage >> 0U) & 0xFFU);
            ECanbMboxes.MBOX7.MDH.byte.BYTE5 = ((Tx122.FuelPumpVoltage >> 8U) & 0xFFU);
            ECanbMboxes.MBOX7.MDH.byte.BYTE6 = ((Tx122.FuelPumpCurrent >> 0U) & 0xFFU);
            ECanbMboxes.MBOX7.MDH.byte.BYTE7 = ((Tx122.FuelPumpCurrent >> 8U) & 0xFFU);

            ECanShadow.CANTRS.bit.TRS7 = 1U;
            ECanShadow.CANTA.bit.TA7   = 1U;
            break;
        }
        case 5U:
        {
            // [123h]
            fTemp = Adc_CoolantPump_V.fLpfValue * 10.0F;
            Tx123.CoolantPumpVoltage = (Uint16)fTemp;

            fTemp = Adc_CoolantPump_I.fLpfValue * 10.0F;
            Tx123.CoolantPumpCurrent = (Uint16)fTemp;

            fTemp = Adc_Fan1_V.fLpfValue * 10.0F;
            Tx123.Fan1Voltage        = (Uint16)fTemp;

            fTemp = Adc_Fan1_I.fLpfValue * 10.0F;
            Tx123.Fan1Current        = (Uint16)fTemp;

            ECanbMboxes.MBOX8.MDL.byte.BYTE0 = ((Tx123.CoolantPumpVoltage >> 0U) & 0xFFU);
            ECanbMboxes.MBOX8.MDL.byte.BYTE1 = ((Tx123.CoolantPumpVoltage >> 8U) & 0xFFU);
            ECanbMboxes.MBOX8.MDL.byte.BYTE2 = ((Tx123.CoolantPumpCurrent >> 0U) & 0xFFU);
            ECanbMboxes.MBOX8.MDL.byte.BYTE3 = ((Tx123.CoolantPumpCurrent >> 8U) & 0xFFU);
            ECanbMboxes.MBOX8.MDH.byte.BYTE4 = ((Tx123.Fan1Voltage >> 0U) & 0xFFU);
            ECanbMboxes.MBOX8.MDH.byte.BYTE5 = ((Tx123.Fan1Voltage >> 8U) & 0xFFU);
            ECanbMboxes.MBOX8.MDH.byte.BYTE6 = ((Tx123.Fan1Current >> 0U) & 0xFFU);
            ECanbMboxes.MBOX8.MDH.byte.BYTE7 = ((Tx123.Fan1Current >> 8U) & 0xFFU);

            ECanShadow.CANTRS.bit.TRS8 = 1U;
            ECanShadow.CANTA.bit.TA8   = 1U;
            break;
        }
        default:
        {
            if (uiTxDivid == 6U)
            {
                // [124h]
                fTemp = Adc_Fan2_V.fLpfValue * 10.0F;
                Tx124.Fan2Voltage = (Uint16)fTemp;

                fTemp = Adc_Fan2_I.fLpfValue * 10.0F;
                Tx124.Fan2Current = (Uint16)fTemp;

                ECanbMboxes.MBOX9.MDL.byte.BYTE0 = ((Tx124.Fan2Voltage >> 0U) & 0xFFU);
                ECanbMboxes.MBOX9.MDL.byte.BYTE1 = ((Tx124.Fan2Voltage >> 8U) & 0xFFU);
                ECanbMboxes.MBOX9.MDL.byte.BYTE2 = ((Tx124.Fan2Current >> 0U) & 0xFFU);
                ECanbMboxes.MBOX9.MDL.byte.BYTE3 = ((Tx124.Fan2Current >> 8U) & 0xFFU);
                ECanbMboxes.MBOX9.MDH.byte.BYTE4 = 0x0U;
                ECanbMboxes.MBOX9.MDH.byte.BYTE5 = 0x0U;
                ECanbMboxes.MBOX9.MDH.byte.BYTE6 = 0x0U;
                ECanbMboxes.MBOX9.MDH.byte.BYTE7 = 0x0U;

                ECanShadow.CANTRS.bit.TRS9 = 1U;
                ECanShadow.CANTA.bit.TA9   = 1U;
            }
            break;
        }
    }
    ECanbRegs.CANTRS.all = ECanShadow.CANTRS.all;
    ECanbRegs.CANTA.all = ECanShadow.CANTA.all;

    uiTxDivid = (uiTxDivid + 1U) % 10U;
}

static void CInitECanB(void)
{
    /* Create a shadow register structure for the CAN control registers. This is
    needed, since only 32-bit access is allowed to these registers. 16-bit access
    to these registers could potentially corrupt the register contents or return
    false data. This is especially true while writing to/reading from a bit
    (or group of bits) among bits 16 - 31 */

    struct ECAN_REGS ECanbShadow = {};

    EALLOW;     // EALLOW enables access to protected bits

    /* Enable internal pull-up for the selected CAN pins */
    // Pull-ups can be enabled or disabled by the user.
    // This will enable the pullups for the specified pins.
    // Comment out other unwanted lines.

    GpioCtrlRegs.GPAPUD.bit.GPIO20 = 0x00U;      // Enable pull-up CANTXB
    GpioCtrlRegs.GPAPUD.bit.GPIO21 = 0x00U;      // Enable pull-up CANRXB

    /* Set qualification for selected CAN pins to asynch only */
    // Inputs are synchronized to SYSCLKOUT by default.
    // This will select asynch (no qualification) for the selected pins.

    GpioCtrlRegs.GPAQSEL2.bit.GPIO21 = 0x03U;    // Asynch qual for CANRXB

    /* Configure eCAN-A pins using GPIO regs*/
    // This specifies which of the possible GPIO pins will be eCAN functional pins.

    GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 0x03U;     // Configure CANTXB operation
    GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 0x03U;     // Configure CANRXB operation

    /* Configure eCAN RX and TX pins for CAN operation using eCAN regs*/

    ECanbShadow.CANTIOC.all = ECanbRegs.CANTIOC.all;
    ECanbShadow.CANTIOC.bit.TXFUNC = 1U;
    ECanbRegs.CANTIOC.all = ECanbShadow.CANTIOC.all;

    ECanbShadow.CANRIOC.all = ECanbRegs.CANRIOC.all;
    ECanbShadow.CANRIOC.bit.RXFUNC = 1U;
    ECanbRegs.CANRIOC.all = ECanbShadow.CANRIOC.all;

    /* Configure eCAN for HECC mode - (reqd to access mailboxes 16 thru 31) */
                                    // HECC mode also enables time-stamping feature

    ECanbShadow.CANMC.all = ECanbRegs.CANMC.all;
    ECanbShadow.CANMC.bit.SCB = 1;
    ECanbRegs.CANMC.all = ECanbShadow.CANMC.all;

    // TAn, RMPn, GIFn bits are all zero upon reset and are cleared again
    //  as a matter of precaution.

    ECanbRegs.CANTA.all   = 0xFFFFFFFFU;   /* Clear all TAn bits */
    ECanbRegs.CANRMP.all  = 0xFFFFFFFFU;   /* Clear all RMPn bits */
    ECanbRegs.CANGIF0.all = 0xFFFFFFFFU;   /* Clear all interrupt flag bits */
    ECanbRegs.CANGIF1.all = 0xFFFFFFFFU;

    /* Configure bit timing parameters for eCANB*/
    ECanbShadow.CANMC.all = ECanbRegs.CANMC.all;
    ECanbShadow.CANMC.bit.CCR = 1U; // Set CCR = 1
    ECanbRegs.CANMC.all = ECanbShadow.CANMC.all;

    ECanbShadow.CANES.all = ECanbRegs.CANES.all;

    do
    {
        ECanbShadow.CANES.all = ECanbRegs.CANES.all;
    } while(ECanbShadow.CANES.bit.CCE != 1U); // Wait for CCE bit to be set..

    ECanbShadow.CANBTC.all = 0U;

    // 250 [kbps]
    ECanbShadow.CANBTC.bit.BRPREG = 19U;
    ECanbShadow.CANBTC.bit.TSEG1REG = 10U;
    ECanbShadow.CANBTC.bit.TSEG2REG = 2U;

    ECanbShadow.CANBTC.bit.SAM = 1U;
    ECanbShadow.CANBTC.bit.SJWREG = 2U;
    ECanbRegs.CANBTC.all = ECanbShadow.CANBTC.all;

    ECanbShadow.CANMC.all = ECanbRegs.CANMC.all;
    ECanbShadow.CANMC.bit.CCR = 0U;
    ECanbRegs.CANMC.all = ECanbShadow.CANMC.all;

    ECanbShadow.CANES.all = ECanbRegs.CANES.all;

    do
    {
        ECanbShadow.CANES.all = ECanbRegs.CANES.all;
    } while (ECanbShadow.CANES.bit.CCE != 0U); // Wait for CCE bit to be cleared..

    /* Disable all Mailboxes */
    ECanbRegs.CANME.all = 0U; // Required before writing the MSGIDs

    EDIS;
    CECanBSetMbox();
}

static void CECanBSetMbox(void)
{
    struct ECAN_REGS ECanShadow = {};

    /* Tx Can MBox */
    ECanbMboxes.MBOX0.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX0.MSGID.bit.STDMSGID = 0x100U;
    ECanbMboxes.MBOX0.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX0.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX0.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX0.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX0.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX1.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX1.MSGID.bit.STDMSGID = 0x101U;
    ECanbMboxes.MBOX1.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX1.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX1.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX1.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX1.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX2.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX2.MSGID.bit.STDMSGID = 0x102U;
    ECanbMboxes.MBOX2.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX2.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX2.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX2.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX2.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX3.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX3.MSGID.bit.STDMSGID = 0x103U;
    ECanbMboxes.MBOX3.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX3.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX3.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX3.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX3.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX4.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX4.MSGID.bit.STDMSGID = 0x110U;
    ECanbMboxes.MBOX4.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX4.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX4.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX4.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX4.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX5.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX5.MSGID.bit.STDMSGID = 0x120U;
    ECanbMboxes.MBOX5.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX5.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX5.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX5.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX5.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX6.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX6.MSGID.bit.STDMSGID = 0x121U;
    ECanbMboxes.MBOX6.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX6.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX6.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX6.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX6.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX7.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX7.MSGID.bit.STDMSGID = 0x122U;
    ECanbMboxes.MBOX7.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX7.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX7.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX7.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX7.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX8.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX8.MSGID.bit.STDMSGID = 0x123U;
    ECanbMboxes.MBOX8.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX8.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX8.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX8.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX8.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX9.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX9.MSGID.bit.STDMSGID = 0x124U;
    ECanbMboxes.MBOX9.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX9.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX9.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX9.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX9.MDL.all = 0x00000000U;

    /* Rx Can MBox(GCU)*/
    ECanbMboxes.MBOX15.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX15.MSGID.bit.STDMSGID = 0x200U;
    ECanbMboxes.MBOX15.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX15.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX15.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX15.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX15.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX16.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX16.MSGID.bit.STDMSGID = 0x201U;
    ECanbMboxes.MBOX16.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX16.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX16.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX16.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX16.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX17.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX17.MSGID.bit.STDMSGID = 0x210U;
    ECanbMboxes.MBOX17.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX17.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX17.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX17.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX17.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX18.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX18.MSGID.bit.STDMSGID = 0x220U;
    ECanbMboxes.MBOX18.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX18.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX18.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX18.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX18.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX19.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX19.MSGID.bit.STDMSGID = 0x221U;
    ECanbMboxes.MBOX19.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX19.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX19.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX19.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX19.MDL.all = 0x00000000U;

    /* Rx Can MBox(ECU)*/
    ECanbMboxes.MBOX25.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX25.MSGID.bit.STDMSGID = 0x300U;
    ECanbMboxes.MBOX25.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX25.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX25.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX25.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX25.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX26.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX26.MSGID.bit.STDMSGID = 0x301U;
    ECanbMboxes.MBOX26.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX26.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX26.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX26.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX26.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX27.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX27.MSGID.bit.STDMSGID = 0x310U;
    ECanbMboxes.MBOX27.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX27.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX27.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX27.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX27.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX28.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX28.MSGID.bit.STDMSGID = 0x320U;
    ECanbMboxes.MBOX28.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX28.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX28.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX28.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX28.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX29.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX29.MSGID.bit.STDMSGID = 0x321U;
    ECanbMboxes.MBOX29.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX29.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX29.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX29.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX29.MDL.all = 0x00000000U;

    ECanbMboxes.MBOX30.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX30.MSGID.bit.STDMSGID = 0x322U;
    ECanbMboxes.MBOX30.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX30.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX30.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX30.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX30.MDL.all = 0x00000000U;
#ifdef AUX_TEST // ! Auxiliary Test
    ECanbMboxes.MBOX31.MSGID.bit.IDE = 0U;
    ECanbMboxes.MBOX31.MSGID.bit.STDMSGID = 0x400U;
    ECanbMboxes.MBOX31.MSGID.bit.AME = 0U;
    ECanbMboxes.MBOX31.MSGCTRL.bit.DLC = 8U;
    ECanbMboxes.MBOX31.MSGCTRL.bit.RTR = 0U;
    ECanbMboxes.MBOX31.MDH.all = 0x00000000U;
    ECanbMboxes.MBOX31.MDL.all = 0x00000000U;
#endif

    //0 is Transe, 1 is Receive
    ECanShadow.CANMD.all = ECanbRegs.CANMD.all;
    ECanShadow.CANMD.all = 0x7E0F8000UL; // USE MBOX15~19, 25~30 (31 제외)
#ifdef AUX_TEST // ! Auxiliary Test
    ECanShadow.CANMD.bit.MD31 = 1U;
#endif
    ECanbRegs.CANMD.all = ECanShadow.CANMD.all;

    // MailBox Enable/Disable, 0 is Disable, 1 is Enable
    ECanShadow.CANME.all = ECanbRegs.CANME.all;
    ECanShadow.CANME.all = 0x7E0F83FFUL; // USE MBOX0~9, 15~19, 25~30 (31 제외)
#ifdef AUX_TEST // ! Auxiliary Test
    ECanShadow.CANME.bit.ME31 = 1U;
#endif
    ECanbRegs.CANME.all = ECanShadow.CANME.all;

    EALLOW;
    ECanShadow.CANMC.all = ECanbRegs.CANMC.all;
    ECanShadow.CANMC.bit.STM = 0U;                   // '1' CAN Self-test Mode ¼³A¤
    ECanShadow.CANMC.bit.ABO = 1U;                   // '1' CAN Auto Bus On
    ECanbRegs.CANMC.all = ECanShadow.CANMC.all;

    // Interrupt Enable(Receive Interrupt), 0 is Disable, 1 is Enable
    ECanShadow.CANMIM.all = ECanbRegs.CANMIM.all;
    ECanShadow.CANMIM.bit.MIM15 = 1U;
    ECanShadow.CANMIM.bit.MIM16 = 1U;
    ECanShadow.CANMIM.bit.MIM17 = 1U;
    ECanShadow.CANMIM.bit.MIM18 = 1U;
    ECanShadow.CANMIM.bit.MIM19 = 1U;
    ECanShadow.CANMIM.bit.MIM25 = 1U;
    ECanShadow.CANMIM.bit.MIM26 = 1U;
    ECanShadow.CANMIM.bit.MIM27 = 1U;
    ECanShadow.CANMIM.bit.MIM28 = 1U;
    ECanShadow.CANMIM.bit.MIM29 = 1U;
    ECanShadow.CANMIM.bit.MIM30 = 1U;
#ifdef AUX_TEST // ! Auxiliary Test
    ECanShadow.CANMIM.bit.MIM31 = 1U;
#endif
    ECanbRegs.CANMIM.all = ECanShadow.CANMIM.all;

    // Groble Interrupt
    ECanShadow.CANGIM.all = ECanbRegs.CANGIM.all;
    ECanShadow.CANGIM.bit.I0EN = 1U;             // Line 0 Interrupt Enable
    ECanShadow.CANGIM.bit.GIL = 0U;              // All global interrupts are mapped to the ECAN0INT interrupt line.
    ECanbRegs.CANGIM.all = ECanShadow.CANGIM.all;
    EDIS;
}

void CInitEcan(void)
{
    CInitECanA();
    CInitECanB();

    CInitECanStructure();
}

static void CInitECanStructure(void)
{
    // Tx
    (void)memset(&Tx100, 0, sizeof(CTx100));
    (void)memset(&Tx101, 0, sizeof(CTx101));
    (void)memset(&Tx102, 0, sizeof(CTx102));
    (void)memset(&Tx103, 0, sizeof(CTx103));
    (void)memset(&Tx110, 0, sizeof(CTx110));
    (void)memset(&Tx120, 0, sizeof(CTx120));
    (void)memset(&Tx121, 0, sizeof(CTx121));
    (void)memset(&Tx122, 0, sizeof(CTx122));
    (void)memset(&Tx123, 0, sizeof(CTx123));
    (void)memset(&Tx124, 0, sizeof(CTx124));

    (void)memset(&Tx700, 0, sizeof(CTx700));
    (void)memset(&Tx701, 0, sizeof(CTx701));
    (void)memset(&Tx710, 0, sizeof(CTx710));
    (void)memset(&Tx720, 0, sizeof(CTx720));
    (void)memset(&Tx730, 0, sizeof(CTx730));
    (void)memset(&Tx731, 0, sizeof(CTx731));
    (void)memset(&Tx732, 0, sizeof(CTx732));
    (void)memset(&Tx733, 0, sizeof(CTx733));
    (void)memset(&Tx734, 0, sizeof(CTx734));
    (void)memset(&Tx740, 0, sizeof(CTx740));
    (void)memset(&Tx741, 0, sizeof(CTx741));
    (void)memset(&Tx750, 0, sizeof(CTx750));
    (void)memset(&Tx751, 0, sizeof(CTx751));
    (void)memset(&Tx752, 0, sizeof(CTx752));

    // Rx - GCU
    (void)memset(&Rx200, 0, sizeof(CRx200));
    (void)memset(&Rx201, 0, sizeof(CRx201));
    (void)memset(&Rx210, 0, sizeof(CRx210));
    (void)memset(&Rx220, 0, sizeof(CRx220));
    (void)memset(&Rx221, 0, sizeof(CRx221));

    // Rx - ECU
    (void)memset(&Rx300, 0, sizeof(CRx300));
    (void)memset(&Rx301, 0, sizeof(CRx301));
    (void)memset(&Rx310, 0, sizeof(CRx310));
    (void)memset(&Rx320, 0, sizeof(CRx320));
    (void)memset(&Rx321, 0, sizeof(CRx321));
    (void)memset(&Rx322, 0, sizeof(CRx322));

#ifdef AUX_TEST // ! Auxiliary Test
    // Rx - Auxiliary Test
    (void)memset(&Rx400, 0, sizeof(CRx400));
#endif
}

static inline Uint16 CPackBit(Uint16 data, Uint16 pos)
{
    Uint16 result = (data != 0U) ? 1U : 0U;

    return result << pos;
}

static inline Uint16 CPackField(Uint16 data, Uint16 mask, Uint16 pos)
{
    return ((data & mask) << pos);
}