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

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

/* ========================================================================= */
/* 3. Local Typedefs & Structures (내부 전용 사용자 정의 자료형)                     */
/* ========================================================================= */
// No Code

/* ========================================================================= */
/* 4. Internal Linkage Function Declarations (내부 동작용 Static 함수 선언)        */
/* ========================================================================= */
static void CInitSystem(void);
static void COledDisplay(void);
static void CInitGeneralOperValue(void);
static void CInitGpio(void);
static void CSystemConfigure(void);
static void CMappingInterrupt(void);
static void CProcessSoftTimer(void);
static void CShutdownProcedure(void);
static Uint16 CPowerOnCheck(void);
static void CSoftTimerWorkProcess(void);
static Uint16 CIsStatusSoftTimer(Uint16 uiTimerIndex);
static void CReloadSoftTimer(Uint16 uiTimerIndex);
static void CInitSoftTimers(void);
static void CInitSoftTimer(void);
static void CConfigSoftTimer(Uint16 TimerIndex, Uint32 Delay);
static void CStartSoftTimer(Uint16 uiTimerIndex);
static Uint16 CSoftClockTimeOut(Uint32 ulStartClock, Uint32 ulTimeOutClock);
static void CInitI2C(void);

/* ========================================================================= */
/* 5. Global Variables & Structure Initialization (전역 변수 및 구조체 초기화)      */
/* ========================================================================= */
Uint16 PowerOnCheckSensor[(Uint16)IDX_SENSOR_MAX] = { 0U };

CGeneralOperValue GeneralOperValue;

static CSoftTimer SoftTimer[TIMER_MAX];
static CWaitTimer WaitTimer[SOFTTIMER_WAIT_MAX];
static Uint32 ulSoftClock;

/* ========================================================================= */
/*                           Function Definitions                            */
/* ========================================================================= */
int main(void)
{
    GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_BOOT;

    CInitSystem(); 

    CInitOled();

    GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_INITIAL;

    AdcOperValue.uiOffsetAdjustStart = 1U; // AD 보정 시작

    for ( ; ; )
    {
        CShutdownProcedure();

        CSoftTimerWorkProcess();

        if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_INITIAL)
        {
            if (OledOperValue.uiProgressDone == 1U)
            {
                if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_INIT, TIME_1SEC) == (Uint16)TIME_OVER)
                {
                    COledBufferReset();

                    GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_POST; // Adc 보정완료 이 후 POST 시작
                }
            }
        }
        else if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_POST)
        {
            if (GeneralOperValue.uiSelfTestCheck == 0U)
            {
                GeneralOperValue.uiSelfTestCheck = 1U; // 한번만 체크하기 위함

                GeneralOperValue.uiSelfTestPass = CPowerOnCheck(); // 1 : 정상, 0 : 비정상
            }
            else
            {
                if (GeneralOperValue.uiSelfTestPass == 1U) // 1 : 정상
                {
                    COledBufferReset();

                    GeneralOperValue.uiApuState = (Uint16)IDX_APU_OPER_STANDBY;
                }
            }
        }
        else
        {
#ifdef AUX_TEST
            if (Rx400.AuxControl.AuxTestStart == 1U)
            {
                CSetAuxCtrlPin(IDX_CS_ENG_HEATER, (Rx400.AuxControl.EngineHeater != 0U) ? 1U : 0U);
                CSetAuxCtrlPin(IDX_CS_GLOW_PLUG, (Rx400.AuxControl.GlowPlug != 0U) ? 1U : 0U);
                CSetAuxCtrlPin(IDX_CS_SOLENOID, (Rx400.AuxControl.Solenoid != 0U) ? 1U : 0U);
                CSetAuxCtrlPin(IDX_CS_FUEL_PUMP, (Rx400.AuxControl.FuelPump != 0U) ? 1U : 0U);
                CSetAuxCtrlPin(IDX_CS_COOLANT_PUMP, (Rx400.AuxControl.CoolantPump != 0U) ? 1U : 0U);
                CSetAuxCtrlPin(IDX_CS_FAN1, (Rx400.AuxControl.Fan1 != 0U) ? 1U : 0U);
                CSetAuxCtrlPin(IDX_CS_FAN2, (Rx400.AuxControl.Fan2 != 0U) ? 1U : 0U);
            }
            // 정비 모드가 꺼져있어야 시퀀스 동작.
            else if (GeneralOperValue.uiMaintenance == 0U)
#else
            if (GeneralOperValue.uiMaintenance == 0U)
#endif
            {
                if (KeyOperValue.KeyList.MainPower == 0U) // 전원 스위치를 눌러서 shutdown 상태면 프로시저 OFF
                {
                    CApuOperProcedure();    // 엔진 운영 프로시저

                    CLedControlProcedure(); // LED 제어 프로시저
                }
            }
            else
            {
                CDebugModeProcedure();
            }
        }
    }
}

static void CSoftTimerWorkProcess(void)
{
    Uint16 ui01msExcute;
    Uint16 ui10msExcute;
    Uint16 ui100msExcute;

    ui01msExcute  = CIsStatusSoftTimer(TIMER_01MS);
    ui10msExcute  = CIsStatusSoftTimer(TIMER_10MS);
    ui100msExcute = CIsStatusSoftTimer(TIMER_100MS);

    if (ui01msExcute == (Uint16)SOFTTIMER_TIME_OVER)
    {
        CReloadSoftTimer(TIMER_01MS);

        if (GeneralOperValue.uiApuState > (Uint16)IDX_APU_OPER_POST) // ADC 오프셋 보정 완료 후 감지
        {
            CAlarmProcedure();
            CDisplayAlarmPopup();
        }

        // (정비모드:키테스트)가 아니면 키 입력 처리 시작 함.
        if (GeneralOperValue.Maintenance.KeyTest == 0U)
        {
            CKeyCheckProcedure();
            CKeyWaitCount();
        }
    }

    if (ui10msExcute == (Uint16)SOFTTIMER_TIME_OVER)
    {
        CReloadSoftTimer(TIMER_10MS);

        CSendECanDataB();
        COledDisplay();
    }

    if (ui100msExcute == (Uint16)SOFTTIMER_TIME_OVER)
    {
        CReloadSoftTimer(TIMER_100MS);
        CSendECanDataA();
        CDisplayAntiNoiseRefresh();
    }
}

static void COledDisplay(void)
{
    static Uint16 RefeshDelay = 0U;

    // 부트 상태 이 후 프로그래스바 화면 표시용
    if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_INITIAL)
    {
        CInitializePage();
    }
    else
    {
        if (RefeshDelay == 0U) // 10ms 주기를 위함
        {
            // POST 상태 표시 용
            if (GeneralOperValue.uiApuState == (Uint16)IDX_APU_OPER_POST)
            {
                CDisplayPostFail();
            }
            else
            {
                // POST 이 후 화면 표시용
                CSetPage(OledOperValue.uiPageNum);
            }
        }
        RefeshDelay = (RefeshDelay + 1U) % 10U;
    }

    COledReflash(0, 0, OLED_WIDTH, OLED_HEIGHT);
}

void CSoftWaitCountClear(Uint16 Index)
{
    WaitTimer[Index].ulCountSoftClock = 0U;
    WaitTimer[Index].uiSoftCountTarget = 0U;
}

static Uint16 CIsStatusSoftTimer(Uint16 uiTimerIndex)
{
    Uint16 isRunning = 1U;

    if (SoftTimer[uiTimerIndex].iStart != -1)
    {
        if (SoftTimer[uiTimerIndex].iStart == 1)
        {
            if (SoftTimer[uiTimerIndex].ulDecreaseValue == 0U)
            {
                isRunning = (Uint16)SOFTTIMER_TIME_OVER; // Success
            }
            else
            {
                isRunning = (Uint16)SOFTTIMER_RUNNING;
            }
        }
    }

    return isRunning;
}

static void CReloadSoftTimer(Uint16 uiTimerIndex)
{
    if (SoftTimer[uiTimerIndex].iTimer != -1)
    {
        SoftTimer[uiTimerIndex].ulDecreaseValue = SoftTimer[uiTimerIndex].ulSetValue;
    }
}

Uint16 CSoftWaitCountProcedure(Uint16 uiIndex, Uint32 ulWaitTime)
{
    Uint16 isCountOver = 0U;

    switch (WaitTimer[uiIndex].uiSoftCountTarget)
    {
        case 0U:
        {
            WaitTimer[uiIndex].ulCountSoftClock = CGetSoftClock();
            WaitTimer[uiIndex].uiSoftCountTarget = 1U;
            break;
        }
        case 1U:
        {
            if (CSoftClockTimeOut(WaitTimer[uiIndex].ulCountSoftClock, ulWaitTime) == (Uint16)SOFTTIMER_TIME_OVER)
            {
                WaitTimer[uiIndex].uiSoftCountTarget = 2U;
            }
            break;
        }
        default:
        {
            WaitTimer[uiIndex].ulCountSoftClock = 0U;
            WaitTimer[uiIndex].uiSoftCountTarget = 0U;
            isCountOver = 1U;
            break;
        }
    }

    return isCountOver;
}

static Uint16 CSoftClockTimeOut(Uint32 ulStartClock, Uint32 ulTimeOutClock)
{
    Uint16 isRunning = 1U;
    Uint32 ulCpuClock = CGetSoftClock();

    if (((ulCpuClock + SYSTEM_10MIN_TIME - ulStartClock) % SYSTEM_10MIN_TIME) >= ulTimeOutClock)
    {
        isRunning = 0U;
    }

    return isRunning;
}

Uint32 CGetSoftClock(void)
{
    return ulSoftClock;
}

static void CInitSystem(void)
{
    DINT;
    IER = 0x0000;
    IFR = 0x0000;

    InitSysCtrl();

    CInitGpio();    // GPIO Direction and mux

    InitPieCtrl();
    IER = 0x0000;
    IFR = 0x0000;

    InitPieVectTable();

    InitCpuTimers();

    ConfigCpuTimer(&CpuTimer0, 150.0F, 100.0F);  // 100usec

    CSystemConfigure();

    EINT; // Enable Global interrupt INTM
    ERTM; // Enable Global realtime interrupt DBGM

    CpuTimer0Regs.TCR.all = 0x4001U; // Use write-only instruction to set TSS bit = 0
}

static void CInitGpio(void)
{
    EALLOW;

    // GPIO MUX Setting
    GpioCtrlRegs.GPBMUX1.bit.GPIO32 = 0x1U;  // SCL
    GpioCtrlRegs.GPBMUX1.bit.GPIO33 = 0x1U;  // SDA

    GpioCtrlRegs.GPBPUD.bit.GPIO32 = 0x0U;   // Enable pull-up (SDAA)
    GpioCtrlRegs.GPBPUD.bit.GPIO33 = 0x0U;   // Enable pull-up (SCLA)

    GpioCtrlRegs.GPBQSEL1.bit.GPIO32 = 0x3U; // Asynch input (SDAA)
    GpioCtrlRegs.GPBQSEL1.bit.GPIO33 = 0x3U; // Asynch input (SCLA)

    // GPIO Direction Setting '1' Output, '0' Input
    GpioCtrlRegs.GPADIR.bit.GPIO9  = 0U; // GPIO_FUEL_PUMP_SIG_C
    GpioCtrlRegs.GPADIR.bit.GPIO10 = 0U; // GPIO_GLOW_PLUG_SIG_C
    GpioCtrlRegs.GPADIR.bit.GPIO11 = 0U; // GPIO_STOP_SOLENOID_SIG_C
    GpioCtrlRegs.GPADIR.bit.GPIO24 = 0U; // GPIO_ENGINE_HEATER_SIG_C
    GpioCtrlRegs.GPADIR.bit.GPIO25 = 0U; // GPIO_FAIL_SAFE_ENABLE_C
    GpioCtrlRegs.GPADIR.bit.GPIO29 = 0U; // CPU_SW_MODE_RESET
    GpioCtrlRegs.GPADIR.bit.GPIO30 = 0U; // CPU_SW_MODE_ENT
    GpioCtrlRegs.GPADIR.bit.GPIO31 = 0U; // CPU_SW_DOWN
    GpioCtrlRegs.GPBDIR.bit.GPIO39 = 0U; // CPU_SW_UP
    GpioCtrlRegs.GPBDIR.bit.GPIO54 = 0U; // GPIO_BATTLEMODE_CMD_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO56 = 0U; // GPIO_EMERGENCY_CMD_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO57 = 0U; // GPIO_STOP_CMD_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO58 = 0U; // GPIO_START_CMD_CS
    GpioCtrlRegs.GPCDIR.bit.GPIO64 = 0U; // CPU_SW_EMERGENCY
    GpioCtrlRegs.GPCDIR.bit.GPIO66 = 0U; // CPU_SW_START
    GpioCtrlRegs.GPCDIR.bit.GPIO67 = 0U; // CPU_SW_PWR

    GpioCtrlRegs.GPADIR.bit.GPIO12 = 1U; // GPIO_CPU_LED_SWITCH3
    GpioCtrlRegs.GPADIR.bit.GPIO13 = 1U; // GPIO_CPU_LED_SWITCH2
    GpioCtrlRegs.GPADIR.bit.GPIO14 = 1U; // GPIO_CPU_LED_SWITCH1
    GpioCtrlRegs.GPADIR.bit.GPIO26 = 1U; // GPIO_FUEL_PUMP_CS
    GpioCtrlRegs.GPADIR.bit.GPIO27 = 1U; // GPIO_GLOW_PLUG_CS
    GpioCtrlRegs.GPADIR.bit.GPIO28 = 1U; // GPIO_OLED_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO37 = 1U; // GPIO_OLED_RESET
    GpioCtrlRegs.GPBDIR.bit.GPIO48 = 1U; // GPIO_STOP_SOLENOID_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO49 = 1U; // GPIO_ENGINE_HEATER_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO50 = 1U; // GPIO_COOLING_FAN1_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO51 = 1U; // GPIO_COOLING_FAN2_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO52 = 1U; // GPIO_COOLING_PUMP_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO55 = 1U; // GPIO_FAULT_CMD_CS
    GpioCtrlRegs.GPCDIR.bit.GPIO65 = 1U; // GPIO_POWER_HOLD
    GpioCtrlRegs.GPCDIR.bit.GPIO68 = 1U; // GPIO_CPU_LED_COM_FAULT
    GpioCtrlRegs.GPCDIR.bit.GPIO69 = 1U; // GPIO_CPU_LED_COM_RUN
    GpioCtrlRegs.GPCDIR.bit.GPIO70 = 1U; // GPIO_CPU_LED_COM_STA

    // GPAQSEL : 0b00 - Synchronize to SYSCLKOUT, 0b01 - Qualification 3 sample, 0b10 - Qualification 6 sample, 0b11 - Asynchronous
    GpioCtrlRegs.GPAQSEL1.all = 0x0000U;    // GPIO0-GPIO15 Synch to SYSCLKOUT
    GpioCtrlRegs.GPAQSEL2.all = 0x0000U;    // GPIO16-GPIO31 Synch to SYSCLKOUT
    GpioCtrlRegs.GPBQSEL1.all = 0x0000U;    // GPIO32-GPIO47 Synch to SYSCLKOUT
    GpioCtrlRegs.GPBQSEL2.all = 0x0000U;    // GPIO48-GPIO63 Synch to SYSCLKOUT

    GpioCtrlRegs.GPAQSEL1.bit.GPIO9 = 1U;   // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO10 = 1U;  // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO11 = 1U;  // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL2.bit.GPIO24 = 1U;  // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL2.bit.GPIO25 = 1U;  // 3 Clk Sampling

    // Gpio Default Value Initial
    GpioDataRegs.GPCSET.bit.GPIO65 = 1U; // GPIO_POWER_HOLD

    GpioDataRegs.GPCSET.bit.GPIO68 = 1U; // GPIO_CPU_LED_COM_FAULT_N
    GpioDataRegs.GPCSET.bit.GPIO69 = 1U; // GPIO_CPU_LED_COM_RUN_N
    GpioDataRegs.GPCSET.bit.GPIO70 = 1U; // GPIO_CPU_LED_COM_STA_N

    EDIS;
}

void COffChipSelect(void)
{
    CSetAuxCtrlPin(IDX_CS_ENG_HEATER, 0U);
    CSetAuxCtrlPin(IDX_CS_GLOW_PLUG, 0U);
    CSetAuxCtrlPin(IDX_CS_SOLENOID, 0U);
    CSetAuxCtrlPin(IDX_CS_FUEL_PUMP, 0U);
    CSetAuxCtrlPin(IDX_CS_COOLANT_PUMP, 0U);
    CSetAuxCtrlPin(IDX_CS_FAN1, 0U);
    CSetAuxCtrlPin(IDX_CS_FAN2, 0U);
}

static interrupt void CMainTimer0Interrupt(void)
{
    // Per 100uSec

    DINT;

    ulSoftClock = (ulSoftClock + 1U) % SYSTEM_10MIN_TIME;

    CProcessSoftTimer();
    // Do Something

    AdcRegs.ADCTRL2.bit.SOC_SEQ1 = 0x01U; // Adc Read Start

    PieCtrlRegs.PIEACK.all |= PIEACK_GROUP1;
    EINT;
}

static void CSystemConfigure(void)
{
    CMappingInterrupt();

    CInitGeneralOperValue();

    CInitAdc();
    CInitEcan();

    CInitI2C();

    CInitXintf();

    CInitSoftTimers();

    CInitKeyOperValue();
}

static void CInitGeneralOperValue(void)
{
    (void)memset(&GeneralOperValue, 0, sizeof(CGeneralOperValue));

    GeneralOperValue.uiPassword[IDX_OLED_PASS_DIGIT_1] = 0;
    GeneralOperValue.uiPassword[IDX_OLED_PASS_DIGIT_2] = 0;
    GeneralOperValue.uiPassword[IDX_OLED_PASS_DIGIT_3] = 0;
    GeneralOperValue.uiPassword[IDX_OLED_PASS_DIGIT_4] = 0;

    GeneralOperValue.EcuCommand.EngineStop = 1U;
}

static void CMappingInterrupt(void)
{
    EALLOW;

    // Interrupt Vector Remapping
    PieCtrlRegs.PIEIER1.bit.INTx7 = 0x1U;  // TINT0
    PieCtrlRegs.PIEIER1.bit.INTx6 = 0x1U;  // ADC
    PieCtrlRegs.PIEIER9.bit.INTx5 = 0x1U;  // ECAN0INTA
    PieCtrlRegs.PIEIER9.bit.INTx7 = 0x1U;  // ECAN0INTB

    PieVectTable.TINT0 = &CMainTimer0Interrupt;
    PieVectTable.ECAN0INTA = &CECanInterruptA;
    PieVectTable.ECAN0INTB = &CECanInterruptB;
    PieVectTable.ADCINT = &CAdcInterrupt;

    IER = (Uint16)((Uint16)M_INT1 | (Uint16)M_INT9);

    EDIS;
}

static void CProcessSoftTimer(void)
{
    Uint16 i;

    for (i = 0U; i < (Uint16)TIMER_MAX; i++)
    {
        if (SoftTimer[i].iTimer != -1)
        {
            if (SoftTimer[i].iStart == 1)
            {
                if (SoftTimer[i].ulDecreaseValue > 0UL)
                {
                    SoftTimer[i].ulDecreaseValue--;
                }
            }
        }
    }
}

static void CInitSoftTimers(void)
{
    CInitSoftTimer();
    CConfigSoftTimer(TIMER_01MS,  TIME_01MS);
    CConfigSoftTimer(TIMER_10MS,  TIME_10MS);
    CConfigSoftTimer(TIMER_20MS,  TIME_20MS);
    CConfigSoftTimer(TIMER_50MS,  TIME_50MS);
    CConfigSoftTimer(TIMER_100MS, TIME_100MS);
    CConfigSoftTimer(TIMER_500MS, TIME_500MS);

    CStartSoftTimer(TIMER_01MS);
    CStartSoftTimer(TIMER_10MS);
    CStartSoftTimer(TIMER_20MS);
    CStartSoftTimer(TIMER_50MS);
    CStartSoftTimer(TIMER_100MS);
    CStartSoftTimer(TIMER_500MS);
}

static void CStartSoftTimer(Uint16 uiTimerIndex)
{
    if (SoftTimer[uiTimerIndex].iTimer != -1)
    {
        SoftTimer[uiTimerIndex].iStart = 1;
    }
}

static void CInitSoftTimer(void)
{
    Uint16 i;

    (void)memset(&SoftTimer, 0, sizeof(SoftTimer));
    (void)memset(&WaitTimer, 0, sizeof(WaitTimer));

    for (i = 0; i < (Uint16)TIMER_MAX; i++)
    {
        SoftTimer[i].iTimer = -1;
    }
}

static void CConfigSoftTimer(Uint16 TimerIndex, Uint32 Delay)
{
    SoftTimer[TimerIndex].iTimer = (int16) TimerIndex;
    SoftTimer[TimerIndex].ulSetValue = Delay;
    SoftTimer[TimerIndex].ulDecreaseValue = Delay;
    SoftTimer[TimerIndex].iStart = 0;
}

static Uint16 CPowerOnCheck(void)
{
    Uint16 result = 1U;
    Uint16 uiTemp = 0U;
    Uint16 i;

    // Check EngineHeater V/I Sensor
    uiTemp =  ((Adc_EngineHeater_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_EngineHeater_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    uiTemp |= ((Adc_EngineHeater_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_EngineHeater_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    PowerOnCheckSensor[(Uint16)IDX_SENSOR_ENGINE_HEATER] = uiTemp;

    // Check GlowPlug V/I Sensor
    uiTemp =  ((Adc_GlowPlug_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_GlowPlug_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    uiTemp |= ((Adc_GlowPlug_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_GlowPlug_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    PowerOnCheckSensor[(Uint16)IDX_SENSOR_GLOW_PLUG] = uiTemp;

    // Check Solenoid V/I Sensor
    uiTemp =  ((Adc_Solenoid_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Solenoid_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    uiTemp |= ((Adc_Solenoid_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Solenoid_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    PowerOnCheckSensor[(Uint16)IDX_SENSOR_SOLENOID] = uiTemp;

    // Check FuelPump V/I Sensor
    uiTemp =  ((Adc_FuelPump_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_FuelPump_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    uiTemp |= ((Adc_FuelPump_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_FuelPump_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    PowerOnCheckSensor[(Uint16)IDX_SENSOR_FUEL_PUMP] = uiTemp;

    // Check CoolantPump V/I Sensor
    uiTemp =  ((Adc_CoolantPump_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_CoolantPump_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    uiTemp |= ((Adc_CoolantPump_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_CoolantPump_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    PowerOnCheckSensor[(Uint16)IDX_SENSOR_COOLANT_PUMP] = uiTemp;

    // Check Fan1 V/I Sensor
    uiTemp =  ((Adc_Fan1_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Fan1_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    uiTemp |= ((Adc_Fan1_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Fan1_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    PowerOnCheckSensor[(Uint16)IDX_SENSOR_FAN1] = uiTemp;

    // Check Fan2 V/I Sensor
    uiTemp =  ((Adc_Fan2_V.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Fan2_V.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    uiTemp |= ((Adc_Fan2_I.iAdcValue > SENSOR_LOW_LIMIT) && (Adc_Fan2_I.iAdcValue < SENSOR_HIGH_LIMIT)) ? 0U : 1U;
    PowerOnCheckSensor[(Uint16)IDX_SENSOR_FAN2] = uiTemp;

    for (i = 0U; i < (Uint16)IDX_SENSOR_MAX; i++)
    {
        if (PowerOnCheckSensor[i] > 0U)
        {
            result = 0U;
            break;
        }
    }
    return result; // '0' 정상
}

static void CInitI2C(void)
{
    /* I2C 모듈 리셋 */
    I2caRegs.I2CMDR.bit.IRS = 0U;

    /*
     * 1. I2C 프리스케일러 (I2CPSC) 설정
     * SYSCLKOUT = 150MHz 기준
     * 10MHz = 150MHz / (14 + 1) -> I2CPSC = 14
     */
    I2caRegs.I2CPSC.all = 14U;

    /*
     * 2. I2C 마스터 클럭 (SCL) 설정
     * 10MHz / 400kHz = 25 -> (I2CCLKL + 5) + (I2CCLKH + 5) = 25
     */
    //I2caRegs.I2CCLKL = 45U; // 100kHz
    //I2caRegs.I2CCLKH = 45U; // 100kHz
    I2caRegs.I2CCLKL = 8U; // 400kHz
    I2caRegs.I2CCLKH = 7U; // 400kHz

    /*
     * 3. I2C 핀 설정 (GPIO32/SDAA, GPIO33/SCLA)
     */
    EALLOW;
    GpioCtrlRegs.GPBPUD.bit.GPIO32 = 0U;   /* Pull-up 활성화 (SDAA) */
    GpioCtrlRegs.GPBPUD.bit.GPIO33 = 0U;   /* Pull-up 활성화 (SCLA) */

    GpioCtrlRegs.GPBQSEL1.bit.GPIO32 = 3U; /* 비동기 입력 설정 */
    GpioCtrlRegs.GPBQSEL1.bit.GPIO33 = 3U; /* 비동기 입력 설정 */

    GpioCtrlRegs.GPBMUX1.bit.GPIO32 = 1U;  /* GPIO32를 SDAA로 설정 */
    GpioCtrlRegs.GPBMUX1.bit.GPIO33 = 1U;  /* GPIO33을 SCLA로 설정 */
    EDIS;

    /* I2C 모듈 활성화 (리셋 해제 및 기본 설정 적용) */
    I2caRegs.I2CMDR.all = 0x0020U;
}

static void CShutdownProcedure(void)
{
    if (KeyOperValue.KeyList.MainPower == 1U)
    {
        // 장치의 전원을 끄기 전 모든 제어상태를 정지 한다.
        CSetGcuCommand((Uint16)IDX_GCU_CMD_STOP);
        CSetEcuCommand((Uint16)IDX_ECU_CMD_EMERGENCY);
        COffChipSelect();

        if (GeneralOperValue.uiWriteEepromDataStart == 0U)
        {
            GeneralOperValue.uiWriteEepromDataStart = 1U;
        }

        // 최대 3초 경과 후 꺼짐
        if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_SHUTDOWN, (TIME_1SEC * 3U)) == (Uint16)TIME_OVER)
        {
            GpioDataRegs.GPCCLEAR.bit.GPIO65 = 1U; // GPIO_POWER_HOLD
        }
    }
}

void CUpdateFault(Uint32 *pData, Uint16 uiIdx, Uint16 uiCond)
{
    Uint32 ulMask;

    if (pData != NULL)
    {
        ulMask = 1UL << (Uint32)uiIdx;
        *pData = (uiCond != 0U) ? (*pData | ulMask) : (*pData & ~ulMask);
    }
}

Uint16 CIsBitSet(Uint32 ulData, Uint16 uiIdx)
{
    Uint32 ulMask;

    ulMask = 1UL << (Uint32)uiIdx;

    return (((ulData & ulMask) != 0UL) ? 1U : 0U);
}

void DELAY_USEC(Uint32 ulMicroSeconds)
{
    Uint32 ulDelayCount;

    ulDelayCount = (Uint32)((float64)(((((float64)ulMicroSeconds * 1000.0L) / (float64)CPU_RATE) - 9.0L) / 5.0L));

    DSP28x_usDelay(ulDelayCount);
}

void CSetAuxCtrlPin(E_AUX_CS_IDX eIdx, Uint16 uiState)
{
    switch (eIdx)
    {
        case IDX_CS_ENG_HEATER:
        {
            if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO49 = 1U; }
            else               { GpioDataRegs.GPBCLEAR.bit.GPIO49 = 1U; }
            break;
        }
        case IDX_CS_GLOW_PLUG:
        {
            if (uiState == 1U) { GpioDataRegs.GPASET.bit.GPIO27 = 1U; }
            else               { GpioDataRegs.GPACLEAR.bit.GPIO27 = 1U; }
            break;
        }
        case IDX_CS_SOLENOID:
        {
            if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO48 = 1U; }
            else               { GpioDataRegs.GPBCLEAR.bit.GPIO48 = 1U; }
            break;
        }
        case IDX_CS_FUEL_PUMP:
        {
            if (uiState == 1U) { GpioDataRegs.GPASET.bit.GPIO26 = 1U; }
            else               { GpioDataRegs.GPACLEAR.bit.GPIO26 = 1U; }
            break;
        }
        case IDX_CS_COOLANT_PUMP:
        {
            if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO52 = 1U; }
            else               { GpioDataRegs.GPBCLEAR.bit.GPIO52 = 1U; }
            break;
        }
        case IDX_CS_FAN1:
        {
            if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO50 = 1U; }
            else               { GpioDataRegs.GPBCLEAR.bit.GPIO50 = 1U; }
            break;
        }
        default:
        {
            if (eIdx == IDX_CS_FAN2)
            {
                if (uiState == 1U) { GpioDataRegs.GPBSET.bit.GPIO51 = 1U; }
                else               { GpioDataRegs.GPBCLEAR.bit.GPIO51 = 1U; }
            }
            break;
        }
    }
}