/*
 * Infypwr_PsuCommObj.c
 *
 *  Created on: 2019年11月26日
 *      Author: 7564
 */

#include "InfyGroup_PsuCommObj.h"

#define ARRAY_SIZE(A)                   (sizeof(A) / sizeof(A[0]))
#define NO                              0
#define YES                             1

#define DEBUG_LIB                       1

void PRINTF_LIB_FUNC(char *string, ...);
float IEEE_754_to_float(const byte raw[4]);

//================================================
// Private function
//================================================
void PRINTF_LIB_FUNC(char *string, ...)
{
    if (DEBUG_LIB)
    {
        va_list args;
        char buffer[4096];

        va_start(args, string);
        vsnprintf(buffer, sizeof(buffer), string, args);
        va_end(args);
        printf("%s \n", buffer);
    }
}

float IEEE_754_to_float(const byte raw[4])
{
    float fValue = 0;
    byte *pbyte = (byte *)&fValue;

    *(pbyte + 0) = raw[3];
    *(pbyte + 1) = raw[2];
    *(pbyte + 2) = raw[1];
    *(pbyte + 3) = raw[0];

    return fValue;
}

//================================================
// Callback function
//================================================
void RefreshPsuIndex(int (*func)(byte group, byte address))
{
    return_psuIndex = func;
}

void RefreshGroup(void *func)
{
    return_group = func;
}

void RefreshInfyPwrAlarmFlag(void *func)
{
    return_infy_pwr_alarm_flag = func;
}

void RefreshPhPwrAlarmFlag(void *func)
{
    return_ph_pwr_alarm_flag = func;
}

void RefreshAlarmStatus(void *func)
{
    return_alarm_status = func;
}

void RefreshAmbient(void *func)
{
    return_ambient = func;
}

void RefreshModuleCount(void *func)
{
    return_module_count = func;
}

void RefreshSysModuleCount(void *func)
{
    return_sys_module_count = func;
}

void RefreshAvailableCap(void *func)
{
    return_available_cap = func;
}

void RefreshFwDcVersion(void *func)
{
    return_fw_dc_version = func;
}

void RefreshFwPfcVersion(void *func)
{
    return_fw_pfc_version = func;
}

void RefreshInputVol(void *func)
{
    return_input_vol = func;
}

void RefreshInputCur(void *func)
{
    return_input_cur = func;
}

void RefreshGetOutput(void *func)
{
    return_get_output = func;
}

void RefreshGetOutputF(void *func)
{
    return_get_output_float = func;
}

void RefreshGetModuleOutput(void *func)
{
    return_module_output = func;
}

void RefreshGetErrorRecord(void *func)
{
    return_error_record = func;
}

void RefreshFanSpeedInfo(void *func)
{
    return_fan_speed = func;
}

void RefreshInletTemp(void *func)
{
    return_inlet_temp = func;
}

void RefreshExletTemp(void *func)
{
    return_exlet_temp = func;
}

void RefreshOutletTemp(void *func)
{
    return_outlet_temp = func;
}

void RefreshOtherTemp(void *func)
{
    return_other_temp = func;
}

void RefreshIavailable(void *func)
{
    return_iavail_info = func;
}

void AutoMode_RefreshOutputAndTemp(void *func)
{
    return_output_temp = func;
}

void AutoMode_RefreshModuleStatus(void *func)
{
    return_module_status = func;
}

void AutoMode_RefreshModuleInput(void *func)
{
    return_module_input = func;
}

//================================================
// CANBUS initialization
//================================================
int InitCanBus()
{
	int 					s0,nbytes;
	struct timeval			tv;
	struct ifreq 			ifr0;
	struct sockaddr_can		addr0;

	system("/sbin/ip link set can1 down");
	system("/sbin/ip link set can1 type can bitrate 500000 restart-ms 100");
	system("/sbin/ip link set can1 up");

	s0 = socket(PF_CAN, SOCK_RAW, CAN_RAW);

	tv.tv_sec = 0;
	tv.tv_usec = 10000;
   	if (setsockopt(s0, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
	{
		#ifdef SystemLogMessage
   		PRINTF_LIB_FUNC("Set SO_RCVTIMEO NG");
		#endif
	}
	nbytes=40960;
	if (setsockopt(s0, SOL_SOCKET,  SO_RCVBUF, &nbytes, sizeof(int)) < 0)
	{
		#ifdef SystemLogMessage
		PRINTF_LIB_FUNC("Set SO_RCVBUF NG");
		#endif
	}
	nbytes=40960;
	if (setsockopt(s0, SOL_SOCKET, SO_SNDBUF, &nbytes, sizeof(int)) < 0)
	{
		#ifdef SystemLogMessage
		PRINTF_LIB_FUNC("Set SO_SNDBUF NG");
		#endif
	}
	nbytes=40960;

   	strcpy(ifr0.ifr_name, "can1" );
	ioctl(s0, SIOCGIFINDEX, &ifr0); /* ifr.ifr_ifindex gets filled with that device's index */
	addr0.can_family = AF_CAN;
	addr0.can_ifindex = ifr0.ifr_ifindex;
	bind(s0, (struct sockaddr *)&addr0, sizeof(addr0));
	return s0;
}

//================================================
// Receive Cmd from canbus
//================================================
void ReceiveDataFromCanBus()
{
    int nbytes;
    struct can_frame frame;
    PwrFrame *PwrFrameMsg;
    byte group, address;

    while(1)
	{
        memset(&frame, 0, sizeof(struct can_frame));
        nbytes = read(CanFd, &frame, sizeof(struct can_frame));

        if (nbytes > 0)
        {
            PwrFrameMsg = (PwrFrame *)&frame.can_id;
            address = PwrFrameMsg->InfyBits.SourceAddress;

            if(PwrFrameMsg->InfyBits.DestinationAddress == INFY_ADD_CSU)
            {
                switch (PwrFrameMsg->InfyBits.CmdValue)
                {
                    // 0x01
                    case PSU_RCmd_SysOutputVolCur_F:
                    {
                        group = address;
                        byte vol[4], cur[4];
                        memcpy(vol, frame.data, 4);
                        memcpy(cur, frame.data + 4, 4);

                        float _Vol = IEEE_754_to_float(vol);
                        float _Cur = IEEE_754_to_float(cur);

                        return_get_output_float(group, _Vol, _Cur);
                    }
                        break;

                    // 0x02
                    case PSU_RCmd_SysModuleCount:
                    {
                        // 回傳模組數量
                        byte count = 0;
                        count = frame.data[2];

                        if(address != SYSTEM_CMD)
                        {
                            return_module_count(address, count, false);
                        }
                        else
                        {
                            return_sys_module_count(address, count);
                        }
                    }
                        break;

                    // 0x04
                    case PSU_RCmd_ModuleStatus:
                    {
                        // 回傳模組組號及狀態
                        byte SN = address;
                        group = frame.data[2];
                        int temp = (signed char)frame.data[4] + 60;
                        byte state_2 = frame.data[5];
                        byte state_1 = frame.data[6];
                        byte state_0 = frame.data[7];

                        return_group(group, SN, SN);
                        return_infy_pwr_alarm_flag(SN, state_2, state_1, state_0);
                        return_ambient(SN, temp);
                    }
                        break;

                    // 0x06
                    case PSU_RCmd_ModuleInputVoltage:
                    {
                        // 回傳三向輸入電壓
                        short abVol = ((frame.data[0] << 8) + frame.data[1]);
                        short bcVol = ((frame.data[2] << 8) + frame.data[3]);
                        short caVol = ((frame.data[4] << 8) + frame.data[5]);

                        return_input_vol(address, abVol, bcVol, caVol);
                    }
                        break;

                    // 0x07
                    case PSU_RCmd_ModuleVersion:
                    {
                        short dcSwVer = ((frame.data[0] << 8) + frame.data[1]);
                        short pfcSwVer = ((frame.data[2] << 8) + frame.data[3]);
                        //short hwVer = ((frame.data[4] << 8) + frame.data[5]);

                        char dcVersion[32];
                        char pfcVersion[32];

                        memset(dcVersion, 0x00, sizeof(dcVersion));
                        memset(pfcVersion, 0x00, sizeof(pfcVersion));

                        sprintf(dcVersion, "DC %d.%02d", (dcSwVer & 0xFF00) >> 8, dcSwVer & 0xFF);
                        sprintf(pfcVersion, "PFC %d.%02d", (pfcSwVer & 0xFF00) >> 8, pfcSwVer & 0xFF);

                        return_fw_dc_version(address, dcVersion);
                        return_fw_pfc_version(address, pfcVersion);
                    }
                        break;

                    // 0x08
                    case PSU_RCmd_SysOutputVolCur:
                    {
                        // 回傳當前輸出電壓電流
                        int outputVol = ((frame.data[0] << 24) + (frame.data[1] << 16) + (frame.data[2] << 8) + frame.data[3]) / 100;
                        int outputCur = ((frame.data[4] << 24) + (frame.data[5] << 16) + (frame.data[6] << 8) + frame.data[7]) / 100;

                        // outputVol unit: 1mV > 0.1V
                        // outputCur unit: 1mA > 0.1A
                        return_get_output(address, outputVol, outputCur);
                    }
                        break;

                    // 0x0A
                    case PSU_RCmd_ModuleCapability:
                    {
                        // 回傳輸出能力 : 最大電壓、最小電壓、最大電流、額定功率
                        short maxVol = ((frame.data[0] << 8) + frame.data[1]) * 10;
                        short minVol = ((frame.data[2] << 8) + frame.data[3]) * 10;
                        short maxCur = (frame.data[4] << 8) + frame.data[5];
                        short totalPow = ((frame.data[6] << 8) + frame.data[7]) / 10;

                        // maxVol unit: 1V > 0.1V
                        // minVol unit: 1V > 0.1V
                        // maxCur unit: 0.1A
                        // totalPow unit: 0.01kW > 0.1kW
                        return_available_cap(address, maxVol, minVol, maxCur, totalPow);
                    }
                        break;

                    // 0x0B
                    case PSU_RCmd_ModuleBarcode:
                    {
                        // 回傳BarCode
                    }
                        break;

                    // 0x0C
                    case PSU_RCmd_ModuleIAvailable:
                    {
                        // 回傳降載後的電流
                        unsigned short vextVol = ((frame.data[0] << 8) + frame.data[1]);
                        unsigned short iAvailCur = ((frame.data[2] << 8) + frame.data[3]);

                        return_iavail_info(address, iAvailCur, vextVol);
                    }
                        break;

                    // 0x0E
                    case PSU_RCmd_ModuleMiscInfo:
                    {
                        byte value[4];
                        unsigned short MiscType = (frame.data[0] << 8) | frame.data[1];
                        float MiscInfoValue = 0;
                        memcpy(value, frame.data + 4, sizeof(value));
                        MiscInfoValue = IEEE_754_to_float(value);

                        if(MiscType == FAN_SPEED_CMD)
                        {
                            return_fan_speed(address, (unsigned int)MiscInfoValue);
                        }
                        if(MiscType == TEMP_DC_CMD)
                        {
                            MiscInfoValue += 60;
                            return_exlet_temp(address, (char)MiscInfoValue);
                            return_outlet_temp(address, (char)MiscInfoValue);
                        }
                        if(MiscType == TEMP_PFC_CMD)
                        {
                            MiscInfoValue += 60;
                            return_inlet_temp(address, (char)MiscInfoValue);
                        }
                    }
                        break;

                    // 0x13
                    case PSU_WCmd_ModuleWalkIn:
                    {

                    }
                        break;
                }
            }
            if(PwrFrameMsg->InfyBits.DestinationAddress == NEXTON_ADD)
            {
                switch(PwrFrameMsg->NextonBits.CmdValue)
                {
                    case Nexton_PSU_DcOutputValue:
                    {
                        short outputVol = ((frame.data[0] << 8) + frame.data[1]);
                        short outputCur = ((frame.data[2] << 8) + frame.data[3]);
                        short outputPow = ((frame.data[4] << 8) + frame.data[5]);
                        char temp = frame.data[6];

                        return_output_temp(address, outputVol, outputCur, outputPow, temp);

                        float vol = ((float)outputVol) * 0.1;
                        float cur = ((float)outputCur) * 0.1;
                        return_module_output(address, vol, cur);
                    }
                        break;

                    case Nexton_PSU_StatusEvent:
                    {
                        byte isErr =  (frame.data[0] >> 0) & 0x01;
                        byte status = (frame.data[0] >> 1) & 0x01;
                        byte err1 = frame.data[2];
                        byte err2 = frame.data[3];
                        byte err3 = frame.data[4];
                        byte err4 = frame.data[5];

                        return_module_status(address, isErr, status, err1, err2, err3, err4);
                    }
                        break;

                    case Nexton_PSU_AcInputValue:
                    {
                        short vR = ((frame.data[0] << 8) + frame.data[1]);
                        short vS = ((frame.data[2] << 8) + frame.data[3]);
                        short vT = ((frame.data[4] << 8) + frame.data[5]);

                        // vR, vS, vT unit: 0.1V
                        return_module_input(address, vR, vS, vT);
                    }
                        break;
                }
            }
		}
		else
			usleep(10000);
	}
}

//================================================
// Private Function
//================================================
void SendCmdToPsu(int cmd, byte *data, byte dataLen)
{
    PwrFrame PwrFrameMsg;
    struct can_frame frame;

    //設定 CANBSU 2.0B 長封包
    PwrFrameMsg.PwrMessage = cmd | 0x80000000;

    frame.can_id = PwrFrameMsg.PwrMessage;
    frame.can_dlc = dataLen;
    memcpy(frame.data, data, dataLen);

    write(CanFd, &frame, sizeof(struct can_frame));
    // 群命令才 delay
    //if (PwrFrameMsg.InfyBits.DestinationAddress == INFY_ADD_BROADCAST)
    //{
        usleep(CMD_DELAY_TIME);
    //}
}

void SetPowerOnOff(byte address, byte device, byte value)
{
    byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_WCmd_ModulePowerOnOff;

    memset(data, 0x00, ARRAY_SIZE(data));
    // 1 : 關機
    // 0 : 開機
    data[0] = value;

    PwrFrameMsg.InfyBits.DeviceValue = device;
    PwrFrameMsg.InfyBits.DestinationAddress = address;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

    SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void SetAllModuleOutput(byte address, byte device, int voltage, int current)
{
    byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_WCmd_SetOutput;

    int Vol = voltage * 100;
    int Cur = current * 100;

    memset(data, 0x00, ARRAY_SIZE(data));

    // 輸出電壓
    data[0] = (Vol >> 24) & 0xFF;
    data[1] = (Vol >> 16) & 0xFF;
    data[2] = (Vol >> 8) & 0xFF;
    data[3] = Vol & 0xFF;
    // 輸出電流
    data[4] = (Cur >> 24) & 0xFF;
    data[5] = (Cur >> 16) & 0xFF;
    data[6] = (Cur >> 8) & 0xFF;
    data[7] = Cur & 0xFF;

    PwrFrameMsg.InfyBits.DeviceValue = device;
    PwrFrameMsg.InfyBits.DestinationAddress = address;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

    SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void SetModuleOutputVol(byte address, byte device, int voltage, int current)
{
    byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_WCmd_ModuleSetOutput;

    int Vol = voltage * 100;
    int Cur = current * 100;

    memset(data, 0x00, ARRAY_SIZE(data));

    // 輸出電壓
    data[0] = (Vol >> 24) & 0xFF;
    data[1] = (Vol >> 16) & 0xFF;
    data[2] = (Vol >> 8) & 0xFF;
    data[3] = Vol & 0xFF;
    // 輸出電流
    data[4] = (Cur >> 24) & 0xFF;
    data[5] = (Cur >> 16) & 0xFF;
    data[6] = (Cur >> 8) & 0xFF;
    data[7] = Cur & 0xFF;

    PwrFrameMsg.InfyBits.DeviceValue = device;
    PwrFrameMsg.InfyBits.DestinationAddress = address;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

    SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void SetLed(byte address, byte device, byte value)
{
    byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_WCmd_ModuleFlashLed;

    memset(data, 0x00, ARRAY_SIZE(data));
    // 1 : 閃爍
    // 0 : 正常
    data[0] = value;

    PwrFrameMsg.InfyBits.DeviceValue = device;
    PwrFrameMsg.InfyBits.DestinationAddress = address;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

    SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

pid_t InitialCommunication()
{
    CanFd = InitCanBus();

    if(CanFd < 0)
    {
        PRINTF_LIB_FUNC("Init can bus fail.\n");
        return false;
    }

    recFork = fork();
    if(recFork == 0)
    {
        ReceiveDataFromCanBus();
        return 0;
    }

    return recFork;
}

//================================================
// API Function
//================================================
void SwitchPower(byte group, byte value)
{
    if (group == INFY_ADD_BROADCAST)
    {
        SetPowerOnOff(group, DEVICE_NO_SINGLE_MODULE, value);
    }
    else
    {
        SetPowerOnOff(group, DEVICE_NO_GROUP_MODULE, value);
    }
}

void SinglePsuPower(byte address, byte value)
{
    SetPowerOnOff(address, DEVICE_NO_SINGLE_MODULE, value);
}

void SwitchPower_On(byte group)
{
    SwitchPower(group, PSU_POWER_ON);
}

void SwitchPower_Off(byte group)
{
    SwitchPower(group, PSU_POWER_OFF);
}

void SinglePsuPower_On(byte address)
{
    SetPowerOnOff(address, DEVICE_NO_SINGLE_MODULE, PSU_POWER_ON);
}

void SinglePsuPower_Off(byte address)
{
    SetPowerOnOff(address, DEVICE_NO_SINGLE_MODULE, PSU_POWER_OFF);
}

void SleepMode(byte group, byte value)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_WCmd_ModuleSleepMode;

	memset(data, 0x00, ARRAY_SIZE(data));
	// 1 : 休眠
	// 0 : 起床
	data[0] = value;

	if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void FlashLed(byte group, byte value)
{
    if (group == INFY_ADD_BROADCAST)
    {
        SetLed(group, DEVICE_NO_SINGLE_MODULE, value);
    }
    else
    {
        SetLed(group, DEVICE_NO_GROUP_MODULE, value);
    }
}

void SingleFlashLed(byte address, byte value)
{
    SetLed(address, DEVICE_NO_SINGLE_MODULE, value);
}

void FlashLed_Static(byte group)
{
    FlashLed(group, PSU_FLASH_NORMAL);
}

void FlashLed_Blinking(byte group)
{
    FlashLed(group, PSU_FLASH_ON);
}

void SingleFlashLed_Static(byte address)
{
    SingleFlashLed(address, PSU_FLASH_NORMAL);
}

void SingleFlashLed_Blinking(byte address)
{
    SingleFlashLed(address, PSU_FLASH_ON);
}

void PresentOutputVol(byte group, int voltage, int current)
{
    if(group == INFY_ADD_BROADCAST)
    {
        SetAllModuleOutput(group, DEVICE_NO_SINGLE_MODULE, voltage, current);
    }
    else
    {
        SetAllModuleOutput(group, DEVICE_NO_GROUP_MODULE, voltage, current);
    }
}

void SingleOutputVol(byte address, int voltage, int current)
{
    SetModuleOutputVol(address, DEVICE_NO_SINGLE_MODULE, voltage, current);
}

void FanNoiseInfo(byte group, byte value)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_WCmd_ModuleSetMiscInfo;

	memset(data, 0x00, ARRAY_SIZE(data));

	// 風扇低噪音
    data[0] = ((SetMiscInfo_FanMode >> 8) & 0xFF);
    data[1] = (SetMiscInfo_FanMode & 0xFF);
    data[7] = value;

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void SetWalkInConfig(byte group, byte enable, byte sec)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_WCmd_ModuleWalkIn;

	memset(data, 0x00, ARRAY_SIZE(data));
	unsigned short _Sec = sec * 100;

	// Walk-in mode enable
	data[0] = enable;
	// Walk-in time (default == 5s)
	data[6] = (_Sec >> 8) & 0xFF;
	data[7] = _Sec & 0xFF;

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void SetDirModulePresentOutput(byte group, int voltage, int current, byte _switch, byte _interRelay)
{
}

void SetDipSwitchMode()
{
    byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_WCmd_DipSwitchMode;

    memset(data, 0x00, ARRAY_SIZE(data));
    data[0] = 0x01;

    PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    PwrFrameMsg.InfyBits.DestinationAddress = INFY_ADD_BROADCAST;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

    SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void UnlockPsuAlarm(byte full_address)
{
    // no function
}

/**********************************************************************************/
/***                                                                            ***/
/***                                   Get                                      ***/
/***                                                                            ***/
/**********************************************************************************/
void GetStatus(byte group)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleStatus;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetFanSpeed(byte group)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleMiscInfo;

	memset(data, 0x00, ARRAY_SIZE(data));

	data[0] = (FAN_SPEED_CMD >> 8) & 0xFF;
	data[1] = FAN_SPEED_CMD & 0xFF;

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetDcTemperature(byte group)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleMiscInfo;

	memset(data, 0x00, ARRAY_SIZE(data));

	data[0] = (TEMP_DC_CMD >> 8) & 0xFF;
	data[1] = TEMP_DC_CMD & 0xFF;

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetPfcTemperature(byte group)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleMiscInfo;

	memset(data, 0x00, ARRAY_SIZE(data));

	data[0] = (TEMP_PFC_CMD >> 8) & 0xFF;
	data[1] = TEMP_PFC_CMD & 0xFF;

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetModuleCount(byte group)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_SysModuleCount;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetSysModuleCount(void)
{
    GetModuleCount(SYSTEM_CMD);
}

void GetModuleVer(byte group, byte type)
{
	// 無系統廣播功能
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleVersion;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetAllModuleVer(byte group)
{
    GetModuleVer(group, 0);
}

void GetModuleCap(byte group)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleCapability;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetModuleBarCode(byte group)
{
	// 無系統廣播功能
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleBarcode;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetModuleInputVol(byte group)
{
	// 無系統廣播功能
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleInputVoltage;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetModuleInputCur(byte group)
{

}

void GetModuleIavailable(byte group, unsigned short voltage)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleIAvailable;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetModuleOutput(byte group)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_SysOutputVolCur;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetModuleOutputF(byte group)
{
	byte data[8];
    PwrFrame PwrFrameMsg;
    PwrFrameMsg.PwrMessage = 0;
    PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_SysOutputVolCur_F;

	memset(data, 0x00, ARRAY_SIZE(data));

    if (group == INFY_ADD_BROADCAST)
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_SINGLE_MODULE;
    }
    else
    {
        PwrFrameMsg.InfyBits.DeviceValue = DEVICE_NO_GROUP_MODULE;
    }
    PwrFrameMsg.InfyBits.DestinationAddress = group;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void GetErrorRecord(byte group)
{
    // no function
}

/**********************************************************************************/
/***                                                                            ***/
/***                                 Upgrate                                    ***/
/***                                                                            ***/
/**********************************************************************************/
void ChangePsuBaudrate(short baudrate)
{
}