#include "main.h"

CPowerOnCheckValue PowerOnCheckValue;
CGeneralOperValue GeneralOperValue;

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

void CInitSystem(void);
void CInitGeneralOperValue(void);
void CInitGpio(void);
void CSystemConfigure(void);
void CMappingInterrupt(void);
void CProcessSoftTimer(void);
Uint16 CPowerOnCheck(void);
void CSoftTimerWorkProcess(void);
Uint16 CIsStatusSoftTimer(Uint16 ucTimerIndex);
void CReloadSoftTimer(Uint16 ucTimerIndex);
void CInitSoftTimers(void);
void CInitSoftTimer(void);
void CConfigSoftTimer(Uint16 ucTimerIndex, Uint32 ulDelay);
void CStartSoftTimer(Uint16 ucTimerIndex);
Uint16 CSoftClockTimeOut(Uint32 ulStartClock, Uint32 ulTimeOutClock);
Uint32 CGetSoftClock(void);
void CSOftWaitCountCancel(Uint16 Index);

int main(void)
{
    CSetApuOperIndex(APU_OPER_IDX_BOOT);

    CInitSystem(); 

    CInitOled();

    CSetApuOperIndex(APU_OPER_IDX_INITIAL);

    for ( ; ; )
    {
        CSoftTimerWorkProcess();

        if (CGetApuOperIndex() == APU_OPER_IDX_INITIAL)
        {
            if (OledOperValue.uiProgressDone == 1U)
            {
                if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_INIT, TIME_1SEC) == TIME_OVER)
                {
                    COledBufferReset();
                    CSetApuOperIndex(APU_OPER_IDX_POST); // Adc º¸Á¤¿Ï·á ÀÌ ÈÄ POST ½ÃÀÛ
                }
            }
        }
        else if (CGetApuOperIndex() == APU_OPER_IDX_POST)
        {
            if (CPowerOnCheck() == 0U)
            {
                AdcOperValue.uiOffsetAdjustStart = 1U; // ¼¾¼­ ¹®Á¦ ¾øÀ» °æ¿ì offset °è»ê.

                COledBufferReset();
                CSetApuOperIndex(APU_OPER_IDX_STANDBY);
            }
        }
        else
        {
            if (GeneralOperValue.uiMaintenence == 0U)
            {
                // Á¤ºñ ¸ðµå°¡ ²¨Á®ÀÖ¾î¾ß ½ÃÄö½º µ¿ÀÛ.
                //CApuOperProcedure();

                CLedControlProcedure();

                GPIO_ENGINE_HEATER_CS(GPIO_USER_MODE_1());
                GPIO_GLOW_PLUG_CS(GPIO_USER_MODE_1());
                GPIO_SOLENOID_CS(GPIO_USER_MODE_1());
                GPIO_FUEL_PUMP_CS(GPIO_USER_MODE_1());
                GPIO_COOLANT_PUMP_CS(GPIO_USER_MODE_1());
                GPIO_FAN1_CS(GPIO_USER_MODE_1());
                GPIO_FAN2_CS(GPIO_USER_MODE_1());
            }
            else
            {
                CDebugModeProcedure();
            }
        }
    }
}

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

    if (CIsStatusSoftTimer(TIMER_01MS) == SOFTTIMER_TIME_OVER) // Excute Per 1msec
    {
        CReloadSoftTimer(TIMER_01MS);

        if (GeneralOperValue.uiApuState > APU_OPER_IDX_POST) // ADC ¿ÀÇÁ¼Â º¸Á¤ ¿Ï·á ÈÄ °¨Áö
        {
            CAlarmProcedure();
            CDisplayAlarmPopup();
        }

        if (GeneralOperValue.Maintenence.KeyTest == 0U)
        {
            // (Á¤ºñ¸ðµå:Å°Å×½ºÆ®)°¡ ¾Æ´Ï¸é Å° ÀÔ·Â ½ÃÀÛ ÇÔ.
            CKeyCheckProcedure();
            CKeyWaitCount();
        }
    }

    if (CIsStatusSoftTimer(TIMER_10MS) == SOFTTIMER_TIME_OVER) // Excute Per 10msec
    {
        CReloadSoftTimer(TIMER_10MS);

        CSendECanDataA();
        CSendECanDataB();

        COledReflash(0, 0, OLED_WIDTH, OLED_HEIGHT);

        if (CGetApuOperIndex() == APU_OPER_IDX_INITIAL)
        {
            CInitializePage();
        }
        else
        {
            if (RefeshDelay == 0U)
            {
                if (CGetApuOperIndex() == APU_OPER_IDX_POST)
                {
                    CDisplayPostFail();
                }
                else
                {
                    CSetPage(OledOperValue.uiPageNum);
                }
            }
            RefeshDelay = (RefeshDelay + 1U) % 10U;
        }
    }

    if (CIsStatusSoftTimer(TIMER_100MS) == SOFTTIMER_TIME_OVER) // Excute Per 100msec
    {
        CReloadSoftTimer(TIMER_100MS);

        // Â÷·®Á¦¾îÄÄÇ»ÅÍÀÇ Åë½Å ¼ö½ÅÀÌ ÇѹøÀÌ¶óµµ µÇ¾úÀ» °æ¿ì Åë½Å ŸÀӾƿô üũ ½ÃÀÛ
        if (CApuSystemAlarmCheck() == 0U)
        {
            // °íÀå¹ß»ý½Ã ŸÀӾƿôÀº üũÇÏÁö ¾Ê´Â´Ù.
            CommCheck.CarComputer = ((GeneralOperValue.Conection.CarComputer == 1U) && (CommCheck.CarComputer < COMM_TIME_OUT_COUNT)) ? (CommCheck.CarComputer + 1U) : 0U;
            CommCheck.Gcu = ((GeneralOperValue.Conection.Gcu == 1U) && (CommCheck.Gcu < COMM_TIME_OUT_COUNT)) ? (CommCheck.Gcu + 1U) : 0U;
            CommCheck.Ecu = ((GeneralOperValue.Conection.Ecu == 1U) && (CommCheck.Ecu < COMM_TIME_OUT_COUNT)) ? (CommCheck.Ecu + 1U) : 0U;
        }
    }
    if (CIsStatusSoftTimer(TIMER_1SEC) == SOFTTIMER_TIME_OVER) // Excute Per 1s
    {
        CReloadSoftTimer(TIMER_1SEC);

        if (OledOperValue.uiAlreadyAlarm == 1U) // °æ°í °íÀå ¾Ë¶÷ ¹ß»ý ÈÄ ÇØÁ¦ µÇÁö ¾ÊÀ¸¸é 1ºÐµÚ ´Ù½Ã Æ˾÷ Çϱâ À§ÇÔ.
        {
            if (CSoftWaitCountProcedure(SOFTTIMER_WAIT_POPUP, (TIME_1SEC * 60UL)) == TIME_OVER)
            {
                OledOperValue.uiAlarmPopCheck = 0U;
                OledOperValue.uiAlreadyAlarm = 0U;
            }
        }
        else
        {
            CSOftWaitCountCancel(SOFTTIMER_WAIT_POPUP);
        }
    }
}

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

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

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

    return isRunning;
}

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) == SOFTTIMER_TIME_OVER)
            {
                WaitTimer[uiIndex].uiSoftCountTarget = 2U;
            }
            break;
        }
        default:
        {
            WaitTimer[uiIndex].ulCountSoftClock = 0U;
            WaitTimer[uiIndex].uiSoftCountTarget = 0U;
            isCountOver = 1U;
            break;
        }
    }

    return isCountOver;
}

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;
}

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
}

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.GPIO1  = 0U; // GPIO_COOLING_PUMP_FUSE
    GpioCtrlRegs.GPADIR.bit.GPIO2  = 0U; // GPIO_FUEL_PUMP_FUSE
    GpioCtrlRegs.GPADIR.bit.GPIO3  = 0U; // GPIO_COOLING_FAN1_FUSE
    GpioCtrlRegs.GPADIR.bit.GPIO4  = 0U; // GPIO_COOLING_FAN2_FUSE
    GpioCtrlRegs.GPADIR.bit.GPIO5  = 0U; // GPIO_GLOW_PLUG_FUSE
    GpioCtrlRegs.GPADIR.bit.GPIO6  = 0U; // GPIO_ENGINE_HEATER_FUSE
    GpioCtrlRegs.GPADIR.bit.GPIO7  = 0U; // GPIO_STOP_SOLENOID_FUSE
    GpioCtrlRegs.GPADIR.bit.GPIO8  = 0U; // GPIO_ECU_ON_OFF
    GpioCtrlRegs.GPADIR.bit.GPIO9  = 0U; // GPIO_FUEL_PUMP
    GpioCtrlRegs.GPADIR.bit.GPIO10 = 0U; // GPIO_GLOW_PLUG
    GpioCtrlRegs.GPADIR.bit.GPIO11 = 0U; // GPIO_STOP_SOLENOID
    GpioCtrlRegs.GPADIR.bit.GPIO24 = 0U; // GPIO_ENGINE_HEATER
    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.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.GPBDIR.bit.GPIO56 = 1U; // GPIO_EMERGENCY_CMD_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO57 = 1U; // GPIO_STOP_CMD_CS
    GpioCtrlRegs.GPBDIR.bit.GPIO58 = 1U; // GPIO_START_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.GPIO1 = 1U;   // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO2 = 1U;   // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO3 = 1U;   // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO4 = 1U;   // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO5 = 1U;   // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO6 = 1U;   // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO7 = 1U;   // 3 Clk Sampling
    GpioCtrlRegs.GPAQSEL1.bit.GPIO8 = 1U;   // 3 Clk Sampling
    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

    // Gpio Default Value Initial
    GPIO_POWER_HOLD(1);

    GPIO_CPU_LED_COM_FAULT_N(1);
    GPIO_CPU_LED_COM_RUN_N(1);
    GPIO_CPU_LED_COM_STA_N(1);

    EDIS;
}

void CActiveChipSelect(Uint16 Active)
{
    if (Active == 0U)
    {
        // ºñ»óÁ¤Áö »óȲ¿¡¼­´Â ¸ðµç CS¸¦ OFFÇÑ´Ù. (0 - CS OFF, 1 - CS ON)
        GPIO_ENGINE_HEATER_CS(0);
        GPIO_GLOW_PLUG_CS(0);
        GPIO_SOLENOID_CS(0);
        GPIO_FUEL_PUMP_CS(0);

        GPIO_COOLANT_PUMP_CS(0);
        GPIO_FAN1_CS(0);
        GPIO_FAN2_CS(0);
    }
    else
    {
        // ¿î¿µ »óÅ¿¡¼­´Â EcuSignalÀÇ »óŸ¦ È®ÀÎÇÏ°í ¿£ÁøÈ÷ÅÍ, ±Û·Î¿ìÇ÷¯±×, ¼Ö·¹³ëÀ̵å, ¿¬·áÆßÇÁ¸¦ µ¿ÀÛÇÑ´Ù.
        // 0 - CS OFF, 1 - CS ON
        GPIO_ENGINE_HEATER_CS(GPIO_ENGINE_HEATER());
        GPIO_GLOW_PLUG_CS(GPIO_GLOW_PLUG());
        GPIO_SOLENOID_CS(GPIO_SOLENOID());
        GPIO_FUEL_PUMP_CS(GPIO_FUEL_PUMP());

        GPIO_COOLANT_PUMP_CS(1);
        GPIO_FAN1_CS(1);
        GPIO_FAN2_CS(1);
    }
}

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;
}

void CSystemConfigure(void)
{
    CMappingInterrupt();

    CInitGeneralOperValue();

    CInitAdc();
    CInitEcan();

    CInitXintf();

    CInitSoftTimers();

    CInitKeyOperValue();
}

void CInitGeneralOperValue(void)
{
    (void) memset(&GeneralOperValue, 0, sizeof(CGeneralOperValue));
    (void) memset(&PowerOnCheckValue, 0x1FF, sizeof(CPowerOnCheckValue)); // Set All bit 1

    GeneralOperValue.uiPassword[OLED_PASS_DIGIT_1] = 0;
    GeneralOperValue.uiPassword[OLED_PASS_DIGIT_2] = 0;
    GeneralOperValue.uiPassword[OLED_PASS_DIGIT_3] = 0;
    GeneralOperValue.uiPassword[OLED_PASS_DIGIT_4] = 0;
}

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 = M_INT1 | M_INT9;

    EDIS;
}

void CProcessSoftTimer(void)
{
    Uint16 i;

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

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);
    CConfigSoftTimer(TIMER_1SEC,  TIME_1SEC);

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

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

void CInitSoftTimer(void)
{
    Uint16 i;

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

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

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

Uint16 CPowerOnCheck(void)
{
    // Åë½Å ¼ö½Å È®ÀÎÀº CAN ¼ö½Å ÀÎÅÍ·´Æ® ¹ß»ý ½Ã, üũ
    Uint16 retValue = (*(Uint16*)&PowerOnCheckValue) & 0x7FU;

    PowerOnCheckValue.EngineHeaterSensor = ((Adc_EngineHeater_I.iAdcValue > SENSOR_MIN_LIMIT) && (Adc_EngineHeater_I.iAdcValue < SENSOR_MAX_LIMIT)) ? 0U : 1U;
    PowerOnCheckValue.GlowPlugSensor     = ((Adc_GlowPlug_I.iAdcValue > SENSOR_MIN_LIMIT) && (Adc_GlowPlug_I.iAdcValue < SENSOR_MAX_LIMIT)) ? 0U : 1U;
    PowerOnCheckValue.SolenoidSensor     = ((Adc_Solenoid_I.iAdcValue > SENSOR_MIN_LIMIT) && (Adc_Solenoid_I.iAdcValue < SENSOR_MAX_LIMIT)) ? 0U : 1U;
    PowerOnCheckValue.FuelPumpSensor     = ((Adc_FuelPump_I.iAdcValue > SENSOR_MIN_LIMIT) && (Adc_FuelPump_I.iAdcValue < SENSOR_MAX_LIMIT)) ? 0U : 1U;
    PowerOnCheckValue.CoolantPumpSensor  = ((Adc_CoolantPump_I.iAdcValue > SENSOR_MIN_LIMIT) && (Adc_CoolantPump_I.iAdcValue < SENSOR_MAX_LIMIT)) ? 0U : 1U;
    PowerOnCheckValue.Fan1Sensor         = ((Adc_Fan1_I.iAdcValue > SENSOR_MIN_LIMIT) && (Adc_Fan1_I.iAdcValue < SENSOR_MAX_LIMIT)) ? 0U : 1U;
    PowerOnCheckValue.Fan2Sensor         = ((Adc_Fan2_I.iAdcValue > SENSOR_MIN_LIMIT) && (Adc_Fan2_I.iAdcValue < SENSOR_MAX_LIMIT)) ? 0U : 1U;

    return retValue; // '0' Á¤»ó
}