csu3_am335x/EVSE/Projects/DD360/Apps/ModuleInternalComm/RelayBoard.c

#include <stdio.h>      /*標準輸入輸出定義*/
#include <stdlib.h>     /*標準函數庫定義*/
#include <string.h>
#include <stdint.h>
#include <time.h>
#include <unistd.h>

#include <sys/time.h>
#include <sys/timeb.h>

#include "../ShareMemory/shmMem.h"
#include "../Config.h"
#include "../Log/log.h"
#include "Module_InternalComm.h"
#include "internalComm.h"
#include "../common.h"
//------------------------------------------------------------------------------
static struct SysConfigData *pSysConfig = NULL;
static struct SysInfoData *pSysInfo = NULL;
static struct AlarmCodeData *pAlarmCode = NULL;
static struct RelayModuleData *ShmRelayModuleData = NULL;
static struct PsuData *ShmPsuData = NULL;
static struct PrimaryMcuData *ShmPrimaryMcuData = NULL;
static DcCommonInfo *ShmDcCommonData = NULL;
static struct WARNING_CODE_INFO *pSysWarning = NULL;
static struct LedModuleData *ShmLedModuleData = NULL;
static struct FanModuleData *ShmFanModuleData = NULL;
static struct GBTData* ShmGBTData = NULL;
static Relay outputRelay = {0};
static Relay regRelay = {0};
static int Uart5Fd = 0;
static struct timespec gFanBoardRunTimer;
static uint16_t _setFanSpeed = 0;
static uint16_t fanSpeedSmoothValue = 1000;

static Led_Color cur_led_color = {COLOR_MIN_LV};
static Led_Color led_color;
static struct timespec _led_priority_time;
int ReservationLed;
bool LcmLoseFlash;
time_t ReservationFlashTimer;
//static bool _isRelayWelding[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
//static struct timeval _checkRelayWeldingTimer[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];

//static bool _isOutputNoneMatch[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
//static struct timeval _checkOutputNoneMatchTimer[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];

static bool _isOvpChkTimeFlag[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY]; //DS60-120 add
static struct timespec _checkOutputVolProtectTimer[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY]; //DS60-120 add

static void SetLedColor(void);
static struct timespec _close_ac_contactor;

//------------------------------------------------------------------------------
static void RunForceStopProcess(void)
{
    static bool isCriticalStop = NO;
    static struct timespec  _psuCriticalStop;
    uint32_t _timebuf;

    if (isCriticalStop == NO) {
        isCriticalStop = YES;
        GetClockTime(&_psuCriticalStop);
    } else {
        _timebuf = GetClockTimeoutValue(_psuCriticalStop);

        if (_timebuf < 0) {
            GetClockTime(&_psuCriticalStop);
        } else {
            if (_timebuf / 1000 >= (FORCE_STOP_TIME * 1000)) {
                isCriticalStop = NO;
                pAlarmCode->AlarmEvents.bits.PsuFailureAlarm = NORMAL;
            }
        }
    }
}

static void StopCheckRelayInfo(uint8_t _chkIndex)
{
    if (ShmDcCommonData->CheckRelayStatus[_chkIndex] != STOP) {
        ShmDcCommonData->CheckRelayStatus[_chkIndex] = STOP;
    }
}

static void StartCheckRelayInfo(uint8_t _chkIndex, uint8_t toState)
{
    // SMR1 *2 + SMR2 * 2 + Parallel * 2
    static struct timespec lastCheckRelayStateTimer[6] = {0};
    //uint8_t *pCheckRelayState = (uint8_t *)ShmDcCommonData->CheckRelayStatus[_chkIndex];

    if (ShmDcCommonData->CheckRelayStatus[_chkIndex] == STOP) {
        GetClockTime(&lastCheckRelayStateTimer[_chkIndex]);
        ShmDcCommonData->CheckRelayStatus[_chkIndex] = START;
    } else {
        if ((GetClockTimeoutValue(lastCheckRelayStateTimer[_chkIndex]) / 1000000) >= 1) {
            //log_info("relay welding or driving fault = %d ", _chkIndex);
            if (toState == 1) {
                ShmDcCommonData->CheckRelayStatus[_chkIndex] = RELAY_STATUS_ERROR_DRIVING;
            } else {
                ShmDcCommonData->CheckRelayStatus[_chkIndex] = RELAY_STATUS_ERROR_WELDING;
            }
            GetClockTime(&lastCheckRelayStateTimer[_chkIndex]);
        }
    }
}

static uint8_t getCommTargetID(uint8_t index)
{
    uint8_t targetID = 0;
    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);

    if (pSysConfig->TotalConnectorCount == 1) {
        if (strncmp((char *)&pSysConfig->ModelName[7], "0", 1) != 0) {
            targetID = 0x01;
        } else if (strncmp((char *)&pSysConfig->ModelName[9], "0", 1) != 0) {
            targetID = 0x02;
        }
    } else {
        targetID = pDcChargingInfo->Evboard_id;
    }

    return targetID;
}

/*static void MatchRelayStatus(void)
{
    // 因為 AC Contactor 沒有 Feedback，所以暫時先這樣處理
    //regRelay.relay_event.bits.AC_Contactor = outputRelay.relay_event.bits.AC_Contactor;
    //pSysInfo->AcContactorStatus =
    //    regRelay.relay_event.bits.AC_Contactor =
    //        outputRelay.relay_event.bits.AC_Contactor;
    regRelay.relay_event.bits.CCS_Precharge = outputRelay.relay_event.bits.CCS_Precharge;
    regRelay.relay_event.bits.Gun1_P = outputRelay.relay_event.bits.Gun1_P;
    regRelay.relay_event.bits.Gun1_N = outputRelay.relay_event.bits.Gun1_N;
    regRelay.relay_event.bits.Gun2_P = outputRelay.relay_event.bits.Gun2_P;
    regRelay.relay_event.bits.Gun2_N = outputRelay.relay_event.bits.Gun2_N;
    regRelay.relay_event.bits.Gun1_Parallel_P = outputRelay.relay_event.bits.Gun1_Parallel_P;
    regRelay.relay_event.bits.Gun1_Parallel_N = outputRelay.relay_event.bits.Gun1_Parallel_N;
}
*/

static bool IsNoneMatchRelayStatus(void)
{
    bool result = false;

    if (
        (regRelay.relay_event.bits.Gun1_P != outputRelay.relay_event.bits.Gun1_P) ||
        (regRelay.relay_event.bits.Gun1_N != outputRelay.relay_event.bits.Gun1_N) ||
        (regRelay.relay_event.bits.Gun2_P != outputRelay.relay_event.bits.Gun2_P) ||
        (regRelay.relay_event.bits.Gun2_N != outputRelay.relay_event.bits.Gun2_N)
    ) {
        result = true;
    }

    if (regRelay.relay_event.bits.Gun1_P != outputRelay.relay_event.bits.Gun1_P) {
        //log_info("SMR1:D+ Relay none match. ");
        StartCheckRelayInfo(RELAY_SMR1_P_STATUS, outputRelay.relay_event.bits.Gun1_P);
    } else {
        StopCheckRelayInfo(RELAY_SMR1_P_STATUS);
    }

    if (regRelay.relay_event.bits.Gun1_N != outputRelay.relay_event.bits.Gun1_N) {
        //log_info("SMR1:D- Relay none match. ");
        StartCheckRelayInfo(RELAY_SMR1_N_STATUS, outputRelay.relay_event.bits.Gun1_N);
    } else {
        StopCheckRelayInfo(RELAY_SMR1_N_STATUS);
    }

    if (regRelay.relay_event.bits.Gun2_P != outputRelay.relay_event.bits.Gun2_P) {
        //log_info("SMR2:D+ Relay none match. ");
        StartCheckRelayInfo(RELAY_SMR2_P_STATUS, outputRelay.relay_event.bits.Gun2_P);
    } else {
        StopCheckRelayInfo(RELAY_SMR2_P_STATUS);
    }

    if (regRelay.relay_event.bits.Gun2_N != outputRelay.relay_event.bits.Gun2_N) {
        //log_info("SMR2:D- Relay none match. ");
        StartCheckRelayInfo(RELAY_SMR2_N_STATUS, outputRelay.relay_event.bits.Gun2_N);
    } else {
        StopCheckRelayInfo(RELAY_SMR2_N_STATUS);
    }

    return result;
}

static void GetGfdAdc(void)
{
    int gunIndex = 0;
    uint8_t targetID = 0;
    struct ChargingInfoData *pDcChargingInfo = NULL;
    Gfd gfd_adc = {0};

    // define : 每 0.2 ~ 1 秒一次
    // occur : <= 75k 歐姆 @ 150 - 750 Vdc
    // warning : >= 100 歐姆 && <= 500 歐姆 @ 150-750 Vdc
    if (Query_Gfd_Adc(Uart5Fd, ADDR_RELAY, &gfd_adc) == PASS) {
        for (gunIndex = 0; gunIndex < pSysConfig->TotalConnectorCount; gunIndex++) {
            pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(gunIndex);

            if (pDcChargingInfo->Type == 0x09 &&
                    !pSysConfig->AlwaysGfdFlag
               ) {
                if ((pDcChargingInfo->PresentChargingVoltage * 10) >= VOUT_MIN_VOLTAGE) {
                    pDcChargingInfo->GroundFaultStatus = GFD_PASS;
                }
                continue;
            }

            targetID = getCommTargetID(gunIndex);

            if (targetID == 0x01) {
                //if (gfd_adc.result_conn1 == GFD_WARNING) {
                //    gfd_adc.result_conn1 = GFD_PASS;
                //}

                pDcChargingInfo->GroundFaultStatus = gfd_adc.result_conn1;
                //log_info("GFD ******** Result = %d, Step = %d, R = %d, Vol = %d ",
                //            pDcChargingInfo->GroundFaultStatus,
                //            gfd_adc.rb_step_1,
                //            gfd_adc.Resister_conn1,
                //            gfd_adc.voltage_conn1);
                if (pDcChargingInfo->GroundFaultStatus == GFD_FAIL) {
                    log_info("GFD Fail. index = %d, Step = %d, R = %d, Vol = %d ",
                             gunIndex,
                             gfd_adc.rb_step_1,
                             gfd_adc.Resister_conn1,
                             gfd_adc.voltage_conn1);

                } else if (pDcChargingInfo->GroundFaultStatus == GFD_PASS ||
                           pDcChargingInfo->GroundFaultStatus == GFD_WARNING
                          ) {
                    if (pDcChargingInfo->GroundFaultStatus == GFD_WARNING) {
                        log_info("GFD Warning. index = %d, Result = %d, R = %d, Vol = %d ",
                                 gunIndex,
                                 pDcChargingInfo->GroundFaultStatus,
                                 gfd_adc.Resister_conn1,
                                 gfd_adc.voltage_conn1);
                    }
                }
            } else if (targetID == 0x02) {
                //if (gfd_adc.result_conn2 == GFD_WARNING) {
                //    gfd_adc.result_conn2 = GFD_PASS;
                //}
                pDcChargingInfo->GroundFaultStatus = gfd_adc.result_conn2;
                if (pDcChargingInfo->GroundFaultStatus == GFD_FAIL) {
                    log_info("GFD Fail. index = %d, Step = %d, R = %d, Vol = %d ",
                             gunIndex,
                             gfd_adc.rb_step_2,
                             gfd_adc.Resister_conn2,
                             gfd_adc.voltage_conn2);
                } else if (pDcChargingInfo->GroundFaultStatus == GFD_PASS ||
                           pDcChargingInfo->GroundFaultStatus == GFD_WARNING
                          ) {
                    if (pDcChargingInfo->GroundFaultStatus == GFD_WARNING) {
                        log_info("GFD Warning. index = %d, Result = %d, R = %d, Vol = %d ",
                                 gunIndex,
                                 pDcChargingInfo->GroundFaultStatus,
                                 gfd_adc.Resister_conn1,
                                 gfd_adc.voltage_conn1);
                    }
                }
            }
        }
    }
}

void CheckOutputPowerOverCarReq(uint8_t index)
{
    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);
    ShmGBTData = (struct GBTData*)GetShmGBTData();
    float fireV = pDcChargingInfo->FireChargingVoltage;
    float carV = pDcChargingInfo->EvBatteryMaxVoltage * 10;
    /*
    log_info("PresentChargingVoltage:%f, FireChargingVoltage:%f ", pDcChargingInfo->PresentChargingVoltage * 10, pDcChargingInfo->FireChargingVoltage);
    log_info("fireV:%f, carV:%f, _isOvpChkTimeFlag:%d", fireV, carV, _isOvpChkTimeFlag[index]);
    log_info("EvBatterytargetVoltage:%f", pDcChargingInfo->EvBatterytargetVoltage);
    if (pDcChargingInfo->Type == _Type_GB) {
        log_info("GB EV Board Status:%d", ShmGBTData->ev[pDcChargingInfo->type_index].PresentMsgFlowStatus);
    }
    */
    if ((pDcChargingInfo->EvBatterytargetVoltage * 10) > 1500 &&
            (pDcChargingInfo->Type == _Type_Chademo ||
             pDcChargingInfo->Type == _Type_CCS_2 ||
             pDcChargingInfo->Type == _Type_GB)) {
        if (fireV >= (carV + (carV * 0.02))) {
            if (!_isOvpChkTimeFlag[index]) {
                if ((pDcChargingInfo->PresentChargingVoltage * 10) >= VOUT_MIN_VOLTAGE * 10) {
                    GetClockTime(&_checkOutputVolProtectTimer[index]);
                    _isOvpChkTimeFlag[index] = YES;
                }
            } else {
                log_error("[Module_InternalComm]CheckOutputPowerOverCarReq NG : fire = %f, battery = %f, OVP = %f",
                         pDcChargingInfo->FireChargingVoltage,
                         (pDcChargingInfo->EvBatterytargetVoltage * 10),
                         (carV + (carV * 0.02)));

                if ((GetClockTimeoutValue(_checkOutputVolProtectTimer[index]) / 1000) >= OUTPUT_VOL_CHK_TIME) {
                    if (pDcChargingInfo->Type == _Type_Chademo) {
                        //pAlarmCode->AlarmEvents.bits.SystemChademoOutputOVP = YES;
                        ShmDcCommonData->ConnectErrList[index].GunBits.ChaConnectOVP = YES;
                    } else if (pDcChargingInfo->Type == _Type_CCS_2) {
                        //pAlarmCode->AlarmEvents.bits.SystemCcsOutputOVP = YES;
                        ShmDcCommonData->ConnectErrList[index].GunBits.CCSConnectOVP = YES;
                    } else if (pDcChargingInfo->Type == _Type_GB) {
                        //pAlarmCode->AlarmEvents.bits.SystemGbOutputOVP = YES;
                        ShmDcCommonData->ConnectErrList[index].GunBits.GBTConnectOVP = YES;
                    }
                    //pDcChargingInfo->StopChargeFlag = YES;
                }
            }
        } else {
            if (_isOvpChkTimeFlag[index] == YES) {
                _isOvpChkTimeFlag[index] = NO;
            }
        }
    }
}

void ResetDetAlarmStatus(uint8_t gun)
{
    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(gun);

    if (pDcChargingInfo->Type == _Type_Chademo) {
        if (pAlarmCode->AlarmEvents.bits.SystemChademoOutputOVP == YES) {
            pAlarmCode->AlarmEvents.bits.SystemChademoOutputOVP = NO;
        }
    } else if (pDcChargingInfo->Type == _Type_GB) {
        if (pAlarmCode->AlarmEvents.bits.SystemGbOutputOVP == YES) {
            pAlarmCode->AlarmEvents.bits.SystemGbOutputOVP = NO;
        }
    } else if (pDcChargingInfo->Type == _Type_CCS_2) {
        if (pAlarmCode->AlarmEvents.bits.SystemCcsOutputOVP == YES) {
            pAlarmCode->AlarmEvents.bits.SystemCcsOutputOVP = NO;
        }
    }
}

void CheckAcInputOvpStatus(uint8_t index)
{
    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);

    if (pAlarmCode->AlarmEvents.bits.SystemL1InputOVP == YES ||
            pAlarmCode->AlarmEvents.bits.SystemL2InputOVP == YES ||
            pAlarmCode->AlarmEvents.bits.SystemL3InputOVP == YES) {
//      if ((pDcChargingInfo->SystemStatus >= S_PREPARNING && pDcChargingInfo->SystemStatus <= S_CHARGING) ||
//              (pDcChargingInfo->SystemStatus >= S_CCS_PRECHARGE_ST0 && pDcChargingInfo->SystemStatus <= S_CCS_PRECHARGE_ST1))
//      {
//          if (pSysInfo->ChargerType == _CHARGER_TYPE_IEC)
//          {
//              if (_psuInputVolR > VIN_MAX_VOLTAGE_IEC ||
//                      _psuInputVolS > VIN_MAX_VOLTAGE_IEC ||
//                      _psuInputVolT > VIN_MAX_VOLTAGE_IEC)
//              {
//                  log_info("IEC _psuInputVolR = %f, _psuInputVolS = %f, _psuInputVolT = %f ",
//                          _psuInputVolR, _psuInputVolS, _psuInputVolT);
//                  pDcChargingInfo->StopChargeFlag = YES;
//              }
//
//          }
//          else if (pSysInfo->ChargerType == _CHARGER_TYPE_UL)
//          {
//              if (_psuInputVolR > VIN_MAX_VOLTAGE_UL ||
//                      _psuInputVolS > VIN_MAX_VOLTAGE_UL ||
//                      _psuInputVolT > VIN_MAX_VOLTAGE_UL)
//              {
//                  log_info("UL _psuInputVolR = %f, _psuInputVolS = %f, _psuInputVolT = %f ",
//                          _psuInputVolR, _psuInputVolS, _psuInputVolT);
//                  pDcChargingInfo->StopChargeFlag = YES;
//              }
//          }
//      }
//      else
        //log_info("CheckAcInputOvpStatus");
        pDcChargingInfo->StopChargeFlag = YES;
    }
}

//void CheckOutputVolNoneMatchFire(uint8_t index)
//{
//    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);
//
//    if ((pDcChargingInfo->EvBatterytargetVoltage * 10) > 1500 &&
//            (pDcChargingInfo->Type == _Type_Chademo ||
//             pDcChargingInfo->Type == _Type_CCS_2 ||
//             pDcChargingInfo->Type == _Type_GB)) {
//        if (((pDcChargingInfo->PresentChargingVoltage * 10) < pDcChargingInfo->FireChargingVoltage - 300) ||
//                ((pDcChargingInfo->PresentChargingVoltage * 10) > pDcChargingInfo->FireChargingVoltage + 300)) {
//            if (!_isOutputNoneMatch[index]) {
//                _isOutputNoneMatch[index] = YES;
//                GetClockTime(&_checkOutputNoneMatchTimer[index], NULL);
//            } else {
//                if ((GetClockTimeoutValue(_checkOutputNoneMatchTimer[index]) / 1000) >= 5000) {
//                    /*log_info("[Module_InternalComm]CheckOutputVolNoneMatchFire NG (%d) : pre = %f, fire = %f ",
//                            index, (pDcChargingInfo->PresentChargingVoltage * 10), pDcChargingInfo->FireChargingVoltage);
//                    log_error("[Module_InternalComm]CheckOutputVolNoneMatchFire NG (%d): pre = %f, fire = %f ",
//                            index, (pDcChargingInfo->PresentChargingVoltage * 10), pDcChargingInfo->FireChargingVoltage);
//                    pDcChargingInfo->StopChargeFlag = YES;*/
//                }
//            }
//        } else {
//            _isOutputNoneMatch[index] = NO;
//        }
//    }
//}

void CheckPhaseLossStatus(uint8_t index)
{
    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);

    if (pAlarmCode->AlarmEvents.bits.SystemL1InputUVP == YES ||
            pAlarmCode->AlarmEvents.bits.SystemL2InputUVP == YES ||
            pAlarmCode->AlarmEvents.bits.SystemL3InputUVP == YES) {
        //log_info("CheckPhaseLossStatus");
        pDcChargingInfo->StopChargeFlag = YES;
    }
}

void SetK1K2RelayStatus(uint8_t index)
{
    uint8_t targetID = 0;
    PreChargingState *pRegPreChargingState = NULL;
    PreChargingState *pOutputPreChargingState = NULL;
    GunPNState *pRegGunPNState = NULL;
    GunPNState *pOutputGunPNState = NULL;
    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);

    if (ShmPsuData->Work_Step >= _TEST_MODE &&
            ShmPsuData->Work_Step <= _TEST_MODE) {
        if (regRelay.relay_event.bits.Gun1_N == NO) {
            outputRelay.relay_event.bits.Gun1_N = YES;
        } else if (regRelay.relay_event.bits.Gun1_P == NO) {
            outputRelay.relay_event.bits.Gun1_P = YES;
        }
        return;
    }

    targetID = getCommTargetID(index);

    pRegPreChargingState = (PreChargingState *)&regRelay.relay_event.relay_status[0];
    pOutputPreChargingState = (PreChargingState *)&outputRelay.relay_event.relay_status[0];
    if (targetID == 0x01) {
        pRegGunPNState = (GunPNState *)&regRelay.relay_event.relay_status[1];
        pOutputGunPNState = (GunPNState *)&outputRelay.relay_event.relay_status[1];
    } else if (targetID == 0x02) {
        pRegGunPNState = (GunPNState *)&regRelay.relay_event.relay_status[2];
        pOutputGunPNState = (GunPNState *)&outputRelay.relay_event.relay_status[2];
    }

    switch (pDcChargingInfo->SystemStatus) {
    case S_BOOTING:
    case S_IDLE:
    case S_AUTHORIZING:
    case S_REASSIGN_CHECK:
    case S_REASSIGN:
    case S_PREPARNING:
    case S_PREPARING_FOR_EV:
        if (pRegGunPNState->GunP == YES) {
            pOutputGunPNState->GunP = NO;
        } else if (pRegGunPNState->GunN == YES) {
            pOutputGunPNState->GunN = NO;
        }

        if (targetID == 0x02 && pDcChargingInfo->Type == _Type_CCS_2) {
            if (pRegPreChargingState->CcsPrecharge == YES) {
                pOutputPreChargingState->CcsPrecharge = NO;
            }
        }
        break;

    case S_PREPARING_FOR_EVSE:
    case S_CHARGING:
        //if (pDcChargingInfo->RelayWeldingCheck != YES) {
        //    break;
        //}
        if (pRegGunPNState->GunN == NO) {
            if (pDcChargingInfo->GroundFaultStatus != GFD_FAIL) {
                pOutputGunPNState->GunN = YES;
            } else {
                pOutputGunPNState->GunN = NO;
            }
        } else {
            if (pDcChargingInfo->GroundFaultStatus == GFD_FAIL) {
                pOutputGunPNState->GunN = NO;
            }
        }
        if (pRegGunPNState->GunP == NO) {
            if (pDcChargingInfo->GroundFaultStatus != GFD_FAIL) {
                pOutputGunPNState->GunP = YES;
            } else {
                pOutputGunPNState->GunP = NO;
            }
        } else {
            if (pDcChargingInfo->GroundFaultStatus == GFD_FAIL) {
                pOutputGunPNState->GunP = NO;
            }
        }
        break;

    case S_TERMINATING:
    case S_COMPLETE:
    case S_ALARM:
        if ((pDcChargingInfo->PresentChargingCurrent * 10) <= SEFETY_SWITCH_RELAY_CUR) {
            pOutputGunPNState->GunP = NO;
            pOutputGunPNState->GunN = NO;
        }
        if (pDcChargingInfo->GroundFaultStatus == GFD_FAIL) {
            pOutputGunPNState->GunP = NO;
            pOutputGunPNState->GunN = NO;
        }
        break;

    case S_CCS_PRECHARGE_ST0:
#if defined DD360 || defined DD360Audi || defined DD360ComBox
        break;
#endif //defined DD360 || defined DD360Audi || defined DD360ComBox

        //if (pDcChargingInfo->Type == _Type_CCS_2 && targetID == 0x02) {
        //    if (pRegPreChargingState->CcsPrecharge == NO) {
        //        pOutputPreChargingState->CcsPrecharge = YES;
        //    } else if (pRegPreChargingState->CcsPrecharge == YES) {
        //        pRegGunPNState->GunP = NO;
        //    }
        //}
        if (pDcChargingInfo->GroundFaultStatus == GFD_FAIL) {
            pOutputGunPNState->GunP = NO;
            pOutputGunPNState->GunN = NO;
        }
        break;

    case S_CCS_PRECHARGE_ST1:
#if defined DD360 || defined DD360Audi || defined DD360ComBox
        break;
#endif //defined DD360 || defined DD360Audi || defined DD360ComBox

        //if (pDcChargingInfo->Type == _Type_CCS_2 && targetID == 0x02) {
        //    if (pRegGunPNState->GunP == NO) {
        //        pOutputGunPNState->GunP = YES;
        //    } else if (pRegGunPNState->GunP == YES) {
        //        pOutputPreChargingState->CcsPrecharge = NO;
        //    }
        //}
        if (pDcChargingInfo->GroundFaultStatus == GFD_FAIL) {
            pOutputGunPNState->GunP = NO;
            pOutputGunPNState->GunN = NO;
        }
        break;
    }
}

// 確認 K1 K2 relay 的狀態
void CheckK1K2RelayOutput(uint8_t index)
{
    uint8_t targetID = 0;
    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);

    targetID = getCommTargetID(index);

    switch (targetID) {
    case 0x01:
        if (regRelay.relay_event.bits.Gun1_N == YES && regRelay.relay_event.bits.Gun1_P == YES) {
            pDcChargingInfo->RelayK1K2Status = YES;
        } else {
            pDcChargingInfo->RelayK1K2Status = NO;
        }

        if (pDcChargingInfo->Type == _Type_CCS_2) {
#if !defined DD360 && !defined DD360Audi && !defined DD360ComBox
            if (regRelay.relay_event.bits.Gun1_N == YES && regRelay.relay_event.bits.CCS_Precharge == YES) {
                pDcChargingInfo->RelayKPK2Status = YES;
            } else {
                pDcChargingInfo->RelayKPK2Status = NO;
            }
#else
            if (pDcChargingInfo->SystemStatus == S_CCS_PRECHARGE_ST0) {
                pDcChargingInfo->RelayKPK2Status = YES;
            } else {
                pDcChargingInfo->RelayKPK2Status = NO;
            }
#endif //!defined DD360 && !defined DD360Audi
        }
        break;

    case 0x02:
        if (regRelay.relay_event.bits.Gun2_N == YES &&
                regRelay.relay_event.bits.Gun2_P == YES) {
            pDcChargingInfo->RelayK1K2Status = YES;
        } else {
            pDcChargingInfo->RelayK1K2Status = NO;
        }

        if (pDcChargingInfo->Type == _Type_CCS_2) {
#if !defined DD360 && !defined DD360Audi && !defined DD360ComBox
            if (regRelay.relay_event.bits.Gun2_N == YES &&
                    regRelay.relay_event.bits.CCS_Precharge == YES) {
                pDcChargingInfo->RelayKPK2Status = YES;
            } else {
                pDcChargingInfo->RelayKPK2Status = NO;
            }
#else
            if (pDcChargingInfo->SystemStatus == S_CCS_PRECHARGE_ST0) {
                pDcChargingInfo->RelayKPK2Status = YES;
            } else {
                pDcChargingInfo->RelayKPK2Status = NO;
            }
#endif //!defined DD360 && !defined DD360Audi
        }
        break;
    }

#if !defined DD360 && !defined DD360Audi && !defined DD360ComBox
    //DS60-120 add
    if (pSysInfo->BridgeRelayStatus == YES) {
        if (regRelay.relay_event.bits.Gun1_Parallel_N == NO &&
                regRelay.relay_event.bits.Gun1_Parallel_P == NO) {
            pSysInfo->BridgeRelayStatus = NO;
        }
    } else if (pSysInfo->BridgeRelayStatus == NO) {
        if (regRelay.relay_event.bits.Gun1_Parallel_N == YES &&
                regRelay.relay_event.bits.Gun1_Parallel_P == YES) {
            pSysInfo->BridgeRelayStatus = YES;
        }
    }
#else
    pSysInfo->BridgeRelayStatus = YES;
#endif //!defined DD360 && !defined DD360Audi
}

void SetGfdConfig(uint8_t index, uint8_t resister)
{
    Gfd_config gfd_config = {
        .index = index,
        .state = resister,
    };

    //log_info("************************GFD Vol = %d, GFD Res = %d ", gfd_config.reqVol, gfd_config.resister);
    if (Config_Gfd_Value(Uart5Fd, ADDR_RELAY, &gfd_config) == PASS) {
//      log_info("Set reqVol = %f, resister = %d ",
//              gfd_config.reqVol,
//              gfd_config.resister);
    }
}

void CableCheckDetected(uint8_t index)
{
    uint8_t targetID = 0;
    struct ChargingInfoData *pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);
    // Cable Check
    // 當火線上的電壓 = 車端要求的電壓電流
    // _chargingData[targetGun]->EvBatterytargetVoltage
    // 才可以開始偵測 1s
    // Warning : Rgfd <= 150 歐/V 假設電壓為 500V 則~ Rgfd <= 75000 歐
    // Pre-Warning : 150 歐/V < Rgfd <= 500 歐/V 假設電壓為 500V 則 75000 歐 < Rgfd <= 250000
    // SO Normal : Rgfd > 500 歐/V 假設電壓為 500 V 則 Rgfd > 250000 歐

    if (pSysConfig->TotalConnectorCount == 1) {
        if (strncmp((char *)&pSysConfig->ModelName[7], "0", 1) != 0) {
            targetID = 0;
        } else if (strncmp((char *)&pSysConfig->ModelName[9], "0", 1) != 0) {
            targetID = 1;
        }
    } else {
        targetID = index;
    }

    if ((pDcChargingInfo->Type >= _Type_Chademo &&
            pDcChargingInfo->Type <= _Type_GB) ||
            (pDcChargingInfo->Type == 0x09 &&
             pSysConfig->AlwaysGfdFlag)
       ) {
        if ((pDcChargingInfo->SystemStatus >= S_PREPARING_FOR_EVSE &&
                pDcChargingInfo->SystemStatus < S_TERMINATING) ||
                (pDcChargingInfo->SystemStatus >= S_CCS_PRECHARGE_ST0 &&
                 pDcChargingInfo->SystemStatus <= S_CCS_PRECHARGE_ST1)
           ) {
            //if ((pDcChargingInfo->SystemStatus == S_PREPARING_FOR_EVSE) &&
            //        (pDcChargingInfo->RelayWeldingCheck == YES)
            //   ) {
            if (pDcChargingInfo->SystemStatus == S_PREPARING_FOR_EVSE) {
                SetGfdConfig(targetID, GFD_CABLECHK);
            } else if ((pDcChargingInfo->SystemStatus >= S_CCS_PRECHARGE_ST0) &&
                       (pDcChargingInfo->SystemStatus <= S_CCS_PRECHARGE_ST1)
                      ) {
                SetGfdConfig(targetID, GFD_PRECHARGE);
            } else if ((pDcChargingInfo->SystemStatus >= S_CHARGING) &&
                       (pDcChargingInfo->SystemStatus < S_TERMINATING)
                      ) {
                if ((pDcChargingInfo->Type == _Type_GB) ||
                        (pDcChargingInfo->Type == _Type_Chademo)
                   ) {
                    SetGfdConfig(targetID, GFD_IDLE);
                } else {
                    SetGfdConfig(targetID, GFD_CHARGING);
                }
            }
        }
        else if(pDcChargingInfo->SystemStatus == S_TERMINATING || pDcChargingInfo->SystemStatus == S_ALARM)
        {
            if (pDcChargingInfo->Type == _Type_CCS_2)
            {
                SetGfdConfig(targetID, GFD_CHARGING);
            }
        } else {
            SetGfdConfig(targetID, GFD_IDLE);
        }
    }
}

// 讀取 Relay 狀態
void GetRelayOutputStatus(void)
{
    if (Query_Relay_Output(Uart5Fd, ADDR_RELAY, &regRelay) == PASS) {

    }
}

// AC 三相輸入電壓
void GetPresentInputVol(void)
{
    static uint8_t _threePhaseOvp[3] = {0, 0, 0}; //DS60-120 add
    static uint8_t _threePhaseUvp[3] = {0, 0, 0}; //DS60-120 add
    PresentInputVoltage inputVoltage = {0};

    if (Query_Present_InputVoltage(Uart5Fd, ADDR_RELAY, &inputVoltage) == PASS) {
        // resolution : 0.1
        pSysInfo->InputVoltageR = ShmRelayModuleData->InputL1Volt = inputVoltage.L1N_L12;
        pSysInfo->InputVoltageS = ShmRelayModuleData->InputL2Volt = inputVoltage.L2N_L23;
        pSysInfo->InputVoltageT = ShmRelayModuleData->InputL3Volt = inputVoltage.L3N_L31;

        //********************************************************************************************************//
        // Vin (UVP)
        if (pSysInfo->ChargerType == _CHARGER_TYPE_IEC) {
            if (pAlarmCode->AlarmEvents.bits.SystemL1InputUVP == NO) {
                if (inputVoltage.L1N_L12 < VIN_MIN_VOLTAGE_IEC) {
                    log_info("In Uvp L1N_L12 = %f ", inputVoltage.L1N_L12);
                    if (_threePhaseUvp[0] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL1InputUVP = YES;
                    } else {
                        _threePhaseUvp[0] += 1;
                    }
                }
            } else {
                if (inputVoltage.L1N_L12 > VIN_MIN_REV_VOLTAGE_IEC) {
                    pAlarmCode->AlarmEvents.bits.SystemL1InputUVP = NO;
                    _threePhaseUvp[0] = 0;
                }
            }

            if (pAlarmCode->AlarmEvents.bits.SystemL2InputUVP == NO) {
                if (inputVoltage.L2N_L23 < VIN_MIN_VOLTAGE_IEC) {
                    log_info("In Uvp L2N_L23 = %f ", inputVoltage.L2N_L23);
                    if (_threePhaseUvp[1] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL2InputUVP = YES;
                    } else {
                        _threePhaseUvp[1] += 1;
                    }
                }
            } else {
                if (inputVoltage.L2N_L23 > VIN_MIN_REV_VOLTAGE_IEC) {
                    pAlarmCode->AlarmEvents.bits.SystemL2InputUVP = NO;
                    _threePhaseUvp[1] = 0;
                }
            }

            if (pAlarmCode->AlarmEvents.bits.SystemL3InputUVP == NO) {
                if (inputVoltage.L3N_L31 < VIN_MIN_VOLTAGE_IEC) {
                    log_info("In Uvp L3N_L31 = %f ", inputVoltage.L3N_L31);
                    if (_threePhaseUvp[2] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL3InputUVP = YES;
                    } else {
                        _threePhaseUvp[2] += 1;
                    }
                }
            } else {
                if (inputVoltage.L3N_L31 > VIN_MIN_REV_VOLTAGE_IEC) {
                    pAlarmCode->AlarmEvents.bits.SystemL3InputUVP = NO;
                    _threePhaseUvp[2] = 0;
                }
            }
        } else if (pSysInfo->ChargerType == _CHARGER_TYPE_UL) {
            if (pAlarmCode->AlarmEvents.bits.SystemL1InputUVP == NO) {
                if (inputVoltage.L1N_L12 < VIN_MIN_VOLTAGE_UL) {
                    log_info("In Uvp L1N_L12 = %f ", inputVoltage.L1N_L12);
                    if (_threePhaseUvp[0] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL1InputUVP = YES;
                    } else {
                        _threePhaseUvp[0] += 1;
                    }
                }
            } else {
                if (inputVoltage.L1N_L12 > VIN_MIN_REV_VOLTAGE_UL) {
                    pAlarmCode->AlarmEvents.bits.SystemL1InputUVP = NO;
                    _threePhaseUvp[0] = 0;
                }
            }

            if (pAlarmCode->AlarmEvents.bits.SystemL2InputUVP == NO) {
                if (inputVoltage.L2N_L23 < VIN_MIN_VOLTAGE_UL) {
                    log_info("In Uvp L2N_L23 = %f ", inputVoltage.L2N_L23);
                    if (_threePhaseUvp[1] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL2InputUVP = YES;
                    } else {
                        _threePhaseUvp[1] += 1;
                    }
                }
            } else {
                if (inputVoltage.L2N_L23 > VIN_MIN_REV_VOLTAGE_UL) {
                    pAlarmCode->AlarmEvents.bits.SystemL2InputUVP = NO;
                    _threePhaseUvp[1] = 0;
                }
            }

            if (pAlarmCode->AlarmEvents.bits.SystemL3InputUVP == NO) {
                if (inputVoltage.L3N_L31 < VIN_MIN_VOLTAGE_UL) {
                    log_info("In Uvp L3N_L31 = %f ", inputVoltage.L3N_L31);
                    if (_threePhaseUvp[2] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL3InputUVP = YES;
                    } else {
                        _threePhaseUvp[2] += 1;
                    }
                }
            } else {
                if (inputVoltage.L3N_L31 > VIN_MIN_REV_VOLTAGE_UL) {
                    pAlarmCode->AlarmEvents.bits.SystemL3InputUVP = NO;
                    _threePhaseUvp[2] = 0;
                }
            }
        }

        //********************************************************************************************************//
        // Vin (OVP)
        if (pSysInfo->ChargerType == _CHARGER_TYPE_IEC) {
            if (pAlarmCode->AlarmEvents.bits.SystemL1InputOVP == NO) {
                if (inputVoltage.L1N_L12 > VIN_MAX_VOLTAGE_IEC) {
                    log_info("In Ovp L1N_L12 = %f ", inputVoltage.L1N_L12);
                    if (_threePhaseOvp[0] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL1InputOVP = YES;
                    } else {
                        _threePhaseOvp[0] += 1;
                    }
                }
            } else {
                if (inputVoltage.L1N_L12 < VIN_MAX_REV_VOLTAGE_IEC) {
                    pAlarmCode->AlarmEvents.bits.SystemL1InputOVP = NO;
                    _threePhaseOvp[0] = 0;
                }
            }

            if (pAlarmCode->AlarmEvents.bits.SystemL2InputOVP == NO) {
                if (inputVoltage.L2N_L23 > VIN_MAX_VOLTAGE_IEC) {
                    log_info("In Ovp L2N_L23 = %f ", inputVoltage.L2N_L23);
                    if (_threePhaseOvp[1] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL2InputOVP = YES;
                    } else {
                        _threePhaseOvp[1] += 1;
                    }
                }
            } else {
                if (inputVoltage.L2N_L23 < VIN_MAX_REV_VOLTAGE_IEC) {
                    pAlarmCode->AlarmEvents.bits.SystemL2InputOVP = NO;
                    _threePhaseOvp[1] = 0;
                }
            }

            if (pAlarmCode->AlarmEvents.bits.SystemL3InputOVP == NO) {
                if (inputVoltage.L3N_L31 > VIN_MAX_VOLTAGE_IEC) {
                    log_info("In Ovp L3N_L31 = %f ", inputVoltage.L3N_L31);
                    if (_threePhaseOvp[2] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL3InputOVP = YES;
                    } else {
                        _threePhaseOvp[2] += 1;
                    }
                }
            } else {
                if (inputVoltage.L3N_L31 < VIN_MAX_REV_VOLTAGE_IEC) {
                    pAlarmCode->AlarmEvents.bits.SystemL3InputOVP = NO;
                    _threePhaseOvp[2] = 0;
                }
            }
        } else if (pSysInfo->ChargerType == _CHARGER_TYPE_UL) {
            if (pAlarmCode->AlarmEvents.bits.SystemL1InputOVP == NO) {
                if (inputVoltage.L1N_L12 > VIN_MAX_VOLTAGE_UL) {
                    log_info("In Ovp L1N_L12 = %f ", inputVoltage.L1N_L12);
                    if (_threePhaseOvp[0] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL1InputOVP = YES;
                    } else {
                        _threePhaseOvp[0] += 0;
                    }
                }
            } else {
                if (inputVoltage.L1N_L12 < VIN_MAX_REV_VOLTAGE_UL) {
                    pAlarmCode->AlarmEvents.bits.SystemL1InputOVP = NO;
                    _threePhaseOvp[0] = 0;
                }
            }

            if (pAlarmCode->AlarmEvents.bits.SystemL2InputOVP == NO) {
                if (inputVoltage.L2N_L23 > VIN_MAX_VOLTAGE_UL) {
                    log_info("In Ovp L2N_L23 = %f ", inputVoltage.L2N_L23);
                    if (_threePhaseOvp[1] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL2InputOVP = YES;
                    } else {
                        _threePhaseOvp[1] += 0;
                    }
                }
            } else {
                if (inputVoltage.L2N_L23 < VIN_MAX_REV_VOLTAGE_UL) {
                    pAlarmCode->AlarmEvents.bits.SystemL2InputOVP = NO;
                    _threePhaseOvp[1] = 0;
                }
            }

            if (pAlarmCode->AlarmEvents.bits.SystemL2InputOVP == NO) {
                if (inputVoltage.L3N_L31 > VIN_MAX_VOLTAGE_UL) {
                    log_info("In Ovp L3N_L31 = %f ", inputVoltage.L3N_L31);
                    if (_threePhaseOvp[2] >= OVP_UVP_CHK_COUNT) {
                        pAlarmCode->AlarmEvents.bits.SystemL3InputOVP = YES;
                    } else {
                        _threePhaseOvp[2] += 1;
                    }
                }
            } else {
                if (inputVoltage.L3N_L31 < VIN_MAX_REV_VOLTAGE_UL) {
                    pAlarmCode->AlarmEvents.bits.SystemL3InputOVP = NO;
                    _threePhaseOvp[2] = 0;
                }
            }
        }
    }
}

// 左右槍的 Relay 前後的輸出電壓
void GetPersentOutputVol(void)
{
    uint8_t index = 0;
    uint8_t targetID = 0;
    struct ChargingInfoData *pDcChargingInfo = NULL;
    PresentOutputVoltage outputVoltage = {0};

    if (Query_Present_OutputVoltage(Uart5Fd, ADDR_RELAY, &outputVoltage) != PASS) {
        return;
    }
    /*
    log_info("Conn1 fuse 1 = %f ", outputVoltage.behindFuse_Voltage_C1);
    log_info("Conn1 relay 1 = %f ", outputVoltage.behindRelay_Voltage_C1);
    log_info("Conn2 fuse 2 = %f ", outputVoltage.behindFuse_Voltage_C2);
    log_info("Conn2 relay 2 = %f ", outputVoltage.behindRelay_Voltage_C2);

    log_info("outputVoltage.behindFuse_Voltage_C1 = %f ", outputVoltage.behindFuse_Voltage_C1);
    log_info("outputVoltage.behindFuse_Voltage_C2 = %f ", outputVoltage.behindFuse_Voltage_C2);
    */
    ShmRelayModuleData->Gun1FuseOutputVolt = outputVoltage.behindFuse_Voltage_C1;
    ShmRelayModuleData->Gun1RelayOutputVolt = outputVoltage.behindRelay_Voltage_C1;
    ShmRelayModuleData->Gun2FuseOutputVolt = outputVoltage.behindFuse_Voltage_C2;
    ShmRelayModuleData->Gun2RelayOutputVolt = outputVoltage.behindRelay_Voltage_C2;

    for (index = 0; index < pSysConfig->TotalConnectorCount; index++) {
        pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index);
        targetID = getCommTargetID(index);

        switch (targetID) {
        case 0x01:
            pDcChargingInfo->FireChargingVoltage = ShmRelayModuleData->Gun1RelayOutputVolt;
            pDcChargingInfo->PresentChargingCurrent = ((float)ShmRelayModuleData->Gun1FuseOutputVolt) / 10;
            pDcChargingInfo->PresentChargingVoltage = ((float)pDcChargingInfo->FireChargingVoltage) / 10;
            pDcChargingInfo->FuseChargingVoltage = pDcChargingInfo->FireChargingVoltage;
            break;

        case 0x02:
            pDcChargingInfo->FireChargingVoltage = ShmRelayModuleData->Gun2RelayOutputVolt;
            pDcChargingInfo->PresentChargingCurrent = ((float)ShmRelayModuleData->Gun2FuseOutputVolt) / 10;
            pDcChargingInfo->PresentChargingVoltage = ((float)pDcChargingInfo->FireChargingVoltage) / 10;
            pDcChargingInfo->FuseChargingVoltage = pDcChargingInfo->FireChargingVoltage;
            break;

        }

        //log_info("%d persent vol = %f, cur = %f",
        //         index,
        //         pDcChargingInfo->PresentChargingVoltage,
        //         pDcChargingInfo->PresentChargingCurrent);

        //unsigned short Ovp = 0;
        //unsigned short Ocp = 0;
        //Ovp = MIN [VOUT_MAX_VOLTAGE, EV_BATTERY_VOLTAGE]  // 最大輸出電壓與電池電壓最大值
        //Ocp = MIN [IOUT_MAX_CURRENT, EV_CURRENT_REQ]      // 最大輸出電流與需求電流最小值
        //if (pDcChargingInfo->Type == _Type_Chademo) {
        //    //Ovp = MaxValue(pDcChargingInfo->MaximumChargingVoltage, pDcChargingInfo->EvBatteryMaxVoltage);
        //    //Ocp = MaxValue(pDcChargingInfo->PresentChargingCurrent, ShmCHAdeMOData->ev[pDcChargingInfo->type_index].ChargingCurrentRequest);
        //} else if (pDcChargingInfo->Type == _Type_CCS_2) {
        //}
    }
}

void SetRtcData_Relay(void)
{
    struct timeb csuTime;
    struct tm *tmCSU;
    Rtc rtc = {0};

    ftime(&csuTime);
    tmCSU = localtime(&csuTime.time);
    //  log_info("Time : %04d-%02d-%02d %02d:%02d:%02d ", tmCSU->tm_year + 1900,
    //          tmCSU->tm_mon + 1, tmCSU->tm_mday, tmCSU->tm_hour, tmCSU->tm_min,
    //          tmCSU->tm_sec);

    rtc.RtcData[0] = '0' + (tmCSU->tm_year + 1900) / 1000 % 10;
    rtc.RtcData[1] = '0' + (tmCSU->tm_year + 1900) / 100 % 10;
    rtc.RtcData[2] = '0' + (tmCSU->tm_year + 1900) / 10 % 10;
    rtc.RtcData[3] = '0' + (tmCSU->tm_year + 1900) / 1 % 10;

    rtc.RtcData[4] = '0' + (tmCSU->tm_mon + 1) / 10 % 10;
    rtc.RtcData[5] = '0' + (tmCSU->tm_mon + 1) / 1 % 10;

    rtc.RtcData[6] = '0' + (tmCSU->tm_mday) / 10 % 10;
    rtc.RtcData[7] = '0' + (tmCSU->tm_mday) / 1 % 10;

    rtc.RtcData[8] = '0' + (tmCSU->tm_hour) / 10 % 10;
    rtc.RtcData[9] = '0' + (tmCSU->tm_hour) / 1 % 10;

    rtc.RtcData[10] = '0' + (tmCSU->tm_min) / 10 % 10;
    rtc.RtcData[11] = '0' + (tmCSU->tm_min) / 1 % 10;

    rtc.RtcData[12] = '0' + (tmCSU->tm_sec) / 10 % 10;
    rtc.RtcData[13] = '0' + (tmCSU->tm_sec) / 1 % 10;

    if (Config_Rtc_Data(Uart5Fd, ADDR_RELAY, &rtc) == PASS) {
        //log_info("SetRtc (RB) sucessfully. ");
    }
}

void SetModelName_Relay(void)
{
    if (Config_Model_Name(Uart5Fd, ADDR_RELAY, pSysConfig->ModelName) == PASS) {
        //log_info("Set Model name (RB) PASS = %s ", pSysConfig->ModelName);
    }
}

void GetFwAndHwVersion_Relay(void)
{
    Ver ver = {0};

    if (Query_FW_Ver(Uart5Fd, ADDR_RELAY, &ver) == PASS) {
        // RelayModuleData
        strcpy((char *)ShmRelayModuleData->version, ver.Version_FW);
        // SystemInfo
        strcpy((char *)pSysInfo->RelayModuleFwRev, ver.Version_FW);
        //log_info("GetFwAndHwVersion_Relay s1 = %s ", ver.Version_FW);

        if ((strlen((char *)pSysInfo->RelayModuleFwRev) != 0 ||
                pSysInfo->RelayModuleFwRev[0] != '\0') &&
                (ShmRelayModuleData->SelfTest_Comp != YES)
            ) {
            //log_info("Relay Board FW Rev = %s", pSysInfo->RelayModuleFwRev);
            ShmRelayModuleData->SelfTest_Comp = YES;
        }
    }

    if (Query_HW_Ver(Uart5Fd, ADDR_RELAY, &ver) == PASS) {
        // SystemInfo
        strcpy((char *)pSysInfo->RelayModuleHwRev, ver.Version_FW);
        //log_info("GetFwAndHwVersion_Relay s2 = %s ", ver.Version_HW);
    }
}

static void outputRelayInit(int fd)
{
    memset((uint8_t *)&outputRelay, 0, sizeof(Relay));

    if (Config_Relay_Output(fd, ADDR_RELAY, &outputRelay) != PASS) {
        log_info("Config_Relay_Output fail ");
    }
}

static bool IsRelayProcessNeedPause(void)
{
    bool _pause = false;
    static bool isPause = false;
    struct ChargingInfoData *pDcChargingInfo = NULL;

    for (uint8_t i = 0; i < pSysConfig->TotalConnectorCount; i++)
    {
        pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(i);
        if(pDcChargingInfo->SystemStatus == S_UPDATE)
        {
            SetLedColor();
            _pause = true;
        }
    }
    if(isPause != _pause)
    {
        log_info("Relay Process Now Is %s ", _pause == true ? "Paused" : "Continued");
    }
    isPause = _pause;

    return _pause;
}

static void SetFanModuleSpeed(void)
{
    {
        FanSpeed _fanSpeed = {0};

        _setFanSpeed += fanSpeedSmoothValue;

        if (_setFanSpeed >= ShmFanModuleData->SetFan1Speed) {
            _setFanSpeed = ShmFanModuleData->SetFan1Speed;
        }

        _fanSpeed.speed[0] = _setFanSpeed;

        _fanSpeed.speed[1] = _setFanSpeed;

        _fanSpeed.speed[2] = _setFanSpeed;

        _fanSpeed.speed[3] = _setFanSpeed;

        if (Config_Fan_Speed(Uart5Fd, ADDR_FAN, &_fanSpeed) == PASS) {
            //log_info("successfully Fan");
        }
    }
}

// 風扇速度
static void GetFanSpeed(void)
{
    FanSpeed fanSpeed = {0};

    //log_info("Get fan board speed ");
    if (Query_Fan_Speed(Uart5Fd, ADDR_FAN, &fanSpeed) == PASS) {
        ShmFanModuleData->PresentFan1Speed = fanSpeed.speed[0];
        ShmFanModuleData->PresentFan2Speed = fanSpeed.speed[1];
        ShmFanModuleData->PresentFan3Speed = fanSpeed.speed[2];
        ShmFanModuleData->PresentFan4Speed = fanSpeed.speed[3];
//      log_info("SystemFanRotaSpeed_1 = %d ", fanSpeed.speed[0]);
//      log_info("SystemFanRotaSpeed_2 = %d ", fanSpeed.speed[1]);
//      log_info("SystemFanRotaSpeed_3 = %d ", fanSpeed.speed[2]);
//      log_info("SystemFanRotaSpeed_4 = %d ", fanSpeed.speed[3]);
        // Config_Fan_Speed(Uart5Fd, ADDR_FAN, &fanSpeed[0]);
        //SysInfoData (SystemFanRotaSpeed)
    }
}

static void GetFanSpeedByFunction(void)
{
    if (ShmDcCommonData->pTest.fanflag== YES) {
        ShmFanModuleData->SetFan1Speed = ShmFanModuleData->TestFanSpeed;
        return;
    }

    int gunIndex;
    struct ChargingInfoData* pDcChargingInfo = NULL;
    for (gunIndex = 0; gunIndex < pSysConfig->TotalConnectorCount; gunIndex++) {
        pDcChargingInfo = (struct ChargingInfoData*)GetDcChargingInfoData(gunIndex);
        if (ShmDcCommonData->pGunInfo[gunIndex].withChiller) {
            if ((pDcChargingInfo->SystemStatus > S_AUTHORIZING && pDcChargingInfo->SystemStatus < S_TERMINATING) ||
                (pDcChargingInfo->SystemStatus >= S_CCS_PRECHARGE_ST0 && pDcChargingInfo->SystemStatus <= S_CCS_PRECHARGE_ST1)) {
                ShmDcCommonData->FanOnTime = time((time_t*)NULL);
                if (ShmFanModuleData->SetFan1Speed == 0) {
                    ShmFanModuleData->SetFan1Speed = 7000;
                    log_info("Set Fan speed 7000");
                }
            }
        }
    }

    if ((time((time_t*)NULL) - ShmDcCommonData->FanOnTime) >= 600 &&
        ShmFanModuleData->SetFan1Speed == 7000) {
        ShmFanModuleData->SetFan1Speed = 0;
        log_info("Close fan");
        ShmDcCommonData->FanOnTime = time((time_t*)NULL);
    }

    /*
    // 風控修改 :
    // ******************************************************* //
    //
    //       當前PSU輸出總 KW       PSU Temp
    // 30 x -------------------- x ---------- + 14 x (PSU Temp - 45)
    //       當前樁最大功率 KW         45
    //
    // ******************************************************* //

    // 當前樁最大功率 KW : ShmPsuData->SystemAvailablePower
    uint32_t _maxPower = ShmPsuData->SystemAvailablePower;
    // 當前PSU輸出總 KW & PSU Temp :
    uint8_t temp = 0;
    uint8_t index = 0;
    uint8_t count = 0;
    uint8_t gunIndex = 0;
    uint8_t _temp_diff = 0;
    float power = 0;
    double _pw_rate = 0;
    double _temp_rate = 0;
    struct ChargingInfoData *pDcChargingInfo = NULL;

    for (index = 0; index < ShmPsuData->GroupCount; index++) {
        for (count = 0; count < ShmPsuData->PsuGroup[index].GroupPresentPsuQuantity; count++) {
            if (temp < ShmPsuData->PsuGroup[index].PsuModule[count].ExletTemp) {
                temp = ShmPsuData->PsuGroup[index].PsuModule[count].ExletTemp;
            }
        }
    }

    for (gunIndex = 0; gunIndex < pSysConfig->TotalConnectorCount; gunIndex++) {
        pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(gunIndex);

        power += (pDcChargingInfo->PresentChargingPower * 10);
    }

    if (_maxPower > 0) {
        _pw_rate = power / (double)_maxPower;
    }

    if (temp > 0) {
        _temp_rate = (double)temp / 50;
    }

    if (temp > 45) {
        _temp_diff = temp - 70;
    }

    ShmFanModuleData->TestFanSpeed = (((50 * _pw_rate * _temp_rate) + (0.5 * _temp_diff)) / 100) * MAX_FAN_SPEED;

    if (ShmFanModuleData->TestFanSpeed > MAX_FAN_SPEED) {
        ShmFanModuleData->TestFanSpeed = MAX_FAN_SPEED;
    }

    if (ShmFanModuleData->TestFanSpeed < 0) {
        ShmFanModuleData->TestFanSpeed = 0;
    }
    */
//
//  printf("power = %f \n", power);
//  printf("_maxPower = %d \n", _maxPower);
//  printf("temp = %d \n", temp);
//
//  printf("_pw_rate = %f \n", _pw_rate);
//  printf("_temp_rate = %f \n", _temp_rate);
//  printf("_temp_diff = %d \n", _temp_diff);
//  printf("fan rate = %f \n", (30 * _pw_rate * _temp_rate + 14 * _temp_diff));
//  printf("ShmFanModuleData->TestFanSpeed = %d \n", ShmFanModuleData->TestFanSpeed);
}

static void SetRtcData_Fan(void)
{
    struct timeb csuTime;
    struct tm *tmCSU;
    Rtc rtc = {0};

    ftime(&csuTime);
    tmCSU = localtime(&csuTime.time);
    //  log_info("Time : %04d-%02d-%02d %02d:%02d:%02d ", tmCSU->tm_year + 1900,
    //          tmCSU->tm_mon + 1, tmCSU->tm_mday, tmCSU->tm_hour, tmCSU->tm_min,
    //          tmCSU->tm_sec);

    rtc.RtcData[0] = '0' + (tmCSU->tm_year + 1900) / 1000 % 10;
    rtc.RtcData[1] = '0' + (tmCSU->tm_year + 1900) / 100 % 10;
    rtc.RtcData[2] = '0' + (tmCSU->tm_year + 1900) / 10 % 10;
    rtc.RtcData[3] = '0' + (tmCSU->tm_year + 1900) / 1 % 10;

    rtc.RtcData[4] = '0' + (tmCSU->tm_mon + 1) / 10 % 10;
    rtc.RtcData[5] = '0' + (tmCSU->tm_mon + 1) / 1 % 10;

    rtc.RtcData[6] = '0' + (tmCSU->tm_mday) / 10 % 10;
    rtc.RtcData[7] = '0' + (tmCSU->tm_mday) / 1 % 10;

    rtc.RtcData[8] = '0' + (tmCSU->tm_hour) / 10 % 10;
    rtc.RtcData[9] = '0' + (tmCSU->tm_hour) / 1 % 10;

    rtc.RtcData[10] = '0' + (tmCSU->tm_min) / 10 % 10;
    rtc.RtcData[11] = '0' + (tmCSU->tm_min) / 1 % 10;

    rtc.RtcData[12] = '0' + (tmCSU->tm_sec) / 10 % 10;
    rtc.RtcData[13] = '0' + (tmCSU->tm_sec) / 1 % 10;

    if (Config_Rtc_Data(Uart5Fd, ADDR_FAN, &rtc) == PASS) {
        //log_info("SetRtc (FB) sucessfully. ");
    }
}

static void SetModelName_Fan(void)
{
    if (Config_Model_Name(Uart5Fd, ADDR_FAN, pSysConfig->ModelName) == PASS) {
        log_info("Set Model name PASS = %s ", pSysConfig->ModelName);
    }
}

static void GetFwAndHwVersion_Fan(void)
{
    Ver ver = {0};

    if (Query_FW_Ver(Uart5Fd, ADDR_FAN, &ver) == PASS) {
        // FanModuleData
        strcpy((char *)ShmFanModuleData->version, ver.Version_FW);
        // SystemInfo
        strcpy((char *)pSysInfo->FanModuleFwRev, ver.Version_FW);
        //log_info("GetFwAndHwVersion_Fan s1 = %s ", ver.Version_FW);
        if ((strlen((char *)pSysInfo->FanModuleFwRev) != 0 ||
                pSysInfo->FanModuleFwRev[0] != '\0') &&
                (ShmFanModuleData->SelfTest_Comp != YES)
            ) {
            //log_info("Fan Board FW Rev = %s", pSysInfo->FanModuleFwRev);
            ShmFanModuleData->SelfTest_Comp = YES;
        }
    }

    if (Query_HW_Ver(Uart5Fd, ADDR_FAN, &ver) == PASS) {
        // SystemInfo
        strcpy((char *)pSysInfo->FanModuleHwRev, ver.Version_FW);
        //log_info("GetFwAndHwVersion_Fan s2 = %s ", ver.Version_HW);
    }
}

static void fanBoardSelfTest(void)
{
    if (ShmFanModuleData->SelfTest_Comp == YES) {
        return;
    }

    GetFwAndHwVersion_Fan();
    SetModelName_Fan();
    SetRtcData_Fan();
    sleep(1);
    GetClockTime(&gFanBoardRunTimer);
}

static void fanBoardPorcess(void)
{
    if (ShmFanModuleData->SelfTest_Comp == NO) {
        return;
    }

    if (ShmFanModuleData->SelfTest_Comp == YES ||
            strlen((char *)pSysInfo->FanModuleFwRev) != 0 ||
            pSysInfo->FanModuleFwRev[0] != '\0') {
        ShmFanModuleData->SelfTest_Comp = YES;

        if (GetClockTimeoutValue(gFanBoardRunTimer) / 1000 >= 1000) {
            //GetPsuTempForFanSpeed();
            GetFanSpeedByFunction();
            GetFanSpeed();
            pSysInfo->SystemFanRotaSpeed = _setFanSpeed;
            GetClockTime(&gFanBoardRunTimer);
            /*
            ShmFanModuleData->SetFan1Speed = ShmFanModuleData->TestFanSpeed;
            ShmFanModuleData->SetFan2Speed = ShmFanModuleData->TestFanSpeed;
            ShmFanModuleData->SetFan3Speed = ShmFanModuleData->TestFanSpeed;
            ShmFanModuleData->SetFan4Speed = ShmFanModuleData->TestFanSpeed;
            */
            //log_info("set fan = %d ", ShmFanModuleData->SetFan1Speed);
            SetFanModuleSpeed();
        }
    }
}

static void GetFwAndHwVersion_Led(void)
{
    Ver ver = {0};

    if (Query_FW_Ver(Uart5Fd, ADDR_LED, &ver) == PASS) {
        // LedModuleData
        strcpy((char *) ShmLedModuleData->version, ver.Version_FW);
        // SystemInfo
        strcpy((char *) pSysInfo->LedModuleFwRev, ver.Version_FW);
        log_info("GetFwAndHwVersion_Led s1 = %s ", ver.Version_FW);
        ShmLedModuleData->SelfTest_Comp = YES;
    } else {
        //log_info("GetFwAndHwVersion_Led fail ");
    }

//  if (Query_HW_Ver(Uart5Fd, ADDR_LED, &ver) == PASS)
//  {
//      // SystemInfo
//      strcpy((char *) pSysInfo->RelayModuleHwRev, ver.Version_FW);
//      //log_info("GetFwAndHwVersion_Relay s2 = %s ", ver.Version_HW);
//  }
}

static bool IsNoneMatchLedColor(void)
{
    bool result = false;

    if (cur_led_color.Connect_1_Red != led_color.Connect_1_Red ||
            cur_led_color.Connect_1_Green != led_color.Connect_1_Green ||
            cur_led_color.Connect_1_Blue != led_color.Connect_1_Blue ||
            cur_led_color.Connect_2_Red != led_color.Connect_2_Red ||
            cur_led_color.Connect_2_Green != led_color.Connect_2_Green ||
            cur_led_color.Connect_2_Blue != led_color.Connect_2_Blue) {
        result = true;
    }

    return result;
}

//static void SetLedColor(struct ChargingInfoData *chargingData_1, struct ChargingInfoData *chargingData_2)
static void SetLedColor(void)
{
    static uint8_t _checkLedChanged = 3;
    struct ChargingInfoData *chargingData_1 = NULL;
    struct ChargingInfoData *chargingData_2 = NULL;
    uint8_t _colorBuf = COLOR_MAX_LV * LED_INTENSITY_BRIGHTEST;
    if (CheckDispenserGeneration() == _DISPENSER_GENERATION_3_5) {
        _colorBuf = COLOR_MAX_LV_G3_5 * LED_INTENSITY_BRIGHTEST;
    }
    
    if (pSysConfig->TotalConnectorCount == 1) {
        chargingData_1 = (struct ChargingInfoData *)GetDcChargingInfoData(0);
        chargingData_2 = (struct ChargingInfoData *)GetDcChargingInfoData(0);
    } else if (pSysConfig->TotalConnectorCount == 2) {
        chargingData_1 = (struct ChargingInfoData *)GetDcChargingInfoData(0);
        chargingData_2 = (struct ChargingInfoData *)GetDcChargingInfoData(1);
    }

    if (pSysConfig->LedInfo.Intensity == _LED_INTENSITY_DARKEST) {
        _colorBuf = COLOR_MAX_LV * LED_INTENSITY_DARKEST;
    } else if (pSysConfig->LedInfo.Intensity == _LED_INTENSITY_MEDIUM) {
        _colorBuf = COLOR_MAX_LV * LED_INTENSITY_MEDIUM;
    }
    if (CheckDispenserGeneration() == _DISPENSER_GENERATION_3_5) {
        if (CheckCustomer() == _CUSTOM_AUDI) {
            led_color.Connect_3_Green = 100;
            led_color.Connect_3_Blue = 100;
            led_color.Connect_3_Red = 100;
            led_color.Connect_4_Green = 100;
            led_color.Connect_4_Blue = 100;
            led_color.Connect_4_Red = 100;
        } else {
            led_color.Connect_3_Green = 100;
            led_color.Connect_3_Blue = 0;
            led_color.Connect_3_Red = 0;
            led_color.Connect_4_Green = 100;
            led_color.Connect_4_Blue = 0;
            led_color.Connect_4_Red = 0;
        }
    }
    //printf("chargingData_1->SystemStatus=%d\n",chargingData_1->SystemStatus);
    //printf("chargingData_2->SystemStatus=%d\n",chargingData_2->SystemStatus);
    //printf("pSysWarning->Level=%d\n",pSysWarning->Level);
    if (pSysWarning->Level == 2 || pSysInfo->SelfTestSeq != _STEST_COMPLETE) {
        led_color.Connect_1_Green = COLOR_MIN_LV;
        led_color.Connect_1_Blue = COLOR_MIN_LV;
        led_color.Connect_1_Red = _colorBuf;
        led_color.Connect_2_Green = COLOR_MIN_LV;
        led_color.Connect_2_Blue = COLOR_MIN_LV;
        led_color.Connect_2_Red = _colorBuf;
    } else {
        //實際操作
        if (chargingData_1->SystemStatus == S_BOOTING ||
                chargingData_1->SystemStatus == S_IDLE) {

            if (chargingData_1->IsAvailable == NO) { //For Audi
                led_color.Connect_1_Green = COLOR_MIN_LV;
                led_color.Connect_1_Blue = COLOR_MIN_LV;
                led_color.Connect_1_Red = _colorBuf;
            } else {
                led_color.Connect_1_Green = _colorBuf;
                led_color.Connect_1_Blue = COLOR_MIN_LV;
                led_color.Connect_1_Red = COLOR_MIN_LV;
                if (CheckCustomer() == _CUSTOM_AUDI) {
                    led_color.Connect_1_Green = _colorBuf;
                    led_color.Connect_1_Blue = _colorBuf;
                    led_color.Connect_1_Red = _colorBuf;
                }
            }
        } else if ((chargingData_1->SystemStatus >= S_AUTHORIZING &&
                    chargingData_1->SystemStatus <= S_COMPLETE) ||
                (chargingData_1->SystemStatus >= S_CCS_PRECHARGE_ST0 &&
                    chargingData_1->SystemStatus <= S_CCS_PRECHARGE_ST1)) {
            led_color.Connect_1_Green = COLOR_MIN_LV;
            led_color.Connect_1_Blue = _colorBuf;
            led_color.Connect_1_Red = COLOR_MIN_LV;
        }else if ( chargingData_1->SystemStatus == S_UPDATE ||
            chargingData_1->SystemStatus == S_FAULT ||
                chargingData_1->SystemStatus == S_MAINTAIN) {
            led_color.Connect_1_Green = COLOR_MIN_LV;
            led_color.Connect_1_Blue = COLOR_MIN_LV;
            led_color.Connect_1_Red = _colorBuf;
        } else if (chargingData_1->SystemStatus == S_RESERVATION) {
            if (ReservationLed) {
                led_color.Connect_1_Green = COLOR_MIN_LV;
            } else {
                led_color.Connect_1_Green = _colorBuf;
            }
            led_color.Connect_1_Blue = COLOR_MIN_LV;
            led_color.Connect_1_Red = COLOR_MIN_LV;
        }

        // --------------------------------------------------------------------------
        if (chargingData_2->SystemStatus == S_BOOTING ||
                chargingData_2->SystemStatus == S_IDLE) {
            if (chargingData_2->IsAvailable == NO) {
                led_color.Connect_2_Green = COLOR_MIN_LV;
                led_color.Connect_2_Blue = COLOR_MIN_LV;
                led_color.Connect_2_Red = _colorBuf;
            } else {

                led_color.Connect_2_Green = _colorBuf;
                led_color.Connect_2_Blue = COLOR_MIN_LV;
                led_color.Connect_2_Red = COLOR_MIN_LV;
                if (CheckCustomer() == _CUSTOM_AUDI) {
                    led_color.Connect_2_Green = _colorBuf;
                    led_color.Connect_2_Blue = _colorBuf;
                    led_color.Connect_2_Red = _colorBuf;
                }
            }
        } else if ((chargingData_2->SystemStatus >= S_AUTHORIZING &&
                    chargingData_2->SystemStatus <= S_COMPLETE) ||
                (chargingData_2->SystemStatus >= S_CCS_PRECHARGE_ST0 &&
                    chargingData_2->SystemStatus <= S_CCS_PRECHARGE_ST1)) {
            led_color.Connect_2_Green = COLOR_MIN_LV;
            led_color.Connect_2_Blue = _colorBuf;
            led_color.Connect_2_Red = COLOR_MIN_LV;
        }else if ( chargingData_2->SystemStatus == S_UPDATE ||
                chargingData_2->SystemStatus == S_FAULT ||
                chargingData_2->SystemStatus == S_MAINTAIN) {
            led_color.Connect_2_Green = COLOR_MIN_LV;
            led_color.Connect_2_Blue = COLOR_MIN_LV;
            led_color.Connect_2_Red = _colorBuf;
        } else if (chargingData_2->SystemStatus == S_RESERVATION) {
            if (ReservationLed) {
                led_color.Connect_2_Green = COLOR_MIN_LV;
            } else {
                led_color.Connect_2_Green = _colorBuf;
            }
            led_color.Connect_2_Blue = COLOR_MIN_LV;
            led_color.Connect_2_Red = COLOR_MIN_LV;
        }

    }

    
    if (pAlarmCode->AlarmEvents.bits.LcmModuleCommFail && CheckDispenserGeneration() == _DISPENSER_GENERATION_3_5) {
        if (LcmLoseFlash) {
            led_color.Connect_3_Red = COLOR_MIN_LV;
            led_color.Connect_3_Green = COLOR_MIN_LV;
            led_color.Connect_3_Blue = 100;
            led_color.Connect_4_Red = COLOR_MIN_LV;
            led_color.Connect_4_Green = COLOR_MIN_LV;
            led_color.Connect_4_Blue = COLOR_MIN_LV;
        } else {
            led_color.Connect_3_Red = COLOR_MIN_LV;
            led_color.Connect_3_Green = COLOR_MIN_LV;
            led_color.Connect_3_Blue = COLOR_MIN_LV;
            led_color.Connect_4_Red = COLOR_MIN_LV;
            led_color.Connect_4_Green = COLOR_MIN_LV;
            led_color.Connect_4_Blue = 100;
        }
        _checkLedChanged = 3;
    }
    
    if (ShmDcCommonData->pTest.ledflag) {
        led_color.Connect_1_Red = pSysConfig->LedInfo.Red[0];
        led_color.Connect_1_Green = pSysConfig->LedInfo.Green[0];
        led_color.Connect_1_Blue = pSysConfig->LedInfo.Blue[0];
        led_color.Connect_2_Red = pSysConfig->LedInfo.Red[0];
        led_color.Connect_2_Green = pSysConfig->LedInfo.Green[0];
        led_color.Connect_2_Blue = pSysConfig->LedInfo.Blue[0];
        if (strcmp((char*)pSysInfo->LedModuleFwRev,"D0.03.L0") != EQUAL) {
            led_color.Connect_3_Red = pSysConfig->LedInfo.Red[0];
            led_color.Connect_3_Green = pSysConfig->LedInfo.Green[0];
            led_color.Connect_3_Blue = pSysConfig->LedInfo.Blue[0];
            led_color.Connect_4_Red = pSysConfig->LedInfo.Red[0];
            led_color.Connect_4_Green = pSysConfig->LedInfo.Green[0];
            led_color.Connect_4_Blue = pSysConfig->LedInfo.Blue[0];
        }
    }

    if (_checkLedChanged > 0) {
        int ledNum = 2;
        if (strcmp((char*)pSysInfo->LedModuleFwRev,"D0.03.L0") == EQUAL) {
            ledNum = 2;
        } else {
            ledNum = 4;
        }
        if (Config_Led_Color(Uart5Fd, ADDR_LED, &led_color,ledNum) == PASS) {
            _checkLedChanged--;
            if (ledNum == 2) {
                cur_led_color.Connect_1_Red     = led_color.Connect_1_Red;
                cur_led_color.Connect_1_Green   = led_color.Connect_1_Green;
                cur_led_color.Connect_1_Blue    = led_color.Connect_1_Blue;
                cur_led_color.Connect_2_Red     = led_color.Connect_2_Red;
                cur_led_color.Connect_2_Green   = led_color.Connect_2_Green;
                cur_led_color.Connect_2_Blue    = led_color.Connect_2_Blue;
            } else {
                cur_led_color.Connect_1_Red     = led_color.Connect_1_Red;
                cur_led_color.Connect_1_Green   = led_color.Connect_1_Green;
                cur_led_color.Connect_1_Blue    = led_color.Connect_1_Blue;
                cur_led_color.Connect_2_Red     = led_color.Connect_2_Red;
                cur_led_color.Connect_2_Green   = led_color.Connect_2_Green;
                cur_led_color.Connect_2_Blue    = led_color.Connect_2_Blue;
                cur_led_color.Connect_3_Red     = led_color.Connect_3_Red;
                cur_led_color.Connect_3_Green   = led_color.Connect_3_Green;
                cur_led_color.Connect_3_Blue    = led_color.Connect_3_Blue;
                cur_led_color.Connect_4_Red     = led_color.Connect_4_Red;
                cur_led_color.Connect_4_Green   = led_color.Connect_4_Green;
                cur_led_color.Connect_4_Blue    = led_color.Connect_4_Blue;
                }
        }
    } else if (IsNoneMatchLedColor()) {
        _checkLedChanged = 3;
    }
}

static void LEDBoardSelfTest(void)
{
    // 自檢階段處理，自檢階段如果讀不到版號則代表該系統沒有掛燈板
    if (ShmLedModuleData->SelfTest_Comp == YES) {
        return;
    }

#if defined DD360 ||defined DD360Audi
    GetFwAndHwVersion_Led();
    sleep(1);
    GetClockTime(&_led_priority_time);

    return;
#endif //defined DD360 || defined DD360Audi

    // 自檢階段
    if (pSysInfo->SelfTestSeq <= _STEST_PSU_CAP) {
        GetFwAndHwVersion_Led();
        sleep(1);
        GetClockTime(&_led_priority_time);
    } else {
        // 自檢階段沒有問到版號
        if (pAlarmCode->AlarmEvents.bits.LedboardStestFail == NO) {
            pAlarmCode->AlarmEvents.bits.LedboardStestFail = YES;
        }
    }
}

static void LEDBoardProcess(void)
{
    //struct ChargingInfoData *pDcChargingInfo0 = NULL;
    //struct ChargingInfoData *pDcChargingInfo1 = NULL;

    if (ShmLedModuleData->SelfTest_Comp == NO) {
        return;
    }

    if (GetClockTimeoutValue(_led_priority_time) / 1000 >= 1000) {
        if (time((time_t*)NULL) - ReservationFlashTimer >= 3) {
            ReservationFlashTimer = time((time_t*)NULL);
            if (ReservationLed)
                ReservationLed = 0;
            else
                ReservationLed = 1;
        }
        LcmLoseFlash ? (LcmLoseFlash = 0) : (LcmLoseFlash = 1);

        SetLedColor();
        GetClockTime(&_led_priority_time);
    }
}

void RelayBoardTask(int uartFD)
{
    bool isRelayBypass = false;
    pid_t pid = fork();

    if (pid == 0) {
        bool isCharging = false;
        bool isStopChargingCount = false;
        uint8_t i = 0;
        int isContinue = 1;
        struct ChargingInfoData *pDcChargingInfo = NULL;

        //share memory mapping
        pSysConfig = (struct SysConfigData *)GetShmSysConfigData();
        pSysInfo = (struct SysInfoData *)GetShmSysInfoData();
        pAlarmCode = (struct AlarmCodeData *)GetShmAlarmCodeData();
        ShmRelayModuleData = (struct RelayModuleData *)GetShmRelayModuleData();
        ShmPsuData = (struct PsuData *)GetShmPsuData();
        ShmDcCommonData = (DcCommonInfo *)GetShmDcCommonData();
        ShmPrimaryMcuData = (struct PrimaryMcuData *)GetShmPrimaryMcuData();
        pSysWarning = (struct WARNING_CODE_INFO *)GetShmSysWarningInfo();
        ShmFanModuleData = (struct FanModuleData *)GetShmFanModuleData();
        ShmLedModuleData = (struct LedModuleData *)GetShmLedModuleData();

        Uart5Fd = uartFD;

        for(int i = 0; i < pSysConfig->TotalConnectorCount; i++)
        {
            pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(i);
            if(pDcChargingInfo->PantographFlag == YES)
            {
                isRelayBypass = true;
            }
        }

        //relay init
        if(isRelayBypass == false)
        {
            outputRelayInit(uartFD);
        }

        while (isContinue) {

            if(IsRelayProcessNeedPause() == true)
            {
                sleep(1);
                continue;
            }

            // 程序開始之前~ 必須先確定 FW 版本與硬體版本，確認後!!~ 該模組才算是真正的 Initial Comp.
            if (ShmRelayModuleData->SelfTest_Comp == NO && isRelayBypass == false) {
                GetFwAndHwVersion_Relay();
                SetModelName_Relay(); //DS60-120 add
                SetRtcData_Relay();
                sleep(1);
            }

#if !defined NO_FAN_BOARD && !defined DD360ComBox
            fanBoardSelfTest();
#endif //NO_FAN_BOARD

#if !defined DD360ComBox
            LEDBoardSelfTest();
#endif //defined DD360ComBox

            if (ShmRelayModuleData->SelfTest_Comp == YES && isRelayBypass == false)
            {
                // ==============優先權最高 10 ms ==============
                // 輸出電壓
                GetPersentOutputVol();

    #if !defined DD360 && !defined DD360Audi && !defined DD360ComBox
                // 三相輸入電壓
                GetPresentInputVol();
    #endif //!defined DD360 && !defined DD360Audi

                // 讀取當前 AC relay 狀態
                regRelay.relay_event.bits.AC_Contactor = pSysInfo->AcContactorStatus;
                GetRelayOutputStatus();

                // Cable check (Get)
                GetGfdAdc();

                for (i = 0; i < pSysConfig->TotalConnectorCount; i++) {
                    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(i);

                    // Cable check (Set)
                    CableCheckDetected(i);

                    // check k1 k2 relay 狀態
                    CheckK1K2RelayOutput(i);

                    // 依據當前各槍的狀態選擇 搭上/放開 Relay
                    SetK1K2RelayStatus(i);

#if !defined DD360 && !defined DD360Audi && !defined DD360ComBox
                    if (pSysConfig->PhaseLossPolicy == YES) {
                        CheckPhaseLossStatus(i);
                    }

                    CheckAcInputOvpStatus(i);
#endif //!defined DD360 && !defined DD360Audi

                    if (pDcChargingInfo->SystemStatus == S_IDLE ||
                            pDcChargingInfo->SystemStatus == S_RESERVATION ||
                            pDcChargingInfo->SystemStatus == S_MAINTAIN) {
                        //pDcChargingInfo->RelayWeldingCheck = NO;
                        //_isRelayWelding[i] = NO;
                        _isOvpChkTimeFlag[i] = NO;
                        //ResetDetAlarmStatus(i); //DS60-120 add
                    }

                    if (pDcChargingInfo->SystemStatus == S_BOOTING ||
                            (pDcChargingInfo->SystemStatus >= S_REASSIGN_CHECK &&
                             pDcChargingInfo->SystemStatus <= S_COMPLETE) ||
                            (pDcChargingInfo->SystemStatus >= S_CCS_PRECHARGE_ST0 &&
                             pDcChargingInfo->SystemStatus <= S_CCS_PRECHARGE_ST1) ||
                            pSysInfo->WaitForPlugit == YES ||
                            (pSysInfo->PageIndex >= _LCM_AUTHORIZING &&
                             pSysInfo->PageIndex <= _LCM_WAIT_FOR_PLUG)
                       ) {
                        pDcChargingInfo->IsReadyToCharging = YES;
                        isCharging = true;

                        // 限定只有在槍類別為 GBT 的時候才做 relay welding 的判斷
                        //if (pDcChargingInfo->Type == _Type_GB) {
                        //    if (pDcChargingInfo->SystemStatus >= S_PREPARING_FOR_EVSE &&
                        //            pDcChargingInfo->RelayWeldingCheck == NO) {
                        //        CheckRelayWeldingStatus(i);
                        //    }
                        //} else {
                        //pDcChargingInfo->RelayWeldingCheck = YES;
                        //}

                        if (pDcChargingInfo->SystemStatus == S_CHARGING) {
                            CheckOutputPowerOverCarReq(i);
                            //CheckOutputVolNoneMatchFire(i);
                        }
                        /*else {
                            _isOutputNoneMatch[i] = NO;
                        }*/
                    } else {
                        pDcChargingInfo->IsReadyToCharging = NO;
                    }
                }

                    // 搭上 AC Contactor
                    //if (isCharging) {
                    //    outputRelay.relay_event.bits.AC_Contactor = YES;
                    //} else {
                    //    outputRelay.relay_event.bits.AC_Contactor = NO;
                    //}

                    if (isCharging ||
                            (ShmPsuData->Work_Step >= _TEST_MODE &&
                             ShmPsuData->Work_Step <= _TEST_MODE)) {
                        isStopChargingCount = false;
                        outputRelay.relay_event.bits.AC_Contactor = YES;
                    } else {
                        if (!isStopChargingCount) {
                            GetClockTime(&_close_ac_contactor);
                            isStopChargingCount = true;
                        } else {
                            if ((outputRelay.relay_event.bits.AC_Contactor == YES &&
                                    GetClockTimeoutValue(_close_ac_contactor) / 1000 >= (TEN_MINUTES * 1000))) {
                                outputRelay.relay_event.bits.AC_Contactor = NO;
                            }
                        }
                    }

                    if (ShmPrimaryMcuData->InputDet.bits.EmergencyButton == ABNORMAL) {
                        outputRelay.relay_event.bits.AC_Contactor = NO;
                    }

                    if (pAlarmCode->AlarmEvents.bits.PsuFailureAlarm == ABNORMAL) {
                        RunForceStopProcess();
                        outputRelay.relay_event.bits.AC_Contactor = NO;
                    }

                    if (ShmPsuData->Work_Step >= _TEST_MODE && ShmPsuData->Work_Step <= _TEST_MODE) {
                        outputRelay.relay_event.bits.Gun1_N = outputRelay.relay_event.bits.Gun1_P = YES;
                    }
                    if (ShmDcCommonData->pTest.relayflag) {
                        outputRelay.relay_event.bits.Gun1_N = outputRelay.relay_event.bits.Gun1_P = ShmDcCommonData->pGunInfo[0].RelayTest;
                        if (pSysConfig->TotalConnectorCount > 1)
                            outputRelay.relay_event.bits.Gun2_N = outputRelay.relay_event.bits.Gun2_P = ShmDcCommonData->pGunInfo[1].RelayTest;
                    }
                    // 搭上/鬆開 Relay
                    if (IsNoneMatchRelayStatus()) {
                        if (Config_Relay_Output(Uart5Fd, ADDR_RELAY, &outputRelay)) {
                            //regRelay.relay_event.bits.AC_Contactor = pSysInfo->AcContactorStatus;

                            //regRelay.relay_event.bits.CCS_Precharge = outputRelay.relay_event.bits.CCS_Precharge;
                            //regRelay.relay_event.bits.Gun1_P = outputRelay.relay_event.bits.Gun1_P;
                            //regRelay.relay_event.bits.Gun1_N = outputRelay.relay_event.bits.Gun1_N;
                            //regRelay.relay_event.bits.Gun2_P = outputRelay.relay_event.bits.Gun2_P;
                            //regRelay.relay_event.bits.Gun2_N = outputRelay.relay_event.bits.Gun2_N;
                            //regRelay.relay_event.bits.Gun1_Parallel_P = outputRelay.relay_event.bits.Gun1_Parallel_P;
                            //regRelay.relay_event.bits.Gun1_Parallel_N = outputRelay.relay_event.bits.Gun1_Parallel_N;

                            //MatchRelayStatus();

                            //log_info("Match Relay, AC = %x, g1_p = %x, g1_n = %x, g2_p = %x, g2_n = %x, pre = %x, bri_p = %x, bri_n = %x ",
                            //         regRelay.relay_event.bits.AC_Contactor,
                            //         regRelay.relay_event.bits.Gun1_P,
                        //         regRelay.relay_event.bits.Gun1_N,
                        //         regRelay.relay_event.bits.Gun2_P,
                        //         regRelay.relay_event.bits.Gun2_N,
                        //         regRelay.relay_event.bits.CCS_Precharge,
                        //         regRelay.relay_event.bits.Gun1_Parallel_P,
                        //         regRelay.relay_event.bits.Gun1_Parallel_N);

                    }
                }
            }
            else if(isRelayBypass == true)
            {
                for(i = 0; i < pSysConfig->TotalConnectorCount; i++)
                {
                    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(i);

                    if (pDcChargingInfo->SystemStatus == S_IDLE ||
                            pDcChargingInfo->SystemStatus == S_RESERVATION ||
                            pDcChargingInfo->SystemStatus == S_MAINTAIN)
                    {
                        _isOvpChkTimeFlag[i] = NO;
                    }
                    if (pDcChargingInfo->SystemStatus == S_CHARGING)
                    {
                        CheckOutputPowerOverCarReq(i);
                    }
                }
            }

#if !defined NO_FAN_BOARD && !defined DD360ComBox
            fanBoardPorcess();
#endif //NO_FAN_BOARD

#if !defined DD360ComBox
            LEDBoardProcess();
#endif //defined DD360ComBox

            usleep(10000);
        }
    }
}