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

#include "Infypwr_PsuCommObj.h"

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

#define DEBUG_LIB						1

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

// 設備號 0x09 與 0x0C 似乎是模塊
unsigned int filter[3] = { 0x87570000, 0x8E9B0000, 0x829B0000 };

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

void IEEE_754_to_bytes(float target, byte *bytes2)
{
	int value2 = 0;
	number.f = target;
	int index = 31;

	value2 |= number.raw.sign << index;
	int k;
	for (k = 8 - 1; k >= 0; k--)
	{
		index--;
		if ((number.raw.exponent >> k) & 1)
			value2 |= 1 << index;
	}

	for (k = 23 - 1; k >= 0; k--)
	{
		index--;
		if ((number.raw.mantissa >> k) & 1)
			value2 |= 1 << index;
	}

	*(bytes2) = (value2 >> 24) & 0xFF;
	*(bytes2 + 1) = (value2 >> 16) & 0xFF;
	*(bytes2 + 2) = (value2 >> 8) & 0xFF;
	*(bytes2 + 3) = value2 & 0xFF;
}

//================================================
// Callback function
//================================================
void RefreshStatus(void *func)
{
	return_status = func;
}

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

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

void RefreshFwVersion(void *func)
{
	return_fw_version = func;
}

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

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

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

void RefreshMisInfo(void *func)
{
	return_mis_info = 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;
	struct can_filter 		rfilter[2];

	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;

	//===================================CAN Filter===================================
	//Filter only allowed: Destination CSU 0xF0
	rfilter[0].can_id = 0xF000;
	rfilter[0].can_mask = 0xF000;

	//Filter only allowed: Destination Nexton 0xFF
	rfilter[1].can_id = 0xFF00;
	rfilter[1].can_mask = 0xFF00;

	if (setsockopt(s0, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter)) < 0)
	{
		#ifdef SystemLogMessage
		PRINTF_LIB_FUNC("Set SOL_CAN_RAW NG");
		#endif
	}

   	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
//================================================
byte isFilterValue(unsigned int value)
{
	byte result = NO;

	for(byte i = 0; i < ARRAY_SIZE(filter); i++)
	{
		if (value == filter[i])
		{
			result = YES;
			break;
		}
	}

	return result;
}

bool GetRealIndexByGroup(byte *_address)
{
	for (byte i = 0; i < 2; i++)
	{
		for (byte j = 0; j < infy_pow_info[i].psuCount; j++)
		{
			if (infy_pow_info[i].serialNumber[j] == *_address)
			{
				*_address = infy_pow_info[i].targetNumber[j];
				if (i > 0)
					*_address += infy_pow_info[0].psuCount;

				return true;
			}
		}
	}

	return false;
}

void ReceiveDataFromCanBus()
{
	int nbytes;
	struct can_frame frame;
	PwrFrame *PwrFrameMsg;
	byte group, address;
	byte _totalModuleCount = 0;
	byte _totalModuleCountBuf = 0;
	byte checkTotalCount = 0;

	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 != NEXTON_ADD)
            {
                if(PwrFrameMsg->InfyBits.DestinationAddress != INFY_ADD_CSU || PwrFrameMsg->InfyBits.Error != Infy_MsgErr_Normal)
                {
                    continue;
                }

                switch (PwrFrameMsg->InfyBits.CmdValue)
                {
                    case PSU_WCmd_ModuleWalkIn:
                    {
                        //address = frame.can_id & 0x000000FF;
    //					printf("walk in response address = %d, [0] = %d, [1] = %d, [2] = %d, [3] = %d, [4] = %d, [5] = %d, [6] = %d, [7] = %d \n"
    //							, address,
    //							frame.data[0], frame.data[1],
    //							frame.data[2], frame.data[3],
    //							frame.data[4], frame.data[5],
    //							frame.data[6], frame.data[7]);
                    }
                        break;

                    case PSU_RCmd_ModuleStatus:
                    {
                        group = frame.data[2];
                        byte SN = address;

                        short temp = frame.data[4];
                        int status = (frame.data[5] << 16) + (frame.data[6] << 8) + frame.data[7];
                        return_status(group, SN, temp, status, PSU_PROTOCOL_TYPE, LIB_NO_USE, LIB_NO_USE, LIB_NO_USE, LIB_NO_USE);
                        //PRINTF_LIB_FUNC("group = %d, address = %d, temp = %d \n", group, address, temp);
                    }
                        break;

                    case PSU_RCmd_SysModuleCount:
                    {
						// 回傳模組數量
						group = address;

						byte count = frame.data[2];
						if (group == SYSTEM_CMD && _totalModuleCount == 0 && count != 0)
						{
							if (_totalModuleCountBuf != count)
							{
								checkTotalCount = 0;
								_totalModuleCountBuf = count;
							}
							else
							{
								if (checkTotalCount >= 10)
								{
									printf("***** Total Count = %d ***** \n", count);
									_totalModuleCount = count;
								}
								else
									checkTotalCount++;
							}
						}

						if (group == SYSTEM_CMD)
							return_module_count(group, _totalModuleCount);
						else
							return_module_count(group, count);
                    }
                        break;

                    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;

                        if (maxCur > MODULE_MAX_VOL)
                        	maxCur = MODULE_MAX_VOL;
                        return_available_cap(address, maxVol, minVol, maxCur, totalPow);

                        if (_totalModuleCount != 0)
                        	_totalModuleCount = 0;
//    					printf("address = %d, maxVol = %d, minVol = %d, maxCur = %d, totalPow = %d \n",
//    							address, maxVol, minVol, maxCur, totalPow);
                    }
                        break;

                    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;

                        return_get_output(address, outputVol, outputCur);
                        //PRINTF_LIB_FUNC("address = %d, outputVol = %d, outputCur = %d \n", address, outputVol, outputCur);
                    }
                        break;
                    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, PSU_PROTOCOL_TYPE);
                    }
                        break;
                    case PSU_RCmd_ModuleIAvailable:
                    {
                        // 回傳降載後的電流
                        address = frame.can_id & 0x000000FF;

                        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);
                        //PRINTF_LIB_FUNC("address = %d, iAvailCur = %d \n", address, iAvailCur);
                    }
                        break;

                    case PSU_RCmd_ModuleMiscInfo:
                    {
                        address = frame.can_id & 0x000000FF;
                        float ReturnValue;
                        byte value[4];
                        byte type;

                        memcpy(value, frame.data + 4, sizeof(value));
                        ReturnValue = IEEE_754_to_float(value);
                        if (frame.data[0] == ((FAN_SPEED_CMD >> 8) & 0xFF) && frame.data[1] == (FAN_SPEED_CMD & 0xFF))
                        {
                            type = 1;
                            return_mis_info(address, ReturnValue, type);
                        }
                        else if (frame.data[0] == ((TEMP_DC_CMD >> 8) & 0xFF) && frame.data[1] == (TEMP_DC_CMD & 0xFF))
                        {
                            type = 2;
                            return_mis_info(address, ReturnValue, type);
                        }
                        else if (frame.data[0] == ((TEMP_DC_CMD >> 8) & 0xFF) && frame.data[1] == (TEMP_DC_CMD & 0xFF))
                        {
                            type = 3;
                            return_mis_info(address, ReturnValue, type);
                        }
                    }
                        break;

                    case PSU_RCmd_ModuleVersion:
                    {
                        // 回傳版號 : 無系統回覆功能
                        address = frame.can_id & 0x000000FF;

                        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]);

                        return_fw_version(address, dcSwVer, pfcSwVer, hwVer, PSU_PROTOCOL_TYPE);
                        //PRINTF_LIB_FUNC("address = %d, DC %d, PFC %d, HW %d \n", address, dcSwVer, pfcSwVer, hwVer);
                    }
                        break;

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

                    case PSU_RCmd_ModuleInputVoltage:
                    {
                        // 回傳三向輸入電壓
                        address = frame.can_id & 0x000000FF;

                        short abVol = ((frame.data[0] << 8) + frame.data[1]) / 10;
                        short bcVol = ((frame.data[2] << 8) + frame.data[3]) / 10;
                        short caVol = ((frame.data[4] << 8) + frame.data[5]) / 10;

                        return_input_vol(address, abVol, bcVol, caVol);
                        //PRINTF_LIB_FUNC("address = %d, abVol = %d, bcVol = %d, caVol = %d \n", address, abVol, bcVol, caVol);
                    }
                        break;
                    case PSU_RCmd_ModuleOutputVolCur_F:
                    {
						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(address, _Vol, _Cur);
                    }
                    	break;
                    default:
                        break;
                }
            }
            else
            {
                switch(PwrFrameMsg->NextonBits.CmdValue)
                {
                    case Nexton_PSU_DcOutputValue:
                    {
                        /*Test mode used*/
                        // 回傳輸出值與入風口溫度
                        address = frame.can_id & 0x000000FF;

                        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]);
                        byte temp = frame.data[6];

                        return_output_temp(address, outputVol, outputCur, outputPow, temp, PSU_PROTOCOL_TYPE);
                        //printf("address = %d, outputVol = %d \n", address, outputVol);
                    }
                        break;
                    case Nexton_PSU_StatusEvent:
                    {
                        /*Test mode used*/
                        // 回傳輸出值與入風口溫度
                        address = frame.can_id & 0x000000FF;

                        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);
                        //PRINTF_LIB_FUNC("address = %d, abVol = %d, bcVol = %d, caVol = %d \n", address, abVol, bcVol, caVol);
                    }
                        break;
                    case Nexton_PSU_AcInputValue:
                    {
                        /*Test mode used*/
                        // 回傳輸出值與入風口溫度
                        address = frame.can_id & 0x000000FF;

                        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]);

                        return_module_input(address, vR, vS, vT);
                        //PRINTF_LIB_FUNC("address = %d, abVol = %d, bcVol = %d, caVol = %d \n", address, abVol, bcVol, caVol);
                    }
                        break;
                    default:
                        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);
}

bool InitialCommunication()
{
	CanFd = InitCanBus();

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

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

    return true;
}

//================================================
// API Function
//================================================
void SwitchPower(byte group, 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;

    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 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)
{
	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;

    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 PresentOutputVol(byte group, int voltage, int current, byte psuCount)
{
	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;

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

	// 0xA0 power poriority mode
	// 0xA1 denoise mode
	// 0xA2 quiet mode
	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;

	//printf("walk in cmd = %x \n", cmd);
	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

void SetDirModulePresentOutput(byte group, int voltage, int current, byte _switch, byte _interRelay)
{
	byte data[8];
	uint cmd = TEST_PRESENT_OUT;  //0x180100E5

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

	// 輸出電壓
	data[0] = (voltage >> 8) & 0xFF;
	data[1] = voltage & 0xFF;
	// 輸出電流
	data[2] = (current >> 8) & 0xFF;
	data[3] = current & 0xFF;
	// 開 / 關
	data[4] = _switch;
	// Internal Relay
	data[5] = _interRelay;

	if (group == SYSTEM_CMD)
		cmd |= INFYPWR_BROADCAST;
	else
		cmd |= (group << 8);
	SendCmdToPsu(cmd, data, sizeof(data));
}

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 PresentSingleOutput(byte moduleIndex, 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_NO_SINGLE_MODULE;
    PwrFrameMsg.InfyBits.DestinationAddress = moduleIndex;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

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

void SwitchSinglePower(byte moduleIndex, 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_NO_SINGLE_MODULE;
    PwrFrameMsg.InfyBits.DestinationAddress = moduleIndex;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

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

void FlashSingleLed(byte moduleIndex, 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_NO_SINGLE_MODULE;
    PwrFrameMsg.InfyBits.DestinationAddress = moduleIndex;
    PwrFrameMsg.InfyBits.SourceAddress = INFY_ADD_CSU;

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

void GetSingleModuleOutputF(byte moduleIndex)
{
	byte data[8];
	PwrFrame PwrFrameMsg;
	PwrFrameMsg.PwrMessage = 0;
	PwrFrameMsg.InfyBits.CmdValue = PSU_RCmd_ModuleOutputVolCur_F;

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

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

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

/**********************************************************************************/
/***                                                                            ***/
/***                                   Get                                      ***/
/***                                                                            ***/
/**********************************************************************************/
void GetStatus(byte group, byte param)
{
	if (param == LIB_NO_USE)
		return;

	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 GetModuleVer(byte group)
{
	// 無系統廣播功能
	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;
	//PRINTF_LIB_FUNC("GetModuleVer cmd = %x\n", cmd);
	SendCmdToPsu(PwrFrameMsg.PwrMessage, data, sizeof(data));
}

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;
	//PRINTF_LIB_FUNC("GetModuleCap cmd = %x\n", cmd);
	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 GetModuleInput(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 GetModuleIavailable(byte group)
{
	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));
}

/**********************************************************************************/
/***                                                                            ***/
/***                                 Upgrate                                    ***/
/***                                                                            ***/
/**********************************************************************************/
void ChangePsuBaudrate(short baudrate)
{
	byte data[8];
	uint cmd = CHANGE_BAUDRATE;  //0x180100E5

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

	data[0] = 0x11;
	data[1] = 0x26;

	if (baudrate == 125)
		data[7] = 0xA0;
	else if (baudrate == 250)
		data[7] = 0xA1;
	else if (baudrate == 500)
		data[7] = 0xA2;

	cmd |= INFYPWR_BROADCAST | INFYPWR_DEFAULT;
	SendCmdToPsu(cmd, data, sizeof(data));
}