csu3_am335x/EVSE/Projects/DO360/Apps/Module_PsuComm.c

#include "Module_PsuComm.h"
#include "Config.h"
#include "Common.h"

#define DERATING_COUNT		30
#define DERATING_GAP		30
#define ELEMENT_NOT_FIND	255
#define CHK_VOL_RANGE		50
#define CHK_CUR_RANGE		10
#define DERATING_RANGE		100
#define ZERO_CURRENT		10			// 該值須保持最小為 1A
#define ZERO_VOLTAGE		50
#define STOP_CURRENT		30
#define PSU_MAX_CUR			1000
#define PSU_MIN_VOL			1500
#define PRE_CHARG_STEP_CUR	30
#define PRE_CHARG_RANGE		50
#define CMD_DELAY_TIME 		25000                   // 25us
#define PSU_TASK_CHECK_TIME 1
#define PSU_COMM_CHECK_TIME 1

#define GET_PSU_COUNT_INTERVAL          1           // unit: second
#define GET_PSU_COUNT_TIME              13          // unit: second
#define GET_PSU_LOCATION_INTERVAL       200         // unit: millisecond
#define PSU_COUNT_CONFIRM_INTERVAL      200         // unit: millisecond
#define PSU_COUNT_CONFIRM_TIME          1           // unit: second
#define GET_PSU_VERSION_INTERVAL        200         // unit: millisecond
#define GET_PSU_CAP_INTERVAL            200         // unit: millisecond
#define GET_PSU_CAP_TIME                1           // unit: second
#define STABLE_CURRENT_TOLERANCE        10          // unit: 0.1A, 1A
#define MAX_STABLE_COUNT                24

#define WAIT_EV_DERATING_TIMEOUT        5           // unit: second
#define WAIT_SLAVE_POWER_OFF_TIMEOUT    5           // unit: second
#define WAIT_PARALLEL_RELAY_DELAY       1           // unit: second
#define WAIT_RELAY_CONFIRMED_TIME       3           // unit: second
#define MAX_PREPARE_SWITCH_OFF_TIME     10          // unit: second
#define MIN_POWER_OFF_TIME              1           // unit: second
#define WAIT_SLAVE_TO_CHARGING          1           // unit: second
#define WAIT_SLAVE_TIMEOUT              5           // unit: second
#define WAIT_GRAB_TIME                  15          // unit: second
#define MAX_PSU_POWER_OFF_CURRENT       50          // unit: 0.1A, 5A
#define MAX_PSU_POWER_OFF_VOLTAGE       100         // unit: 0.1A, 10V
#define PRECHARGE_OFFSET_VOLTAGE        20          // unit: 0.1V, 2V
#define PRECHARGE_RANGE_VOLTAGE         50          // unit: 0.1V, 5V
#define WAIT_PRECHARGE_TIME             10          // unit: second
#define EXTEND_CAPABILITY_DELAY         30          // unit: second
#define EXTEND_LOADING                  8000        // unit: 0.01%, 80%
#define RELEASE_LOADING                 5000        // unit: 0.01%, 50%
#define RELEASE_LOADING_OFFSET          1000        // unit: 0.01%, 10%
#define BALANCE_CURRENT_INTERVAL        100         // unit: 1ms, 100ms
#define CURRENT_REACH_TARGET_TIME       5           // unit: 1s, 5s
#define CURRENT_STABLE_TIME             10          // unit: 1s, 10s
#define REACH_CURRENT_TOLERANCE         10          // unit: 0.1A, 1A
#define MAX_ADJ_BALANCE_CURRENT         30          // unit: 0.1A, 3A
#define START_BALANCE_CRITERIA          100         // unit: 0.01%, 1%
#define STOP_BALANCE_CRITERIA           10          // unit: 0.01%, 0.1%
#define EV_MAX_CURRENT_DELAY            120         // unit: second
#define WAIT_SLAVE_READY_TIME           15          // unit: second
#define WAIT_SLAVE_DELAY                1           // unit: second
#define SHOW_OUTPUT_DELAY               1
#define CURRENT_BALANCE_CRITERIA        400         // unit: 0.1A, 40A
#define SAFETY_PRECHARGE_OFFSET         200         // unit: 0.1V, 20V
#define CHARGING_DELAY_INTERVAL         200         // unit: 1ms, 400ms
#define MAX_CHARGING_DELAY_COUNT        15
#define VOLTAGE_RESUME_STEP             10          // unit: 0.1V, 1V
#define POWER_ONOFF_RESEND_INTERVAL     1           // unit: 1s, 1s
#define COMM_LOST_CRITICAL              0
#define LOST_CNT_CRITICAL               10

#if SAFETY_TEST_ENABLE
#define PRECHARGE_OFFSET                1           // 0: normal output, 1: precharge voltage offset enable
#define ONE_MODULE_OUTPUT               1           // 0: normal output, 1: only one module output enable
#define MASTER_OUTPUT_FIRST             0           // 0: normal output, 1: master output first enable
#else
#define PRECHARGE_OFFSET                0           // 0: normal output, 1: precharge voltage offset enable
#define ONE_MODULE_OUTPUT               0           // 0: normal output, 1: only one module output enable
#define MASTER_OUTPUT_FIRST             0           // 0: normal output, 1: master output first enable
#endif

struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct PsuData 					*ShmPsuData;
ChargerInfoData                 *ShmChargerInfo;
PsuPositionInfoData             *ShmPsuPosition;
PsuGroupingInfoData             *ShmPsuGrouping;

bool libInitialize = false;
byte _gunCount = 0;
byte _maxGroupCount = 0;
byte getAvailableCapOffset = 5;
byte deratingKeepCount = 0;
byte psuCmdSeq = _PSU_CMD_CAP;

byte startModuleFlag = false;
bool psuReceiveRecovery = false;
bool isCommStart = false;
int lostCnt = 0;

unsigned short evseOutVol[CONNECTOR_QUANTITY] = {0, 0, 0, 0};
unsigned short evseOutCur[CONNECTOR_QUANTITY] = {0, 0, 0, 0};
unsigned short evseOutputDelay[CONNECTOR_QUANTITY] = {0, 0, 0, 0};
struct timespec _PsuReceiveRecoveryCheck_time;
struct timespec _PsuWorkStep_time;
struct timespec _cmdSubPriority_time;
struct timespec _PsuGroupRole_time[CONNECTOR_QUANTITY];
struct timespec _ChargingRequest_time[CONNECTOR_QUANTITY];
struct timespec _PsuGroupDerating_time[CONNECTOR_QUANTITY];
struct timespec _StopCharging_time[CONNECTOR_QUANTITY];
struct timespec _ExtendCapability_time[CONNECTOR_QUANTITY];
struct timespec _ReachCurrent_time[CONNECTOR_QUANTITY];
struct timespec _BalanceCurrent_time[CONNECTOR_QUANTITY];
struct timespec _MaxCurrent_time[CONNECTOR_QUANTITY];
struct timespec _StageCurrent_time[CONNECTOR_QUANTITY];
struct timespec _CheckSlaveReady_time[CONNECTOR_QUANTITY];
struct timespec _ChargingDelay_time[CONNECTOR_QUANTITY];
struct timespec _PoweOnOff_time[CONNECTOR_QUANTITY];
struct timespec _PsuCommCheck_time;

unsigned short  GCTargetVoltage[CONNECTOR_QUANTITY];
unsigned short  GCTargetCurrent[CONNECTOR_QUANTITY];
unsigned short  StableOutputCurrent[CONNECTOR_QUANTITY];
unsigned short  MaxCurrentDemand[CONNECTOR_QUANTITY];
unsigned short  StageMaxCurrent[CONNECTOR_QUANTITY];

GroupOutputConfigInfo PreGroupOutput[MAX_GROUP_QUANTITY];
unsigned char OutputConfigStep[MAX_GROUP_QUANTITY];
unsigned char _preOutputConfigStep[MAX_GROUP_QUANTITY];

unsigned char _GfdStep[MAX_GROUP_QUANTITY];
unsigned char _VoltageResumeCnt[MAX_GROUP_QUANTITY];

//=================================
// Common routine
//=================================

// return psu group number
// return -1 when out of TotalPsuQuantity
int FindTargetGroup(byte address)
{
	return address < ShmPsuPosition->TotalPsuQuantity ? ShmPsuPosition->PsuAddressInfo[address].GroupNo : -1;
}

// return psu index in the group
// return -1 when out of TotalPsuQuantity
int FindGroupIndex(byte address)
{
    return address < ShmPsuPosition->TotalPsuQuantity ? ShmPsuPosition->PsuAddressInfo[address].GIndex : -1;
}

//=================================
// Save data to share memory Function
//=================================
bool FindChargingInfoData(byte target, struct ChargingInfoData **chargingData)
{
	if(GENERAL_GUN_QUANTITY > 0 && target < GENERAL_GUN_QUANTITY)
	{
		chargingData[target] = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[target].GeneralChargingData;
		return true;
	}

	return false;
}

//=================================
// Alarm code mapping to share memory Function
//=================================
// 檢查 Byte 中某個 Bit 的值
// _byte : 欲改變的 byte
// _bit : 該 byte 的第幾個 bit
unsigned char mask_table[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
unsigned char DetectBitValue(unsigned char _byte, unsigned char _bit)
{
	return ( _byte & mask_table[_bit] ) != 0x00;
}

void AbnormalStopAnalysis(byte gun_index, int errCode)
{
	for (char i = 0; i < 4; i++)
	{
		unsigned char byteIndex = (errCode >> (8 * i)) & 0xff;

		for (char bitIndex = 0; bitIndex < 8; bitIndex++)
		{
			if(DetectBitValue(byteIndex , bitIndex) == 1)
			{
				switch(i)
				{
					case 0:
					{
					    // err 1
						if (bitIndex == 2)
						{
						    // 012307
						    // fuse burn-out
						    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFuseBurnOut = YES;
						}
						else if (bitIndex == 3)
						{
						    // 012308
						    // Communication fault between PFC and DCDC
						    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuPfcAndDcdcCommFault = YES;
						}
                        else if (bitIndex == 6)
                        {
                            // 012309
                            // Unbalance positive and negative BUS voltage
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuBusVoltageUnbalance = YES;
                        }
                        else if (bitIndex == 7)
                        {
                            // 012310
                            // BUS over voltage
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuBusOverVoltage = YES;
                        }
					}
						break;
				case 1:
					{
					    // err 2
						if (bitIndex == 0)
						{
						    // 012311
						    // BUS voltage abnormal
						    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuBusVoltageAbnormal = YES;
						}
						else if (bitIndex == 1)
                        {
						    // 012270
						    // Over voltage of any phase
						    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuInputOVP = YES;
                        }
                        else if (bitIndex == 2)
                        {
                            // 012263
                            // ID number repetition
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDuplicateID = YES;
                        }
                        else if (bitIndex == 3)
                        {
                            // 012312
                            // BUS under voltage
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuBusUnderVoltage = YES;
                        }
                        else if (bitIndex == 4)
                        {
                            // 012313
                            // Phase loss
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuInputPhaseLoss = YES;
                        }
                        else if (bitIndex == 6)
                        {
                            // 012271
                            // Under voltage of any phase
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuInputUVP = NO;
                        }
					}
					break;
				case 2:
					{
					    // err3
						if (bitIndex == 0)
						{
						    // 012240
						    // CAN communication fault
						    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuCommunicationFail = YES;
						}
						else if (bitIndex == 1)
						{
						    // 012275
						    // DCDC uneven current sharing
						    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuSevereUnevenCurrent = YES;
						}
                        else if (bitIndex == 3)
                        {
                            // 012278
                            // PFC power off
                            //ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFfcSideShutDown = YES;
                        }
                        else if (bitIndex == 5)
                        {
                            // 012314
                            // Full speed of fan
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFanFullSpeed = YES;
                        }
                        else if (bitIndex == 6)
                        {
                            // 012266
                            // DCDC power off
                            //ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDcSideShutDown = YES;
                        }
                        else if (bitIndex == 7)
                        {
                            // 012273
                            // Module unders power limiting status
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuPowerLimitedState = YES;
                        }
					}
					break;
				case 3:
                    {
                        // err 4
                        if (bitIndex == 0)
                        {
                            // 012315
                            // Temperature power limiting
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuTemperaturePowerLimit = YES;
                        }
                        else if (bitIndex == 1)
                        {
                            // 012316
                            // AC power limiting
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuAcPowerLimit = YES;
                        }
                        else if (bitIndex == 2)
                        {
                            // 012317
                            // DCDC eeprom faults
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDcdcEepromFault = YES;
                        }
                        else if (bitIndex == 3)
                        {
                            // 012269
                            // Fan faults
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFanFailureAlarm = YES;
                        }
                        else if (bitIndex == 4)
                        {
                            // 012264
                            // DCDC short circuit
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuOutputShortCircuit = YES;
                        }
                        else if (bitIndex == 5)
                        {
                            // 012318
                            // PFC eeprom faults
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuPfcEepromFault = YES;
                        }
                        else if (bitIndex == 6)
                        {
                            // 012226
                            // DCDC over temperature
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuCriticalPointOTP = YES;
                        }
                        else if (bitIndex == 7)
                        {
                            // 012319
                            // DCDC output over voltage
                            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDcdcOverVoltage = YES;
                        }
                    }
                    break;
				}
			}
//			else
//			{
//				switch (byteIndex) {
//				case 0: {
//					if (bitIndex == 0)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuOutputShortCircuit = NO;
//					else if (bitIndex == 5)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDcSideShutDown = NO;
//				}
//					break;
//				case 1: {
//					if (bitIndex == 1)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm = NO;
//					else if (bitIndex == 2)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuProtectionAlarm = NO;
//					else if (bitIndex == 3)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFanFailureAlarm = NO;
//					else if (bitIndex == 4)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuCriticalPointOTP = NO;
//					else if (bitIndex == 5)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDcSideShutDown = NO;
//				}
//					break;
//				case 2: {
//					if (bitIndex == 1)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDuplicateID = NO;
//					if (bitIndex == 2)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuThreePhaseOnputImbalance = NO;
//					else if (bitIndex == 3)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuThreePhaseInputInadequate = NO;
//					else if (bitIndex == 4)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuThreePhaseInputInadequate = NO;
//					else if (bitIndex == 5)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuInputUVP = NO;
//					else if (bitIndex == 6)
//						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuInputOVP = NO;
//				}
//					break;
//				}
//			}
		}
	}
}

//=================================
// Callback Function
//=================================
// 0x04: PSU_RCmd_ModuleStatus
void GetStatusCallback(byte group, byte SN, byte temp, int alarm)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if(ShmPsuData->Work_Step != Get_PSU_LOCATION)
    {
        return;
    }

    if(group >= _maxGroupCount || SN >= MAX_MODULE_PER_GROUP)
    {
        return;
    }

    ShmPsuPosition->PsuAddressInfo[SN].Address = SN;
    ShmPsuPosition->PsuAddressInfo[SN].GroupNo = group;

    if(!ShmPsuPosition->PsuAddressInfo[SN].CheckIn)
    {
        ShmPsuPosition->PsuAddressInfo[SN].CheckIn = true;
        ShmPsuPosition->TotalPsuQuantity++;
        //LOG_INFO("SN = %d At Group %02X", SN, group);
    }

    if(ShmPsuPosition->TotalPsuQuantity == ShmPsuData->SystemPresentPsuQuantity)
    {
        byte group = 0, quantity = 0;

        if(!ShmPsuPosition->PsuLocationInit)
        {
            memset(ShmPsuPosition->GroupLocationInfo, 0x00, sizeof(ShmPsuPosition->GroupLocationInfo));

            for(int index = 0; index < MAX_PSU_MODULE_QUANTITY; index++)
            {
                if(ShmPsuPosition->PsuAddressInfo[index].CheckIn)
                {
                    group = ShmPsuPosition->PsuAddressInfo[index].GroupNo;
                    quantity = ShmPsuPosition->GroupLocationInfo[group].GroupPsuQuantity;
                    ShmPsuPosition->PsuAddressInfo[index].GIndex = quantity;
                    ShmPsuPosition->GroupLocationInfo[group].PsuSN[quantity] = ShmPsuPosition->PsuAddressInfo[index].Address;
                    ShmPsuPosition->GroupLocationInfo[group].GroupPsuQuantity++;
                    //LOG_INFO("Psu %d Assign To Group %02X At %d", index, group, ShmPsuPosition->PsuAddressInfo[index].GIndex);
                }
            }

            bool match = true;
            for(int index = 0; index < _maxGroupCount; index++)
            {
                if(ShmPsuPosition->GroupLocationInfo[index].GroupPsuQuantity != ShmPsuData->PsuGroup[index].GroupPresentPsuQuantity)
                {
                    match = false;
                }
            }

            if(match)
            {
                ShmPsuPosition->PsuLocationInit = true;
            }
            else
            {
                // try to re-initial psu location
                ShmPsuPosition->ReInitPsuLocation = true;
            }
        }
        else
        {
            ShmPsuData->PsuGroup[group].PsuModule[ShmPsuPosition->PsuAddressInfo[SN].GIndex].CriticalTemp1 = temp;
        }
    }
}

// 0x02: PSU_RCmd_SysModuleCount
void GetModuleCountCallback(byte group, byte count)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

	if(group == SYSTEM_CMD)
	{
		ShmPsuData->SystemPresentPsuQuantity = count;
	}
	else
	{
	    if(group < _maxGroupCount)
	    {
	        ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity = count;
	        ShmPsuGrouping->GroupCollection[group].GunPsuQuantity = count;
	    }
	}
}

void UpdateGunAvailableCapability(unsigned char group)
{
    int _availableCurrent = 0, _availablePower = 0, _realPower = 0;
    unsigned char master = 0;

    master = ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup;

    // calculate output group capability
    if(master == 0)
    {
        chargingInfo[group]->AvailableChargingCurrent = ShmPsuData->PsuGroup[group].GroupAvailableCurrent;
        chargingInfo[group]->AvailableChargingPower = ShmPsuData->PsuGroup[group].GroupAvailablePower;
        chargingInfo[group]->RealRatingPower = ShmPsuData->PsuGroup[group].GroupRealOutputPower * 10;
    }
    else
    {
        if(ShmPsuGrouping->GroupCollection[master - 1].Role == _GROLE_MASTER)
        {
            _availableCurrent = ShmPsuData->PsuGroup[master - 1].GroupAvailableCurrent;
            _availablePower = ShmPsuData->PsuGroup[master - 1].GroupAvailablePower;
            _realPower = ShmPsuData->PsuGroup[master - 1].GroupRealOutputPower * 10;

            for(byte i = 0; i < ShmPsuGrouping->GroupCollection[master - 1].Partner.Quantity; i++)
            {
                byte slave = ShmPsuGrouping->GroupCollection[master - 1].Partner.Member[i];

                if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE ||
                    ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_PREPARE_SWITCH_OFF)
                {
                    _availableCurrent += ShmPsuData->PsuGroup[slave].GroupAvailableCurrent;
                    _availablePower += ShmPsuData->PsuGroup[slave].GroupAvailablePower;
                    _realPower += ShmPsuData->PsuGroup[slave].GroupRealOutputPower * 10;
                }
            }

            if(ShmPsuGrouping->GroupCollection[master - 1].GroupCtrl.bits.DeratingConfirmed)
            {
                chargingInfo[master - 1]->AvailableChargingCurrent = ShmPsuGrouping->GroupCollection[master - 1].ReAssignAvailableCurrent;
            }
            else
            {
                chargingInfo[master - 1]->AvailableChargingCurrent = _availableCurrent;
            }
            chargingInfo[master - 1]->AvailableChargingPower = _availablePower;
            chargingInfo[master - 1]->RealRatingPower = _realPower;

//            if((master - 1) != group)
//            {
//                chargingInfo[group]->AvailableChargingCurrent = 0;;
//                chargingInfo[group]->AvailableChargingPower = 0;
//                chargingInfo[group]->RealRatingPower = 0;
//            }
        }
    }
}

void UpdateSystemAvailable(void)
{
    int _sysCurrent = 0, _sysPower = 0;

    // summation of system current & power
    for(byte i = 0; i < _maxGroupCount; i++)
    {
        _sysCurrent += ShmPsuData->PsuGroup[i].GroupAvailableCurrent;
        _sysPower += ShmPsuData->PsuGroup[i].GroupAvailablePower;
    }
    ShmPsuData->SystemAvailableCurrent = _sysCurrent;
    ShmPsuData->SystemAvailablePower = _sysPower;
}

// maxVol, minVol unit: 0.1V
// maxCur unit: 0.1A
// totalPow unit: 0.01kW
// 0x0A: PSU_RCmd_ModuleCapability
void GetAvailableCapCallback(byte address, short maxVol, short minVol, short maxCur, short totalPow)
{
    int _groupCurrent = 0, _groupPower = 0;

    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if (ShmPsuData->Work_Step < GET_SYS_CAP || address >= ShmPsuData->SystemPresentPsuQuantity ||
        !ShmPsuPosition->PsuLocationInit)
    {
        return;
    }

    byte master = 0;
    int group = FindTargetGroup(address);
    int gIndex = FindGroupIndex(address);

    if(group < 0 || gIndex < 0)
    {
        return;
    }

    // calculate psu module available power
    ShmPsuData->PsuGroup[group].PsuModule[gIndex].AvailablePower = totalPow;
    //if(ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage >= PSU_MIN_VOL)
    if(ShmPsuGrouping->GroupOutput[group].GTargetVoltage >= PSU_MIN_VOL)
    {
        ShmPsuData->PsuGroup[group].PsuModule[gIndex].AvailableCurrent =
            ((ShmPsuData->PsuGroup[group].PsuModule[gIndex].AvailablePower * 100) * 10) / (ShmPsuGrouping->GroupOutput[group].GTargetVoltage / 10);
    }
    else
    {
        ShmPsuData->PsuGroup[group].PsuModule[gIndex].AvailableCurrent = maxCur > PSU_MAX_CUR ? PSU_MAX_CUR : maxCur;
    }

    // summation of psu group current & power
    for(byte i = 0; i < ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity; i++)
    {
        _groupCurrent += ShmPsuData->PsuGroup[group].PsuModule[i].AvailableCurrent;
        _groupPower += ShmPsuData->PsuGroup[group].PsuModule[i].AvailablePower;
    }

    if(ShmPsuData->PsuGroup[group].StableIAvailableCurrent != 0)
    {
        ShmPsuData->PsuGroup[group].GroupAvailableCurrent = ShmPsuData->PsuGroup[group].StableIAvailableCurrent;
    }
    else
    {
        if(ShmPsuData->PsuGroup[group].GroupRealOutputPower != 0 &&
            ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage >= PSU_MIN_VOL)
        {
            ShmPsuData->PsuGroup[group].GroupAvailableCurrent = ((ShmPsuData->PsuGroup[group].GroupRealOutputPower * 1000) * 10) / (ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage / 10);
        }
        else
        {
            ShmPsuData->PsuGroup[group].GroupAvailableCurrent = _groupCurrent;
        }
    }
    ShmPsuData->PsuGroup[group].GroupAvailablePower = _groupPower;

    // update MaximumChargingVoltage
    master = ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup;
    if(master == 0)
    {
        chargingInfo[group]->MaximumChargingVoltage = maxVol;
    }
    else
    {
        if(ShmPsuGrouping->GroupCollection[master - 1].Role == _GROLE_MASTER)
        {
            chargingInfo[master - 1]->MaximumChargingVoltage = maxVol;

//            if((master - 1) != group)
//            {
//                chargingInfo[group]->MaximumChargingVoltage = 0;
//            }
        }
    }

    UpdateGunAvailableCapability(group);

    UpdateSystemAvailable();
    //LOG_INFO("address = %d, maxVol = %d, minVol = %d, maxCur = %d, totalPow = %d", address, maxVol, minVol, maxCur, totalPow);
}

// 0x07: PSU_RCmd_ModuleVersion
void GetFwCallback(byte address, short dcSwVer, short pfcSwVer, short hwVer)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if (ShmPsuData->Work_Step != Get_PSU_VERSION || address >= ShmPsuData->SystemPresentPsuQuantity ||
        !ShmPsuPosition->PsuLocationInit)
    {
        return;
    }

    int group = FindTargetGroup(address);
    int gIndex = FindGroupIndex(address);

    if(group < 0 || gIndex < 0)
    {
        return;
    }

    sprintf((char *)ShmPsuData->PsuVersion[address].FwPrimaryVersion, "DC %d.%02d", (dcSwVer & 0xFF00) >> 8, dcSwVer & 0xFF);
    sprintf((char *)ShmPsuData->PsuVersion[address].FwSecondVersion, "PFC %d.%02d", (pfcSwVer & 0xFF00) >> 8, pfcSwVer & 0xFF);
    sprintf((char *)ShmPsuData->PsuGroup[group].PsuModule[gIndex].FwVersion, "DC %d.%02d", (dcSwVer & 0xFF00) >> 8, dcSwVer & 0xFF);
    //LOG_INFO("Psu %d %s %s", address, ShmPsuData->PsuVersion[address].FwPrimaryVersion, ShmPsuData->PsuVersion[address].FwSecondVersion);
}

// no using -- GetInputVoltageCallback
void GetInputVoltageCallback(byte address, unsigned short vol1, unsigned short vol2, unsigned short vol3)
{
}
// no using -- GetInputVoltageCallback End

// no using -- GetPresentOutputCallback
void GetPresentOutputCallback(byte group, unsigned short outVol, unsigned short outCur)
{
}
// no using -- GetPresentOutputCallback End

// type 1: FAN_SPEED_CMD
// type 2: TEMP_DC_CMD
// type 3: TEMP_PFC_CMD
// 0x0E: PSU_RCmd_ModuleMiscInfo
void GetMisCallback(byte address, unsigned int value, byte type)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if (ShmPsuData->Work_Step < GET_SYS_CAP || address >= ShmPsuData->SystemPresentPsuQuantity ||
        !ShmPsuPosition->PsuLocationInit)
    {
        return;
    }

    int group = FindTargetGroup(address);
    int gIndex = FindGroupIndex(address);

    if(group < 0 || gIndex < 0)
    {
        return;
    }

    if (type == 1)
    {
        ShmPsuData->PsuGroup[group].PsuModule[gIndex].FanSpeed_1 = value;
        ShmPsuData->PsuGroup[group].PsuModule[gIndex].FanSpeed_2 = value;
        ShmPsuData->PsuGroup[group].PsuModule[gIndex].FanSpeed_3 = value;
        ShmPsuData->PsuGroup[group].PsuModule[gIndex].FanSpeed_4 = value;
    }
    else if (type == 2)
    {
        //ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp1 = value;
        //ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp2 = value;
        //ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp3 = value;
        ShmPsuData->PsuGroup[group].PsuModule[gIndex].ExletTemp = value;
    }
    else if (type == 3)
    {
        //printf("PFC - group = %d, index = %d, value = %d \n", group, address, value);
        ShmPsuData->PsuGroup[group].PsuModule[gIndex].InletTemp = value;
    }
}

// Iavail unit: 0.1A
// Vext unit: 0.1V
// 0x0C: PSU_RCmd_ModuleIAvailable
// 0x02CCF0XX
void GetIavailableCallback(byte address, unsigned short Iavail, unsigned short Vext)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if (ShmPsuData->Work_Step < GET_SYS_CAP || address >= ShmPsuData->SystemPresentPsuQuantity ||
        !ShmPsuPosition->PsuLocationInit)
    {
        return;
    }

    byte master = 0;
    unsigned short diffIAvailable = 0;
    int totalCurrent = 0;
    int group = FindTargetGroup(address);
    int gIndex = FindGroupIndex(address);

    if(group < 0 || gIndex < 0)
    {
        return;
    }

    ShmPsuData->PsuGroup[group].PsuModule[gIndex].IAvailableCurrent = Iavail;

    // summation of psu group i available current
    for (byte i = 0; i < ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity; i++)
    {
        totalCurrent += ShmPsuData->PsuGroup[group].PsuModule[i].IAvailableCurrent;
    }
    ShmPsuData->PsuGroup[group].TotalIAvailableCurrent = totalCurrent;

    diffIAvailable = totalCurrent >= ShmPsuData->PsuGroup[group].TempIAvailableCurrent ?
        totalCurrent - ShmPsuData->PsuGroup[group].TempIAvailableCurrent : ShmPsuData->PsuGroup[group].TempIAvailableCurrent - totalCurrent;

    if(diffIAvailable > STABLE_CURRENT_TOLERANCE)
    {
        ShmPsuData->PsuGroup[group].StableCurrentCounter = 0;
        ShmPsuData->PsuGroup[group].StableIAvailableCurrent = 0;
    }
    ShmPsuData->PsuGroup[group].TempIAvailableCurrent = ShmPsuData->PsuGroup[group].TotalIAvailableCurrent;
    ShmPsuData->PsuGroup[group].StableCurrentCounter++;

    if(ShmPsuData->PsuGroup[group].StableCurrentCounter >= MAX_STABLE_COUNT)
    {
        // get stable StableIAvailableCurrent
        ShmPsuData->PsuGroup[group].StableIAvailableCurrent = ShmPsuData->PsuGroup[group].TotalIAvailableCurrent;

        // get stable GroupRealOutputPower
        ShmPsuData->PsuGroup[group].GroupRealOutputPower = (ShmPsuData->PsuGroup[group].StableIAvailableCurrent * ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage) / 100 / 1000;

        ShmPsuData->PsuGroup[group].StableCurrentCounter = 0;
    }

    master = ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup;

    if(master == 0)
    {
        // unit: 0.1A
        chargingInfo[group]->DeratingChargingCurrent = ShmPsuData->PsuGroup[group].StableIAvailableCurrent;
        chargingInfo[group]->DeratingChargingPower = (chargingInfo[group]->DeratingChargingCurrent * chargingInfo[group]->PresentChargingVoltage) / 10 / 100;
    }
    else
    {
        // calculate DeratingChargingCurrent of master group
        totalCurrent = ShmPsuData->PsuGroup[master - 1].StableIAvailableCurrent;

        for(byte i = 0; i < ShmPsuGrouping->GroupCollection[master - 1].Partner.Quantity; i++)
        {
            byte slave = ShmPsuGrouping->GroupCollection[master - 1].Partner.Member[i];

            if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE)
            {
                totalCurrent += ShmPsuData->PsuGroup[slave].StableIAvailableCurrent;
            }
        }
        chargingInfo[master - 1]->DeratingChargingCurrent = totalCurrent;
        chargingInfo[master - 1]->DeratingChargingPower = (chargingInfo[master - 1]->DeratingChargingCurrent * chargingInfo[master - 1]->PresentChargingVoltage) / 10 / 100;

        if((master - 1) != group)
        {
            chargingInfo[group]->DeratingChargingCurrent = 0;
            chargingInfo[group]->DeratingChargingPower = 0;
        }
    }
}

// outVol unit: 1V
// outCur unit: 1A
// 0x01: PSU_RCmd_SysOutputVolCur_F
void GetPresentOutputFCallback(byte group, float outVol, float outCur)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if (ShmPsuData->Work_Step < GET_SYS_CAP || group >= _maxGroupCount ||
        !ShmPsuPosition->PsuLocationInit)
    {
        return;
    }

    byte master = 0;
    unsigned short pVoltage = 0, pCurrent = 0;
    unsigned short gVoltage = 0, gCurrent = 0;

    pVoltage = isinf(outVol) == 0 ? (unsigned short)(outVol * 10) : 0;
    pCurrent = isinf(outCur) == 0 ? (unsigned short)(outCur * 10) : 0;
    ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage = pVoltage;
    ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent = pCurrent;
    ShmPsuData->PsuGroup[group].GroupPresentOutputPower = (pVoltage * pCurrent) / 100 / 100;

    master = ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup;

    if(master == 0)
    {
        // calculate PresentChargingVoltage and PresentChargingCurrent of self group
        chargingInfo[group]->PresentChargingVoltage = (float)ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage / 10;
        chargingInfo[group]->PresentChargingCurrent = (float)ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent / 10;
    }
    else
    {
        // calculate PresentChargingVoltage and PresentChargingCurrent of master group
        gVoltage = ShmPsuData->PsuGroup[master - 1].GroupPresentOutputVoltage;
        gCurrent = ShmPsuData->PsuGroup[master - 1].GroupPresentOutputCurrent;

        for(byte i = 0; i < ShmPsuGrouping->GroupCollection[master - 1].Partner.Quantity; i++)
        {
            byte slave = ShmPsuGrouping->GroupCollection[master - 1].Partner.Member[i];

            if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE ||
                ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_PREPARE_SWITCH_OFF ||
                ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE_POWER_OFF)
            {
                if(ShmPsuData->PsuGroup[slave].GroupPresentOutputVoltage > gVoltage)
                {
                    gVoltage = ShmPsuData->PsuGroup[slave].GroupPresentOutputVoltage;
                }

                gCurrent += ShmPsuData->PsuGroup[slave].GroupPresentOutputCurrent;
            }
        }

        chargingInfo[master - 1]->PresentChargingVoltage = (float)gVoltage / 10;
        chargingInfo[master - 1]->PresentChargingCurrent = (float)gCurrent / 10;

        if((master - 1) != group)
        {
            chargingInfo[group]->PresentChargingVoltage = 0;
            chargingInfo[group]->PresentChargingCurrent = 0;
        }
    }
}

//==========================================
// 特規用指令
//==========================================

// 0x1901: Nexton_PSU_DcOutputValue
void GetOutputAndTempCallback(byte address, unsigned short outputVol_s,
		unsigned short outputCur_s, unsigned short outputPower, unsigned char Temperature)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if (ShmPsuData->Work_Step < GET_SYS_CAP || address >= ShmPsuData->SystemPresentPsuQuantity ||
        !ShmPsuPosition->PsuLocationInit)
    {
        return;
    }

    int group = FindTargetGroup(address);
    int gIndex = FindGroupIndex(address);

    if(group < 0 || gIndex < 0)
    {
        return;
    }

    //ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp1 = Temperature;
    ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp2 = Temperature;
    ShmPsuData->PsuGroup[group].PsuModule[gIndex].CriticalTemp3 = Temperature;
}

// 0x1902: Nexton_PSU_StatusEvent
void GetModuleStatusCallback(byte address, unsigned char isErr, unsigned char status,
		unsigned char err1, unsigned char err2, unsigned char err3, unsigned char err4)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if (ShmPsuData->Work_Step < GET_SYS_CAP || address >= ShmPsuData->SystemPresentPsuQuantity ||
        !ShmPsuPosition->PsuLocationInit)
    {
        return;
    }

    int group = FindTargetGroup(address);
    int gIndex = FindGroupIndex(address);

    if(group < 0 || gIndex < 0)
    {
        return;
    }

    int alarm = (err4 << 24) | (err3 << 16) | (err2 << 8) | err1;

    ShmPsuData->PsuGroup[group].PsuModule[gIndex].AlarmCode = alarm;
    AbnormalStopAnalysis(group, alarm);

	if(isErr)
	{
	    // 012267
	    //ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm = YES;
	    ShmPsuData->PsuGroup[group].GroupErrorFlag.bits.PsuFailure = true;
	}
}

// 0x1903: Nexton_PSU_AcInputValue
void GetModuleInputCallback(byte address, unsigned short inputR,
		unsigned short inputS, unsigned short inputT)
{
    ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt++;

    if (ShmPsuData->Work_Step < GET_SYS_CAP || address >= ShmPsuData->SystemPresentPsuQuantity ||
        !ShmPsuPosition->PsuLocationInit)
    {
        return;
    }

    int group = FindTargetGroup(address);
    int gIndex = FindGroupIndex(address);

    if(group < 0 || gIndex < 0)
    {
        return;
    }

    ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL1 = inputR;
    ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL2 = inputS;
    ShmPsuData->PsuGroup[group].PsuModule[gIndex].InputVoltageL3 = inputT;
}
//==========================================
// Init all share memory
//==========================================
int InitShareMemory()
{
	int result = PASS;
	int MeterSMId;

	//creat ShmSysConfigAndInfo
	if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0)
    {
		#ifdef SystemLogMessage
		LOG_ERROR("shmget ShmSysConfigAndInfo NG %d");
		#endif
		result = FAIL;
	}
    else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
    	#ifdef SystemLogMessage
    	LOG_ERROR("shmat ShmSysConfigAndInfo NG");
		#endif
    	result = FAIL;
   	 }
    else
    {}

   	//creat ShmStatusCodeData
   	if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
    {
		#ifdef SystemLogMessage
   		LOG_ERROR("shmget ShmStatusCodeData NG");
		#endif
   		result = FAIL;
	}
    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
    	#ifdef SystemLogMessage
    	LOG_ERROR("shmat ShmStatusCodeData NG");
		#endif
    	result = FAIL;
   	}
    else
    {}

   	//creat ShmPsuData
	if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData),  0777)) < 0)
	{
		#ifdef SystemLogMessage
		LOG_ERROR("shmget ShmPsuData NG");
		#endif
		result = FAIL;
	}
	else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		LOG_ERROR("shmat ShmPsuData NG");
		#endif
		result = FAIL;
	}

    if ((MeterSMId = shmget(SM_ChargerInfoKey, sizeof(ChargerInfoData), 0777)) < 0)
    {
        #ifdef SystemLogMessage
        LOG_ERROR("shmat ChargerInfoData NG");
        #endif
        result = FAIL;
    }
    else if ((ShmChargerInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
        LOG_ERROR("shmat ChargerInfoData NG");
        #endif
        result = FAIL;
    }
    if(result == PASS)
    {
        ShmPsuPosition = &ShmChargerInfo->PsuPosition;
        ShmPsuGrouping = &ShmChargerInfo->PsuGrouping;
    }

    return result;
}

//================================================
// Main process
//================================================
void InitialPsuData()
{
	ShmPsuData->SystemPresentPsuQuantity = 0;
	ShmPsuData->SystemAvailablePower = 0;

	LOG_INFO("************ psu Group = %d", ShmPsuData->GroupCount);
	for (byte _groupCount = 0; _groupCount < ShmPsuData->GroupCount; _groupCount++)
	{
		ShmPsuData->PsuGroup[_groupCount].GroupPresentPsuQuantity = 0;
		ShmPsuData->PsuGroup[_groupCount].GroupAvailablePower = 0;
		ShmPsuData->PsuGroup[_groupCount].GroupAvailableCurrent = 0;
		ShmPsuData->PsuGroup[_groupCount].GroupErrorFlag.PsuGroupErrorValue = 0;
	}

    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFuseBurnOut = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuPfcAndDcdcCommFault = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuBusVoltageUnbalance = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuBusOverVoltage = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuBusVoltageAbnormal = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuInputOVP = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDuplicateID = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuBusUnderVoltage = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuInputPhaseLoss = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuInputUVP = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuCommunicationFail = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuSevereUnevenCurrent = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFfcSideShutDown = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFanFullSpeed = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDcSideShutDown = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuPowerLimitedState = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuTemperaturePowerLimit = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuAcPowerLimit = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDcdcEepromFault = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFanFailureAlarm = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuOutputShortCircuit = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuPfcEepromFault = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuCriticalPointOTP = NO;
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuDcdcOverVoltage = NO;
}

void Initialization()
{
	bool isPass = false;
	while(!isPass)
	{
		isPass = true;
		for (byte _index = 0; _index < _maxGroupCount; _index++)
		{
			if (!FindChargingInfoData(_index, &chargingInfo[0]))
			{
				LOG_ERROR("Module_PsuComm : FindChargingInfoData false");
				isPass = false;
				break;
			}
		}
		sleep(1);
	}

    ShmPsuData->GroupCount = _maxGroupCount;
}

void Await()
{
	usleep(CMD_DELAY_TIME);
}

void PsuReceiveRecoveryCheck(void)
{
    char *ptrSave, *ptrToken;
    int fd, psuTaskCount = 0;
    char pathBuffer[64], psuTaskPidString[64];

    system("pidof Module_PsuComm > /tmp/Module_PsuTask");

    snprintf(pathBuffer, sizeof(pathBuffer), "/tmp/Module_PsuTask");
    fd = open(pathBuffer, O_RDWR);

    if(fd < 0)
    {
        return;
    }
    if(read(fd, psuTaskPidString, 64) < 0)
    {
        return;
    }

    ptrToken = strtok_r(psuTaskPidString, " ", &ptrSave);
    while(ptrToken != NULL)
    {
        int psuPid = atoi(ptrToken);

        if(psuPid > 0)
        {
            psuTaskCount++;
        }

        ptrToken = strtok_r(NULL, " ", &ptrSave);
    }
    close(fd);

    if(psuTaskCount == 1)
    {
        LOG_INFO("************ PSU Receive Task Need Recovery ************\n");
        InitialCommunication();

        psuReceiveRecovery = true;
    }
}

void ShowGroupMember(unsigned char group)
{
    if(group < MAX_GROUP_QUANTITY)
    {
        if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
        {
            for(byte psu = 0; psu < ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity; psu++)
            {
                LOG_INFO("Group %d - Number = %d, SN = %02X", group + 1, psu,
                    ShmPsuPosition->GroupLocationInfo[group].PsuSN[psu]);
            }
        }
    }
}

void ShowPsuVersion(unsigned char group)
{
    if(group < MAX_GROUP_QUANTITY)
    {
        if(ShmPsuPosition->GroupLocationInfo[group].GroupPsuQuantity > 0)
        {
            LOG_INFO("Group %d PSU Version Info", group + 1);
            for(int i = 0; i < ShmPsuPosition->GroupLocationInfo[group].GroupPsuQuantity; i++)
            {
                int psuIndex = ShmPsuPosition->GroupLocationInfo[group].PsuSN[i];
                LOG_INFO("PSU Primary: %s, Second: %s",
                    ShmPsuData->PsuVersion[psuIndex].FwPrimaryVersion,
                    ShmPsuData->PsuVersion[psuIndex].FwSecondVersion);
            }
        }
    }
}

void ShowGroupAvailableCurrentPower(unsigned char group)
{
    if(group < MAX_GROUP_QUANTITY)
    {
        LOG_INFO("Group %d Available Current = %3d.%dA, Power = %3d.%dkW", group + 1,
            (ShmPsuData->PsuGroup[group].GroupAvailableCurrent / 10), (ShmPsuData->PsuGroup[group].GroupAvailableCurrent % 10),
            (ShmPsuData->PsuGroup[group].GroupAvailablePower / 10), (ShmPsuData->PsuGroup[group].GroupAvailablePower % 10));
    }
}

unsigned char _TempType = 0;
void PsuGroupRoutineQuery(void)
{
    for(byte group = 0; group < GENERAL_GUN_QUANTITY; group++)
    {
        if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
        {
            if (psuCmdSeq == _PSU_CMD_CAP)
            {
                // 取系統總輸出能力
                GetModuleCap(group);
            }
            else if (psuCmdSeq == _PSU_CMD_OUTPUT)
            {
                // 取各群輸出電壓電流 (float)
                GetModuleOutputF(group);
            }
            else if (psuCmdSeq == _PSU_CMD_IVAILIABLE)
            {
                // 取得模塊輸出額定電流能力
                GetModuleIavailable(group);
            }
            else if (psuCmdSeq == _PSU_CMD_TEMP)
            {
                // 取得模塊溫度
                if(_TempType == _PSU_TMP_DCDC)
                {
                    GetDcTemperature(group);
                }
                else
                {
                    GetPfcTemperature(group);
                }
            }
        }
    }

    if(psuCmdSeq == _PSU_CMD_CAP)
    {
        psuCmdSeq = _PSU_CMD_OUTPUT;
    }
    else if(psuCmdSeq == _PSU_CMD_OUTPUT)
    {
        psuCmdSeq = _PSU_CMD_IVAILIABLE;
    }
    else if(psuCmdSeq == _PSU_CMD_IVAILIABLE)
    {
        psuCmdSeq = _PSU_CMD_TEMP;

        _TempType = _TempType == _PSU_TMP_DCDC ? _PSU_TMP_PFC : _PSU_TMP_DCDC;
    }
    else
    {
        psuCmdSeq = _PSU_CMD_CAP;
    }

    Await();
}

void SetPsuGroupRole(byte group, byte role)
{
    if(group < GENERAL_GUN_QUANTITY)
    {
        ShmPsuGrouping->GroupCollection[group].Role = role;
    }
}

void SetPsuGroupToIdle(byte group)
{
    if(group < GENERAL_GUN_QUANTITY)
    {
        SetPsuGroupRole(group, _GROLE_IDLE);
        memset(&ShmPsuGrouping->GroupCollection[group].Partner, 0x00, sizeof(PsuGroupPartner));
        memset(&ShmPsuGrouping->GroupCollection[group].PossibleMember, 0x00, sizeof(PsuGroupPartner));
        ShmPsuGrouping->GroupCollection[group].TargetGroup = 0;
        ShmPsuGrouping->GroupCollection[group].ReservedTarget = 0;
        //LOG_INFO("Reset Group[%02X] To Idle", group);
    }
}

// group: self group index
void SetPsuGroupToMaster(byte group)
{
    if(group < GENERAL_GUN_QUANTITY)
    {
        SetPsuGroupRole(group, _GROLE_MASTER);
        ShmPsuGrouping->GroupCollection[group].TargetGroup = group + 1;
        //LOG_INFO("Set Group[%02X] As Master To Gun %d", group, group + 1);
    }
}

// group: self group index
// target: target group index + 1
void SetPsuGroupToSlave(byte group, byte target)
{
    if(group < GENERAL_GUN_QUANTITY && target <= GENERAL_GUN_QUANTITY)
    {
        SetPsuGroupRole(group, _GROLE_SLAVE);
        ShmPsuGrouping->GroupCollection[group].TargetGroup = target;
        ShmPsuGrouping->GroupCollection[group].ReservedTarget = 0;
        memset(&ShmPsuGrouping->GroupCollection[group].PossibleMember, 0x00, sizeof(PsuGroupPartner));
        ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.SlaveCtrlValue = 0;
        //LOG_INFO("Set Group[%02X] As Slave To Gun %d", group, target);
    }
}

// target: target group index + 1
// tPartner: set member to power off
void PrepareToPowerOff(byte target, PsuGroupPartner *tPartner)
{
    unsigned char master = 0, slave = 0;
    char strMember[64];
    bool find = false;

    sprintf(strMember, "Set Member:");

    for(int i = 0; i < tPartner->Quantity; i++)
    {
        slave = tPartner->Member[i];
        master = ShmPsuGrouping->GroupCollection[slave].TargetGroup - 1;
        SetPsuGroupRole(slave, _GROLE_PREPARE_SWITCH_OFF);
        ShmPsuGrouping->GroupCollection[slave].ReservedTarget = target;
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedDerating = true;

        char strSlave[8];
        sprintf(strSlave, " [%02X]", slave);
        strcat(strMember, strSlave);
        find = true;
    }

    if(find)
    {
        char strTemp[32];
        if(target != 0)
        {
            sprintf(strTemp, " Prepare To Change To Gun %d", target);
        }
        else
        {
            sprintf(strTemp, " Prepare To Power Of");
        }
        strcat(strMember, strTemp);
        LOG_INFO("%s", strMember);
    }
}

// target: target group index + 1
// tPartner: set member to prepare to attach on
void PrepareToExtendCapability(byte target, PsuGroupPartner *tPartner)
{
    char strMember[64];

    sprintf(strMember, "Set Member:");
    for(int i = 0; i < tPartner->Quantity; i++)
    {
        SetPsuGroupRole(tPartner->Member[i], _GROLE_PREPARE_ATTACH_ON);
        ShmPsuGrouping->GroupCollection[tPartner->Member[i]].ReservedTarget = target;

        char strSlave[8];
        sprintf(strSlave, " [%02X]", tPartner->Member[i]);
        strcat(strMember, strSlave);
    }

    if(tPartner->Quantity > 0)
    {
        char strTemp[32];
        sprintf(strTemp, " Prepare To Attach To Gun %d", target);
        strcat(strMember, strTemp);
        LOG_INFO("%s", strMember);
    }
}

void FindPsuGroupPartner(byte master, byte quantity, PsuGroupPartner *tPartner)
{
    int slave = 0, location = 0;
    PsuGroupPartner partner;

    memset(&partner, 0x00, sizeof(PsuGroupPartner));

    // search from left
    location = ShmPsuGrouping->GroupCollection[master].Location - 1;
    for(int i = location; i >= 0; i--)
    {
        if(partner.Quantity >= quantity)
        {
            break;
        }

        slave = ShmPsuGrouping->Layout[i];
        if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_IDLE ||
            (ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_WAIT_SLAVE && (ShmPsuGrouping->GroupCollection[slave].ReservedTarget - 1) == master))
        {
            partner.Member[partner.Quantity++] = slave;
        }
        else
        {
            if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE && master == (ShmPsuGrouping->GroupCollection[slave].TargetGroup - 1))
            {
                continue;
            }
            break;
        }
    }

    // search from right
    location = ShmPsuGrouping->GroupCollection[master].Location + 1;
    for(int i = location; i < ShmChargerInfo->Control.MaxConnector; i++)
    {
        if(partner.Quantity >= quantity)
        {
            break;
        }

        slave = ShmPsuGrouping->Layout[i];
        if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_IDLE ||
            (ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_WAIT_SLAVE && (ShmPsuGrouping->GroupCollection[slave].ReservedTarget - 1) == master))
        {
            partner.Member[partner.Quantity++] = slave;
        }
        else
        {
            if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE && master == (ShmPsuGrouping->GroupCollection[slave].TargetGroup - 1))
            {
                continue;
            }
            break;
        }
    }

    memcpy(tPartner, &partner, sizeof(PsuGroupPartner));
}

int GetPsuGroupAvailable(byte group)
{
    PsuGroupPartner partner;

    FindPsuGroupPartner(group, MAX_GROUP_QUANTITY, &partner);

    return partner.Quantity;
}

// return grab success or fail
// return tPartner with possible member
bool PsuGroupGrabCheck(byte group, PsuGroupPartner *tPartner)
{
    int slave = 0, target = 0, location = 0, share = 0, average = 0, total = 0;

    if(ShmPsuGrouping->GroupCollection[group].Role != _GROLE_SLAVE && ShmPsuGrouping->GroupCollection[group].Role != _GROLE_REQUEST_TO_CHARGING)
    {
        return share > 0 ? true : false;
    }

    total = ShmPsuGrouping->GroupCollection[group].Role == _GROLE_REQUEST_TO_CHARGING ? GetPsuGroupAvailable(group) + 1 : 0;

    // search from left
    location = ShmPsuGrouping->GroupCollection[group].Location - 1;
    for(int i = location; i >= 0; i--)
    {
        slave = ShmPsuGrouping->Layout[i];
        if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE &&
            (ShmPsuGrouping->GroupCollection[group].Role == _GROLE_REQUEST_TO_CHARGING ||
            ShmPsuGrouping->GroupCollection[slave].TargetGroup == ShmPsuGrouping->GroupCollection[group].TargetGroup))
        {
            target = ShmPsuGrouping->GroupCollection[slave].TargetGroup - 1;
            if((ShmPsuGrouping->GroupCollection[target].Partner.Quantity + 1) > total)
            {
                average = (ShmPsuGrouping->GroupCollection[target].Partner.Quantity + 1 + total) / 2;
                share = average > 0 ? average - 1 : 0;
            }
            break;
        }
        else
        {
            break;
        }
    }

    if(share == 0)
    {
        // search from right
        location = ShmPsuGrouping->GroupCollection[group].Location + 1;
        for(int i = location; i < ShmChargerInfo->Control.MaxConnector; i++)
        {
            slave = ShmPsuGrouping->Layout[i];
            if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE &&
                (ShmPsuGrouping->GroupCollection[group].Role == _GROLE_REQUEST_TO_CHARGING ||
                ShmPsuGrouping->GroupCollection[slave].TargetGroup == ShmPsuGrouping->GroupCollection[group].TargetGroup))
            {
                target = ShmPsuGrouping->GroupCollection[slave].TargetGroup - 1;
                if((ShmPsuGrouping->GroupCollection[target].Partner.Quantity + 1) > total)
                {
                    average = (ShmPsuGrouping->GroupCollection[target].Partner.Quantity + 1 + total) / 2;
                    share = average > 0 ? average - 1 : 0;
                }
                break;
            }
            else
            {
                break;
            }
        }
    }

    tPartner->Quantity = share;
    tPartner->Member[0] = share > 0 ? slave : 0;

    return share > 0 ? true : false;
}

// return tPartner with possible member when group power off
void PsuGroupPowerOffCheck(byte group, PsuGroupPartner *tPartner)
{
    int master = 0, quantity = 0, location = 0;
    memset(tPartner, 0x00, sizeof(PsuGroupPartner));

    if(ShmPsuGrouping->GroupCollection[group].Role != _GROLE_SLAVE)
    {
        return;
    }

    master = ShmPsuGrouping->GroupCollection[group].TargetGroup - 1;
    quantity = ShmPsuGrouping->GroupCollection[master].Partner.Quantity;

    for(int i = 0; i < quantity; i++)
    {
        if(tPartner->Quantity == 0)
        {
            if(group == ShmPsuGrouping->GroupCollection[master].Partner.Member[i])
            {
                location = i;
                tPartner->Member[tPartner->Quantity] = group;
                tPartner->Quantity++;
            }
        }
        else
        {
            // find other group in the same direction
            if(ShmPsuGrouping->Location[ShmPsuGrouping->GroupCollection[master].Partner.Member[location]] < ShmPsuGrouping->Location[master])
            {
                if(ShmPsuGrouping->Location[ShmPsuGrouping->GroupCollection[master].Partner.Member[i]] < ShmPsuGrouping->Location[master])
                {
                    tPartner->Member[tPartner->Quantity] = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
                    tPartner->Quantity++;
                    //printf("\r\n Find Other Group %02X In The Same Direction", ShmPsuGrouping->GroupCollection[master].Partner.Member[i]);
                }
            }
            if(ShmPsuGrouping->Location[ShmPsuGrouping->GroupCollection[master].Partner.Member[location]] > ShmPsuGrouping->Location[master])
            {
                if(ShmPsuGrouping->Location[ShmPsuGrouping->GroupCollection[master].Partner.Member[i]] > ShmPsuGrouping->Location[master])
                {
                    tPartner->Member[tPartner->Quantity] = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
                    tPartner->Quantity++;
                    //printf("\r\n Find Other Group %02X In The Same Direction", ShmPsuGrouping->GroupCollection[master].Partner.Member[i]);
                }
            }
        }
    }
}

// group: group index, target: target index
// master: master group index
void AddMember(byte group, byte master)
{
    if(group < GENERAL_GUN_QUANTITY && master < GENERAL_GUN_QUANTITY)
    {
        if(ShmPsuGrouping->GroupCollection[master].Role != _GROLE_MASTER &&
            ShmPsuGrouping->GroupCollection[master].Role != _GROLE_REQUEST_TO_CHARGING)
        {
            return;
        }
        if(ShmPsuGrouping->GroupCollection[group].Role != _GROLE_IDLE &&
            ShmPsuGrouping->GroupCollection[group].Role != _GROLE_WAIT_SLAVE &&
            ShmPsuGrouping->GroupCollection[group].Role != _GROLE_PRECHARGE_READY)
        {
            return;
        }

        SetPsuGroupToSlave(group, master + 1);
        ShmPsuGrouping->GroupCollection[master].Partner.Member[ShmPsuGrouping->GroupCollection[master].Partner.Quantity++] = group;
        if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
        {
            ShmPsuGrouping->GroupCollection[master].Partner.RealQuantity++;
            ShmPsuGrouping->GroupCollection[master].GunPsuQuantity += ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity;
        }
        //printf("\r\n Add Group %02X To Gun %d (Quantity %d), Set Parallel Relay %d On", group, target + 1, ShmPsuGrouping->GroupCollection[target].Partner.Quantity, ParallelConfig);
    }
}

// master: master group index
void AddAvailableMember(unsigned char master)
{
    PsuGroupPartner partner;
    char strMember[64];

    FindPsuGroupPartner(master, MAX_GROUP_QUANTITY, &partner);

    sprintf(strMember, "Gun %d Add Available Member:", master + 1);
    for(int i = 0; i < partner.Quantity; i++)
    {
        AddMember(partner.Member[i], master);

        char strSlave[8];
        sprintf(strSlave, " [%02X]", partner.Member[i]);
        strcat(strMember, strSlave);
    }

    if(partner.Quantity > 0)
    {
        LOG_INFO("%s", strMember);
    }
}

// master: master group index
// slave: slave group index
void RemoveMember(unsigned char master, unsigned char slave)
{
    bool find = false;
    int location = 0;
    unsigned char other = 0;

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        if(slave == ShmPsuGrouping->GroupCollection[master].Partner.Member[i])
        {
            ShmPsuGrouping->GroupCollection[master].Partner.Member[i] = 0;
            location = i;
            find = true;
            break;
        }
    }
    if(find)
    {
        for(int i = location + 1; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            other = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
            ShmPsuGrouping->GroupCollection[master].Partner.Member[i] = 0;
            ShmPsuGrouping->GroupCollection[master].Partner.Member[i - 1] = other;
        }
        ShmPsuGrouping->GroupCollection[master].Partner.Quantity--;
        if(ShmPsuData->PsuGroup[slave].GroupPresentPsuQuantity > 0)
        {
            ShmPsuGrouping->GroupCollection[master].Partner.RealQuantity--;
            ShmPsuGrouping->GroupCollection[master].GunPsuQuantity -= ShmPsuData->PsuGroup[slave].GroupPresentPsuQuantity;
        }
    }
}

// master: master group index
void RemoveNonGroupMember(unsigned char master)
{
    unsigned char slave = 0;
    char strMember[64];
    PsuGroupPartner partner;
    bool find = false;

    if(ShmPsuGrouping->GroupCollection[master].Role == _GROLE_MASTER)
    {
        sprintf(strMember, "Gun %d Remove Member:", master + 1);

        memcpy(&partner, &ShmPsuGrouping->GroupCollection[master].Partner, sizeof(PsuGroupPartner));
        for(int i = 0; i < partner.Quantity; i++)
        {
            slave = partner.Member[i];

            if(ShmPsuGrouping->GroupCollection[slave].Role != _GROLE_SLAVE)
            {
                RemoveMember(master, slave);
                if(ShmPsuGrouping->GroupCollection[slave].ReservedTarget == 0)
                {
                    SetPsuGroupToIdle(slave);
                }
                else
                {
                    SetPsuGroupRole(slave, _GROLE_WAIT_SLAVE);
                }

                char strSlave[8];
                sprintf(strSlave, " [%02X]", slave);
                strcat(strMember, strSlave);
                find = true;
            }
        }

        if(find)
        {
            LOG_INFO("%s", strMember);
        }
    }
}

void SetPsuGroupPowerOnOff(unsigned char group, unsigned char power_on_off)
{
    if(group < CONNECTOR_QUANTITY)
    {
        enum PSU_POWER_CMD power_cmd = power_on_off == PSU_POWER_ON ? PSU_POWER_ON : PSU_POWER_OFF;
        enum PSU_FLASH_CMD led_cmd = power_on_off == PSU_POWER_ON ? PSU_FLASH_ON : PSU_FLASH_NORMAL;

        if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
        {
#if ONE_MODULE_OUTPUT
            // for safety test (inrush current)
            if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.InPrechargeMode)
            {
                SinglePsuPower(ShmPsuPosition->GroupLocationInfo[group].PsuSN[0], power_cmd);
            }
            else
            {
                SwitchPower(group, power_cmd);
            }
#else
            SwitchPower(group, power_cmd);
#endif
            Await();
            FlashLed(group, led_cmd);
            Await();
        }
        isStartOutputSwitch[group] = power_on_off == PSU_POWER_ON ? true : false;
    }
}

// master: master group index
unsigned short GetPresentTargetCurrent(unsigned char master, unsigned char role_condition)
{
    unsigned char slave = 0;
    unsigned short current = 0;

    current = ShmPsuGrouping->GroupOutput[master].GTargetCurrent;
    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
        if(role_condition == _GROLE_MASTER || ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE)
        {
            current += ShmPsuGrouping->GroupOutput[slave].GTargetCurrent;
        }
    }
    return current;
}

// group: group index
int GetPsuModuleQuantity(unsigned char group)
{
    int quantity = 0;
    unsigned char slave = 0;

    quantity = ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity;
    for(int i = 0; i < ShmPsuGrouping->GroupCollection[group].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[group].Partner.Member[i];
        quantity += ShmPsuData->PsuGroup[slave].GroupPresentPsuQuantity;
    }

    return quantity;
}

// group: group index
bool IsAvailableGroup(unsigned char group)
{
    return ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0 ? true : false;
}

// master: master group index
int GetMasterAvailableGroup(unsigned char master)
{
    int quantity = 0;
    unsigned char slave = 0;

    quantity = IsAvailableGroup(master) ? quantity + 1 : quantity;
    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
        quantity = IsAvailableGroup(slave) ? quantity + 1 : quantity;
    }

    return quantity;
}

// group: group index
void UpdateGunLoading(unsigned char group)
{
    if(ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup != 0 &&
            group == ShmChargerInfo->PsuGrouping.GroupCollection[group].TargetGroup - 1)
    {
        unsigned short TargetCurrent = (int)(chargingInfo[group]->EvBatterytargetCurrent * 10);

        ShmPsuGrouping->GroupCollection[group].GunLoading = chargingInfo[group]->AvailableChargingCurrent != 0 ?
            (TargetCurrent * 10000 / (int)chargingInfo[group]->AvailableChargingCurrent) : 0;
    }
    else
    {
        ShmPsuGrouping->GroupCollection[group].GunLoading = 0;
    }
}

// group: group index
void UpdatePsuGroupLoading(unsigned char group)
{
    ShmPsuGrouping->GroupOutput[group].OutputLoading = ShmPsuData->PsuGroup[group].GroupAvailableCurrent != 0 ?
        (ShmPsuGrouping->GroupOutput[group].GTargetCurrent * 10000 / ShmPsuData->PsuGroup[group].GroupAvailableCurrent) : 0;
}

// master: master group index
void UpdateMasterPsuGroupLoading(unsigned char master)
{
    unsigned char slave = 0;

    UpdatePsuGroupLoading(master);

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
        UpdatePsuGroupLoading(slave);
    }
}

void PsuGroupIncreaseCurrent(unsigned char group, unsigned short needIncrease, unsigned short *realIncreaseCurrent)
{
    unsigned short increase = needIncrease;
    if((ShmPsuGrouping->GroupOutput[group].GTargetCurrent + increase) <= ShmPsuData->PsuGroup[group].GroupAvailableCurrent)
    {
        ShmPsuGrouping->GroupOutput[group].GTargetCurrent += increase;
    }
    else
    {
        increase = ShmPsuData->PsuGroup[group].GroupAvailableCurrent - ShmPsuGrouping->GroupOutput[group].GTargetCurrent;
        ShmPsuGrouping->GroupOutput[group].GTargetCurrent = ShmPsuData->PsuGroup[group].GroupAvailableCurrent;
    }
    *realIncreaseCurrent += increase;
}

void PsuGroupDecreaseCurrent(unsigned char group, unsigned short needDecrease, unsigned short *realDecreaseCurrent)
{
    unsigned short decrease = needDecrease;
    if(ShmPsuGrouping->GroupOutput[group].GTargetCurrent >= (decrease + ZERO_CURRENT))
    {
        ShmPsuGrouping->GroupOutput[group].GTargetCurrent -= decrease;
    }
    else
    {
        decrease = ShmPsuGrouping->GroupOutput[group].GTargetCurrent - ZERO_CURRENT;
        ShmPsuGrouping->GroupOutput[group].GTargetCurrent = ZERO_CURRENT;
    }
    *realDecreaseCurrent += decrease;
}

void IncreaseCurrentByGunLoading(unsigned char group, unsigned short loading, unsigned short *realIncrease, unsigned short MaxIncrease)
{
    unsigned short target = 0, need = 0;

    if(*realIncrease >= MaxIncrease)
    {
        return;
    }

    target = (loading * ShmPsuData->PsuGroup[group].GroupAvailableCurrent) / 10000;
    need = target >= ShmPsuGrouping->GroupOutput[group].GTargetCurrent ?
        (target - ShmPsuGrouping->GroupOutput[group].GTargetCurrent) : 0;

    need = need > (MaxIncrease - *realIncrease) ? (MaxIncrease - *realIncrease) : need;

    //LOG_INFO("Group [%02X] Target Current %d.%d A, Increase Current: %d.%d A",
    //    group, (target / 10), (target % 10), (need / 10), (need % 10));
    if(need > 0)
    {
        PsuGroupIncreaseCurrent(group, need, realIncrease);
    }
}

void DecreaseCurrentByGunLoading(unsigned char group, unsigned short loading, unsigned short *realDecrease, unsigned short MaxDecrease)
{
    unsigned short target = 0, need = 0;

    if(*realDecrease >= MaxDecrease)
    {
        return;
    }

    target = (loading * ShmPsuData->PsuGroup[group].GroupAvailableCurrent) / 10000;
    need = ShmPsuGrouping->GroupOutput[group].GTargetCurrent >= target ?
        (ShmPsuGrouping->GroupOutput[group].GTargetCurrent - target) : 0;

    need = need > (MaxDecrease - *realDecrease) ? (MaxDecrease - *realDecrease) : need;

    //LOG_INFO("Group [%02X] Target Current %d.%d A, Decrease Current: %d.%d A",
    //    group, (target / 10), (target % 10), (need / 10), (need % 10));
    if(need > 0)
    {
        PsuGroupDecreaseCurrent(group, need, realDecrease);
    }
}

// master: master group index
void AverageIncreaseCurrent(unsigned char master, unsigned short NeedIncreaseCurrent)
{
    unsigned char availableGroup = 0, slave = 0;
    unsigned short avgGroupCurrent = 0, excessCurrent = 0, realIncrease = 0;

#if 0
    PSU_LOG("Gun %d Increase By GunLoading %d.%02d Percent",
        master + 1, (ShmPsuGrouping->GroupCollection[master].GunLoading / 100), (ShmPsuGrouping->GroupCollection[master].GunLoading % 100));
#endif
    IncreaseCurrentByGunLoading(master, ShmPsuGrouping->GroupCollection[master].GunLoading, &realIncrease, NeedIncreaseCurrent);
    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
        IncreaseCurrentByGunLoading(slave, ShmPsuGrouping->GroupCollection[master].GunLoading, &realIncrease, NeedIncreaseCurrent);
    }

    availableGroup = GetMasterAvailableGroup(master);

    if(NeedIncreaseCurrent > realIncrease && availableGroup > 0)
    {
        // increase current by group quantity
        avgGroupCurrent = (NeedIncreaseCurrent - realIncrease) / availableGroup;
#if 0
        PSU_LOG("Gun %d Increase By Group, AvgGroupCurrent %d.%d A",
            master + 1, (avgGroupCurrent / 10), (avgGroupCurrent % 10));
#endif
        PsuGroupIncreaseCurrent(master, avgGroupCurrent, &realIncrease);
        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
            PsuGroupIncreaseCurrent(slave, avgGroupCurrent, &realIncrease);
        }
    }

    if(NeedIncreaseCurrent > realIncrease)
    {
        // increase excess current to master group
        excessCurrent = NeedIncreaseCurrent - realIncrease;
#if 0
        PSU_LOG("Gun %d Increase, ExcessCurrent %d.%d A", master + 1, (excessCurrent / 10), (excessCurrent % 10));
#endif
        PsuGroupIncreaseCurrent(master, excessCurrent, &realIncrease);
    }
}

// master: master group index
void AverageDecreaseCurrent(unsigned char master, unsigned short NeedDecreaseCurrent)
{
    unsigned char availableGroup = 0, slave = 0;
    unsigned short avgGroupCurrent = 0, excessCurrent = 0, realDecrease = 0;

#if 0
    PSU_LOG("Gun %d Decrease By GunLoading %d.%02d Percent",
        master + 1, (ShmPsuGrouping->GroupCollection[master].GunLoading / 100), (ShmPsuGrouping->GroupCollection[master].GunLoading % 100));
#endif
    DecreaseCurrentByGunLoading(master, ShmPsuGrouping->GroupCollection[master].GunLoading, &realDecrease, NeedDecreaseCurrent);
    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
        DecreaseCurrentByGunLoading(slave, ShmPsuGrouping->GroupCollection[master].GunLoading, &realDecrease, NeedDecreaseCurrent);
    }

    availableGroup = GetMasterAvailableGroup(master);

    if(NeedDecreaseCurrent > realDecrease)
    {
        // decrease current by group quantity
        avgGroupCurrent = (NeedDecreaseCurrent - realDecrease) / availableGroup;
#if 0
        PSU_LOG("Gun %d Decrease By Group, AvgGroupCurrent %d.%d A",
            master + 1, (avgGroupCurrent / 10), (avgGroupCurrent % 10));
#endif
        PsuGroupDecreaseCurrent(master, avgGroupCurrent, &realDecrease);
        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
            PsuGroupDecreaseCurrent(slave, avgGroupCurrent, &realDecrease);
        }
    }

    if(NeedDecreaseCurrent > realDecrease)
    {
        // decrease excess current
        excessCurrent = NeedDecreaseCurrent - realDecrease;
#if 0
        PSU_LOG("Gun %d Decrease, ExcessCurrent %d.%d A", master + 1, (excessCurrent / 10), (excessCurrent % 10));
#endif
        PsuGroupDecreaseCurrent(master, excessCurrent, &realDecrease);
    }
}

void MasterIncreaseCurrent(unsigned char master, unsigned short NeedIncreaseCurrent)
{
    unsigned short excessCurrent = 0, realIncrease = 0;

    PsuGroupIncreaseCurrent(master, NeedIncreaseCurrent, &realIncrease);

    if(NeedIncreaseCurrent > realIncrease)
    {
        excessCurrent = NeedIncreaseCurrent - realIncrease;

        AverageIncreaseCurrent(master, excessCurrent);
    }
}

void MasterDecreaseCurrent(unsigned char master, unsigned short NeedDecreaseCurrent)
{
    unsigned char slave = 0;
    unsigned short avgGroupCurrent = 0, excessCurrent = 0, realDecrease = 0;


    if(ShmPsuGrouping->GroupCollection[master].Partner.RealQuantity > 0)
    {
        // decrease current by group quantity
        avgGroupCurrent = NeedDecreaseCurrent / ShmPsuGrouping->GroupCollection[master].Partner.RealQuantity;
#if 0
    PSU_LOG("Gun %d Decrease By Group, AvgGroupCurrent %d.%d A",
        master + 1, (avgGroupCurrent / 10), (avgGroupCurrent % 10));
#endif
        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];

            if(ShmPsuData->PsuGroup[slave].GroupPresentPsuQuantity > 0)
            {
                PsuGroupDecreaseCurrent(slave, avgGroupCurrent, &realDecrease);
            }
        }
    }

    if(NeedDecreaseCurrent > realDecrease)
    {
        excessCurrent = NeedDecreaseCurrent - realDecrease;
        PsuGroupDecreaseCurrent(master, excessCurrent, &realDecrease);
    }
}

void UpdateMaxCurrent(unsigned char master, unsigned short current)
{
    int time = 0;

    // update max stage current
    if(current > StageMaxCurrent[master])
    {
        StageMaxCurrent[master] = current;
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxStageCurrent = false;
        GetClockTime(&_StageCurrent_time[master]);
    }

    if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxStageCurrent)
    {
        time = GetTimeoutValue(_StageCurrent_time[master]) / uSEC_VAL;
        if(time >= EV_MAX_CURRENT_DELAY)
        {
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxStageCurrent = true;
            LOG_INFO("Gun %d Reach Max Stage Current", master + 1);
        }
    }

    // update max target current and reset max current time
    if(current > MaxCurrentDemand[master])
    {
        if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxCurrentDemand)
        {
            LOG_INFO("Gun %d Max Current Demand Timer Reset", master + 1);
        }
        MaxCurrentDemand[master] = current;
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxCurrentDemand = false;
        GetClockTime(&_MaxCurrent_time[master]);
    }

    if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxCurrentDemand)
    {
        time = GetTimeoutValue(_MaxCurrent_time[master]) / uSEC_VAL;
        if(time >= EV_MAX_CURRENT_DELAY)
        {
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxCurrentDemand = true;
            LOG_INFO("Gun %d Reach Max Current Demand", master + 1);
        }
    }
}

// master: master group index
bool IsMasterOutputCurrentStable(unsigned char master)
{
    int time = 0;
    bool stable = false, reachTarget = false;
    unsigned short presentOutput = (int)chargingInfo[master]->PresentChargingCurrent * 10;
    unsigned short TargetCurrent = 0;

    TargetCurrent = (int)(chargingInfo[master]->EvBatterytargetCurrent * 10);

    reachTarget = presentOutput > (TargetCurrent - REACH_CURRENT_TOLERANCE) && presentOutput < (TargetCurrent + REACH_CURRENT_TOLERANCE);

    if((presentOutput >= StableOutputCurrent[master] && presentOutput - StableOutputCurrent[master] > REACH_CURRENT_TOLERANCE) ||
        (presentOutput < StableOutputCurrent[master] && StableOutputCurrent[master] - presentOutput > REACH_CURRENT_TOLERANCE))
    {
        GetClockTime(&_ReachCurrent_time[master]);
        StableOutputCurrent[master] = presentOutput;
    }

    time = GetTimeoutValue(_ReachCurrent_time[master]) / uSEC_VAL;

    if(reachTarget || time >= CURRENT_STABLE_TIME ||
        (ShmChargerInfo->Control.FCharging[master].FCtrl.bits.EnableForceCharging && time >= CURRENT_REACH_TARGET_TIME))
    {
        stable = true;
    }

    return stable;
}

// master: master group index
void MasterBalanceCurrent(unsigned char master)
{
    int time = 0;
    unsigned char slave = 0;
    unsigned short realBalance = 0, grabCurrent = 0;

    time = GetTimeoutValue(_BalanceCurrent_time[master]) / mSEC_VAL;

    if(time >= BALANCE_CURRENT_INTERVAL)
    {
        //LOG_INFO("Gun %d Start Balance Current", master + 1);

        DecreaseCurrentByGunLoading(master, ShmPsuGrouping->GroupCollection[master].GunLoading, &grabCurrent, MAX_ADJ_BALANCE_CURRENT);
        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
            DecreaseCurrentByGunLoading(slave, ShmPsuGrouping->GroupCollection[master].GunLoading, &grabCurrent, MAX_ADJ_BALANCE_CURRENT);
        }
        //LOG_INFO("Gun %d Grab Balance Current %d.%d A", master + 1, (grabCurrent / 10), (grabCurrent % 10));

        IncreaseCurrentByGunLoading(master, ShmPsuGrouping->GroupCollection[master].GunLoading, &realBalance, grabCurrent);
        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
            IncreaseCurrentByGunLoading(slave, ShmPsuGrouping->GroupCollection[master].GunLoading, &realBalance, grabCurrent);
        }
        //LOG_INFO("Gun %d Increase Balance Current %d.%d A", master + 1, (realBalance / 10), (realBalance % 10));

        UpdateMasterPsuGroupLoading(master);
        GetClockTime(&_BalanceCurrent_time[master]);
    }
}

unsigned short GetLoadingDiff(unsigned char master)
{
    unsigned char slave = 0;
    unsigned short maxLoading = 0, minLoading = 0, diffLoading = 0;

    maxLoading = ShmPsuGrouping->GroupOutput[master].OutputLoading;
    minLoading = ShmPsuGrouping->GroupOutput[master].OutputLoading;

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];

        if(ShmPsuData->PsuGroup[slave].GroupPresentPsuQuantity == 0 || ShmPsuData->PsuGroup[slave].GroupAvailableCurrent == 0)
        {
            continue;
        }

        maxLoading = ShmPsuGrouping->GroupOutput[slave].OutputLoading > maxLoading ?
            ShmPsuGrouping->GroupOutput[slave].OutputLoading : maxLoading;

        minLoading = ShmPsuGrouping->GroupOutput[slave].OutputLoading < minLoading ?
            ShmPsuGrouping->GroupOutput[slave].OutputLoading : minLoading;
    }

    diffLoading = maxLoading - minLoading;

    return diffLoading;
}

void CheckCurrentBalance(unsigned char master)
{
    unsigned short diffLoading = 0;

    diffLoading = GetLoadingDiff(master);

    if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedCurrentBalance)
    {
        if(diffLoading >= START_BALANCE_CRITERIA)
        {
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedCurrentBalance = true;
            PSU_LOG("Gun %d Output Current Is Unbalance, diffLoading = %d.%02d", master + 1, (diffLoading / 100), (diffLoading % 100));
            GetClockTime(&_BalanceCurrent_time[master]);
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedCurrentBalance)
    {
        MasterBalanceCurrent(master);

        diffLoading = GetLoadingDiff(master);
        if(diffLoading <= STOP_BALANCE_CRITERIA)
        {
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedCurrentBalance = false;
            PSU_LOG("Gun %d Output Current Is Balance", master + 1);
        }
    }
}

bool IsOtherCharging(unsigned char group)
{
    bool find = false;
    int other = 0, selfTarget = 0, location = 0;

    if(ShmPsuGrouping->GroupCollection[group].TargetGroup == 0)
    {
        return find;
    }

    selfTarget = ShmPsuGrouping->GroupCollection[group].TargetGroup - 1;

    // search from left
    location = ShmPsuGrouping->GroupCollection[group].Location - 1;
    for(int i = location; i >= 0; i--)
    {
        other = ShmPsuGrouping->Layout[i];
        if(ShmPsuGrouping->GroupCollection[other].Role == _GROLE_MASTER)
        {
            find = other != selfTarget ? true : false;
            break;
        }
    }

    if(!find)
    {
        // search from right
        location = ShmPsuGrouping->GroupCollection[group].Location + 1;
        for(int i = location; i < ShmChargerInfo->Control.MaxConnector; i++)
        {
            other = ShmPsuGrouping->Layout[i];
            if(ShmPsuGrouping->GroupCollection[other].Role == _GROLE_MASTER)
            {
                find = other != selfTarget ? true : false;
                break;
            }
        }
    }

    return find;
}

// master: master group index
void MasterReleasePsuGroup(unsigned char master)
{
    bool findOtherInCharging = false;
    unsigned char slave = 0, member = 0, releaseTarget = 0;
    unsigned char otherCharging[MAX_GROUP_QUANTITY] = {0};
    unsigned char releaseList[MAX_GROUP_QUANTITY] = {0};
    unsigned short releaseLoading[MAX_GROUP_QUANTITY] = {0};
    PsuGroupPartner ReleaseMember;
    unsigned short target = 0, releaseAvailableCurrent = 0, originalAvailableCurrent = 0, originalLoading = 0, maxReleaseLoading = 0;

    if(ShmChargerInfo->PsuGrouping.GroupCollection[master].Role != _GROLE_MASTER ||
        ShmPsuGrouping->GroupCollection[master].Partner.Quantity == 0)
    {
        return;
    }

    target = (int)(chargingInfo[master]->EvBatterytargetCurrent * 10);
    originalAvailableCurrent = (int)chargingInfo[master]->AvailableChargingCurrent;
    originalLoading = ShmPsuGrouping->GroupCollection[master].GunLoading;

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];

        releaseAvailableCurrent = 0;
        PsuGroupPowerOffCheck(slave, &ReleaseMember);

        otherCharging[i] = IsOtherCharging(slave);
        findOtherInCharging = otherCharging[i] ? otherCharging[i] : findOtherInCharging;
        releaseList[i] = slave;

        for(int j = 0; j < ReleaseMember.Quantity; j++)
        {
            member = ReleaseMember.Member[j];
            releaseAvailableCurrent += ShmPsuData->PsuGroup[member].GroupAvailableCurrent;
        }

        releaseLoading[i] = originalAvailableCurrent > releaseAvailableCurrent ?
            (target * 10000 / (originalAvailableCurrent - releaseAvailableCurrent)) : 0;

        //LOG_INFO("Gun %d Release [%02X], Total Release %d Group, Gun Loading %d.%02d >> %d.%02d", master + 1, slave, ReleaseMember.Quantity,
        //    (originalLoading / 100), (originalLoading % 100),
        //    (releaseLoading[i] / 100), (releaseLoading[i] % 100));
    }

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        if((otherCharging[i] || !findOtherInCharging) &&
            releaseLoading[i] > maxReleaseLoading && releaseLoading[i] < (EXTEND_LOADING - RELEASE_LOADING_OFFSET))
        {
            maxReleaseLoading = releaseLoading[i];
            releaseTarget = releaseList[i];
        }
    }

    if(maxReleaseLoading > 0)
    {
        ShmPsuGrouping->GroupCollection[releaseTarget].GroupCtrl.bits.SlavePowerOffRequest = true;
        LOG_INFO("Gun %d Set [%02X] Release(%s), Gun Loading %d.%02d >> %d.%02d",
            master + 1, releaseTarget, findOtherInCharging ? "Other In Charging" : "Normal",
            (originalLoading / 100), (originalLoading % 100), (maxReleaseLoading / 100), (maxReleaseLoading % 100));
    }
}

void CheckReleaseOrExtend(unsigned char master)
{
    if((ShmChargerInfo->Control.TestCtrl.bits.ChargingSimulation ||
        !ShmChargerInfo->Control.FCharging[master].FCtrl.bits.EnableForceCharging) &&
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.DeratingCtrlValue == 0 &&
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue == 0)
    {
        if(ShmPsuGrouping->GroupCollection[master].Partner.Quantity > 0 &&
            ShmPsuGrouping->GroupCollection[master].GunLoading < RELEASE_LOADING &&
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxStageCurrent)
        {
            MasterReleasePsuGroup(master);
        }
        else if(ShmPsuGrouping->GroupCollection[master].GunLoading >= EXTEND_LOADING)
        {
            int available = GetPsuGroupAvailable(master);

            if(available > 0)
            {
                if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendAvailable)
                {
                    LOG_INFO("Gun %d Extend Capability Available", master + 1);
                    GetClockTime(&_ExtendCapability_time[master]);
                }
                ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendAvailable = true;
            }
        }
    }
}

bool IsPsuGroupOutputConfigDifferent(unsigned char group)
{
    bool different = false;

    if(ShmPsuGrouping->GroupOutput[group].GTargetVoltage != PreGroupOutput[group].GTargetVoltage ||
        ShmPsuGrouping->GroupOutput[group].GTargetCurrent != PreGroupOutput[group].GTargetCurrent)
    {
        different = true;
    }
    PreGroupOutput[group].GTargetVoltage = ShmPsuGrouping->GroupOutput[group].GTargetVoltage;
    PreGroupOutput[group].GTargetCurrent = ShmPsuGrouping->GroupOutput[group].GTargetCurrent;

    return different;
}

// Gun X Demand Change -> Voltage: XXXX.X V, Current: XXXX.X A, Available: XXXX.X A, Loading: XXX.XX
//         Master [XX] -> Voltage: XXXX.X V, Current: XXXX.X A, Available: XXXX.X A, Loading: XXX.XX
//         Member [XX] -> Voltage: XXXX.X V, Current: XXXX.X A, Available: XXXX.X A, Loading: XXX.XX
void ShowPsuGroupOutputConfig(unsigned char master)
{
    unsigned char slave = 0;

    PSU_LOG("Gun %d Demand Change -> Voltage: %4d V, Current: %4d.%d A, Available: %4d.%d A, Loading: %3d.%02d",
        master + 1, (ShmPsuGrouping->GroupOutput[master].GTargetVoltage / 10),
        ((int)chargingInfo[master]->EvBatterytargetCurrent), (((int)(chargingInfo[master]->EvBatterytargetCurrent * 10)) % 10),
        ((int)chargingInfo[master]->AvailableChargingCurrent / 10), ((int)chargingInfo[master]->AvailableChargingCurrent % 10),
        (ShmPsuGrouping->GroupCollection[master].GunLoading / 100), (ShmPsuGrouping->GroupCollection[master].GunLoading % 100));
    PSU_LOG("        Master [%02X] -> Voltage: %4d V, Current: %4d.%d A, Available: %4d.%d A, Loading: %3d.%02d",
        master, (ShmPsuGrouping->GroupOutput[master].GTargetVoltage / 10),
        (ShmPsuGrouping->GroupOutput[master].GTargetCurrent / 10), (ShmPsuGrouping->GroupOutput[master].GTargetCurrent % 10),
        (ShmPsuData->PsuGroup[master].GroupAvailableCurrent / 10), (ShmPsuData->PsuGroup[master].GroupAvailableCurrent % 10),
        (ShmPsuGrouping->GroupOutput[master].OutputLoading / 100), (ShmPsuGrouping->GroupOutput[master].OutputLoading % 100));
    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
        PSU_LOG("        Member [%02X] -> Voltage: %4d V, Current: %4d.%d A, Available: %4d.%d A, Loading: %3d.%02d",
            slave, (ShmPsuGrouping->GroupOutput[slave].GTargetVoltage / 10),
            (ShmPsuGrouping->GroupOutput[slave].GTargetCurrent / 10), (ShmPsuGrouping->GroupOutput[slave].GTargetCurrent % 10),
            (ShmPsuData->PsuGroup[slave].GroupAvailableCurrent / 10), (ShmPsuData->PsuGroup[slave].GroupAvailableCurrent % 10),
            (ShmPsuGrouping->GroupOutput[slave].OutputLoading / 100), (ShmPsuGrouping->GroupOutput[slave].OutputLoading % 100));
    }
}

void PsuGroupOutputConfigCheck(unsigned char master)
{
    unsigned char slave = 0;
    bool show = false;

    show = IsPsuGroupOutputConfigDifferent(master);

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
        if(IsPsuGroupOutputConfigDifferent(slave))
        {
            show = true;
        }
    }
    if(show)
    {
        ShowPsuGroupOutputConfig(master);
    }
}

void StepRecognition(unsigned char master, unsigned short voltage)
{
    if(_GfdStep[master] == PREPARE_STEP_NONE && voltage > 0)
    {
        // gfd step
        _GfdStep[master] = PREPARE_STEP_CABLE_CHECK;
        LOG_INFO("Gun %d GFD Start Step", master + 1);
    }
    else if(_GfdStep[master] == PREPARE_STEP_CABLE_CHECK && voltage == 0)
    {
        // gfd done step
        _GfdStep[master] = PREPARE_STEP_GFD_DONE;
        LOG_INFO("Gun %d GFD Stop Step", master + 1);
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.CableCheckDone = true;
    }
    else if(_GfdStep[master] == PREPARE_STEP_GFD_DONE && voltage >= SAFETY_PRECHARGE_OFFSET)
    {
        // precharge step
        _GfdStep[master] = PREPARE_STEP_PRECHARGE;
        LOG_INFO("Gun %d PreCharge Step", master + 1);
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.InPrechargeMode = true;
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AlreadyInChargingMode)
    {
        // charging step
        if(_GfdStep[master] != PREPARE_STEP_CHARGING)
        {
            LOG_INFO("Gun %d Charging Step", master + 1);
        }
        _GfdStep[master] = PREPARE_STEP_CHARGING;

        if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.InPrechargeMode)
        {
            if(_VoltageResumeCnt[master] < MAX_CHARGING_DELAY_COUNT)
            {
                int time = GetTimeoutValue(_ChargingDelay_time[master]) / mSEC_VAL;
                if(time >= CHARGING_DELAY_INTERVAL)
                {
                    GetClockTime(&_ChargingDelay_time[master]);
                    _VoltageResumeCnt[master]++;
                }
            }
            else
            {
                ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.InPrechargeMode = false;
            }
        }
    }
}

// master: master group index
// group: self group index
void UpdatePsuGroupOutputConfig(unsigned char master)
{
    unsigned char slave = 0;
    unsigned short TargetVoltage = 0, TargetCurrent = 0, PresentTargetCurrent = 0;
    unsigned short current = 0;

    TargetVoltage = (int)(chargingInfo[master]->EvBatterytargetVoltage * 10);
    TargetCurrent = (int)(chargingInfo[master]->EvBatterytargetCurrent * 10);

    if(chargingInfo[master]->RelayK1K2Status || ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.CableCheckDone)
    {
        // update target voltage
        if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed)
        {
            StepRecognition(master, TargetVoltage);

#if PRECHARGE_OFFSET
            // for safety test (inrush current)
            if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AlreadyInChargingMode)
            {
                GCTargetVoltage[master] = _GfdStep[master] == PREPARE_STEP_PRECHARGE ?
                    TargetVoltage - SAFETY_PRECHARGE_OFFSET : TargetVoltage;
            }
            else
            {
                if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.InPrechargeMode)
                {
                    GCTargetVoltage[master] = TargetVoltage > (GCTargetVoltage[master] + VOLTAGE_RESUME_STEP) ?
                        (GCTargetVoltage[master] + VOLTAGE_RESUME_STEP) : TargetVoltage;
                }
                else
                {
                    GCTargetVoltage[master] = TargetVoltage;
                }
            }
#else
            GCTargetVoltage[master] = TargetVoltage;
#endif
            ShmPsuGrouping->GroupOutput[master].GTargetVoltage = GCTargetVoltage[master];
            for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
            {
                slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
#if ONE_MODULE_OUTPUT
                // for safety test (inrush current)
                if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.InPrechargeMode)
                {
                    ShmPsuGrouping->GroupOutput[slave].GTargetVoltage = 0;
                }
                else
                {
                    ShmPsuGrouping->GroupOutput[slave].GTargetVoltage = GCTargetVoltage[master];
                }
#else
                ShmPsuGrouping->GroupOutput[slave].GTargetVoltage = GCTargetVoltage[master];
#endif
            }
        }

        // update target current
        if(((ShmPsuGrouping->GroupCollection[master].Partner.RealQuantity + 1) * ZERO_CURRENT) > TargetCurrent ||
            !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AlreadyInChargingMode)
        {
            current = ZERO_CURRENT;
#if 0
            if(ShmPsuGrouping->GroupOutput[master].GTargetCurrent != current)
            {
                LOG_INFO("Gun %d Need Minimum Target Current = %d", master + 1, current);
            }
#endif
            ShmPsuGrouping->GroupOutput[master].GTargetCurrent = current;

            for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
            {
                slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
                if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE || ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_PREPARE_SWITCH_OFF)
                {
#if ONE_MODULE_OUTPUT
                    // for safety test (inrush current)
                    ShmPsuGrouping->GroupOutput[slave].GTargetCurrent = 0;
#else
                    ShmPsuGrouping->GroupOutput[slave].GTargetCurrent =
                        ShmPsuData->PsuGroup[slave].GroupPresentPsuQuantity > 0 ? ZERO_CURRENT : 0;
#endif
                }
            }
        }
        else
        {
            if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed)
            {
                // master in normal output mode
                PresentTargetCurrent = GetPresentTargetCurrent(master, _GROLE_MASTER);

                current = TargetCurrent <= (int)chargingInfo[master]->AvailableChargingCurrent ?
                    TargetCurrent : (int)chargingInfo[master]->AvailableChargingCurrent;
#if 0
                if(GCTargetCurrent[master] != current)
                {
                    LOG_INFO("Gun %d Need Normal Target Current = %d", master + 1, current);
                }
#endif
                GCTargetCurrent[master] = current;

                UpdateMaxCurrent(master, GCTargetCurrent[master]);

                if(GCTargetCurrent[master] > PresentTargetCurrent)
                {
                    // increase current
                    OutputConfigStep[master] = _CURRENT_MODE_INCREASE;

                    PSU_LOG("Gun %d Increase Current: %d.%d A, %d.%d A -> %d.%d A", master + 1,
                        ((GCTargetCurrent[master] - PresentTargetCurrent) / 10), ((GCTargetCurrent[master] - PresentTargetCurrent) % 10),
                        (PresentTargetCurrent / 10), (PresentTargetCurrent % 10), (GCTargetCurrent[master] / 10), (GCTargetCurrent[master] % 10));
#if MASTER_OUTPUT_FIRST
                    // for safety test
                    if(GCTargetCurrent[master] <= CURRENT_BALANCE_CRITERIA)
                    {
                        MasterIncreaseCurrent(master, GCTargetCurrent[master] - PresentTargetCurrent);
                    }
                    else
                    {
                        AverageIncreaseCurrent(master, GCTargetCurrent[master] - PresentTargetCurrent);
                    }
#else
                    AverageIncreaseCurrent(master, GCTargetCurrent[master] - PresentTargetCurrent);
#endif
                }
                else if(GCTargetCurrent[master] < PresentTargetCurrent)
                {
                    // decrease current
                    OutputConfigStep[master] = _CURRENT_MODE_DECREASE;

                    PSU_LOG("Gun %d Decrease Current: %d.%d A, %d.%d A -> %d.%d A", master + 1,
                        ((PresentTargetCurrent - GCTargetCurrent[master]) / 10), ((PresentTargetCurrent - GCTargetCurrent[master]) % 10),
                        (PresentTargetCurrent / 10), (PresentTargetCurrent % 10), (GCTargetCurrent[master] / 10), (GCTargetCurrent[master] % 10));
#if MASTER_OUTPUT_FIRST
                    // for safety test
                    if(GCTargetCurrent[master] <= ShmPsuGrouping->GroupCollection[master].Partner.RealQuantity * CURRENT_BALANCE_CRITERIA)
                    {
                        MasterDecreaseCurrent(master, PresentTargetCurrent - GCTargetCurrent[master]);
                    }
                    else
                    {
                        AverageDecreaseCurrent(master, PresentTargetCurrent - GCTargetCurrent[master]);
                    }
#else
                    AverageDecreaseCurrent(master, PresentTargetCurrent - GCTargetCurrent[master]);
#endif
                }
                else
                {
                    // balance current or do not change
                    OutputConfigStep[master] = _CURRENT_MODE_BALANCE;
                    if(OutputConfigStep[master] != _preOutputConfigStep[master])
                    {
                        GetClockTime(&_ReachCurrent_time[master]);
                        LOG_INFO("Gun %d In Balance Mode", master + 1);
                        StableOutputCurrent[master] = (int)chargingInfo[master]->PresentChargingCurrent * 10;
                        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.OutputCurrentStable = false;
                        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedCurrentBalance = false;
                    }

                    if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.OutputCurrentStable)
                    {
                        if(IsMasterOutputCurrentStable(master))
                        {
                            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.OutputCurrentStable = true;
                            LOG_INFO("Gun %d Output Current = %5.1f A Stable", master + 1, chargingInfo[master]->PresentChargingCurrent);
                        }
                    }

                    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.OutputCurrentStable)
                    {
#if MASTER_OUTPUT_FIRST
                        // for safety test
                        if(GCTargetCurrent[master] > ShmPsuGrouping->GroupCollection[master].Partner.RealQuantity * CURRENT_BALANCE_CRITERIA)
                        {
                            CheckCurrentBalance(master);
                        }
                        else
                        {
                            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedCurrentBalance = false;
                        }
#else
                        CheckCurrentBalance(master);
#endif

                        if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedCurrentBalance)
                        {
                            CheckReleaseOrExtend(master);
                        }
                    }
                }
            }
            else
            {
                // master in derating mode
                OutputConfigStep[master] = _CURRENT_MODE_DERATING;
                if(OutputConfigStep[master] != _preOutputConfigStep[master])
                {
                    LOG_INFO("Gun %d In Derating Mode", master + 1);
                }
            }
            _preOutputConfigStep[master] = OutputConfigStep[master];
        }
    }
    else
    {
        ShmPsuGrouping->GroupOutput[master].GTargetVoltage = 0;
        ShmPsuGrouping->GroupOutput[master].GTargetCurrent = 0;
        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];
            ShmPsuGrouping->GroupOutput[slave].GTargetVoltage = 0;
            ShmPsuGrouping->GroupOutput[slave].GTargetCurrent = 0;
        }
    }
}

// group: self group index
void SetPsuGroupOutput(unsigned char group)
{
    int time = 0;

    if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
    {
#if ONE_MODULE_OUTPUT
        // for safety test (inrush current)
        if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.InPrechargeMode)
        {
            SingleOutputVol(ShmPsuPosition->GroupLocationInfo[group].PsuSN[0], ShmPsuGrouping->GroupOutput[group].GTargetVoltage, ShmPsuGrouping->GroupOutput[group].GTargetCurrent);
        }
        else
        {
            PresentOutputVol(group, ShmPsuGrouping->GroupOutput[group].GTargetVoltage, ShmPsuGrouping->GroupOutput[group].GTargetCurrent);
        }
#else
        PresentOutputVol(group, ShmPsuGrouping->GroupOutput[group].GTargetVoltage, ShmPsuGrouping->GroupOutput[group].GTargetCurrent);
#endif
        Await();
    }

    //UpdatePsuGroupLoading(group);
    UpdateGunLoading(group);

    if(ShmPsuGrouping->GroupOutput[group].GTargetVoltage >= PSU_MIN_VOL)
    {
        if(!isStartOutputSwitch[group])
        {
            SetPsuGroupPowerOnOff(group, PSU_POWER_ON);
            GetClockTime(&_PoweOnOff_time[group]);
        }
        time = GetTimeoutValue(_PoweOnOff_time[group]) / uSEC_VAL;
        if(time > POWER_ONOFF_RESEND_INTERVAL)
        {
            SetPsuGroupPowerOnOff(group, PSU_POWER_ON);
            GetClockTime(&_PoweOnOff_time[group]);
        }
    }
    else
    {
        if(isStartOutputSwitch[group])
        {
            SetPsuGroupPowerOnOff(group, PSU_POWER_OFF);
            GetClockTime(&_PoweOnOff_time[group]);
        }
        time = GetTimeoutValue(_PoweOnOff_time[group]) / uSEC_VAL;
        if(time > POWER_ONOFF_RESEND_INTERVAL)
        {
            SetPsuGroupPowerOnOff(group, PSU_POWER_OFF);
            GetClockTime(&_PoweOnOff_time[group]);
        }
    }
}

// master: master group index
bool CanMasterStartDerating(unsigned char master)
{
    bool start = false;
    unsigned short TargetCurrent = 0;

    TargetCurrent = (int)(chargingInfo[master]->EvBatterytargetCurrent * 10);

    if(TargetCurrent <= ShmPsuGrouping->GroupCollection[master].ReAssignAvailableCurrent)
    {
        start = true;
    }

    return start;
}

// master: master group index
// role_condition: when role_condition = _GROLE_MASTER, stop all member
void SetMemberStartPowerOff(unsigned char master, unsigned char role_condition)
{
    unsigned char slave = 0;
    char strMember[64];
    bool find = false;

    if(ShmPsuGrouping->GroupCollection[master].Role == _GROLE_MASTER)
    {
        sprintf(strMember, "Gun %d Set Member:", master + 1);

        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];

            if(role_condition == _GROLE_MASTER || ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_PREPARE_SWITCH_OFF)
            {
                SetPsuGroupRole(slave, _GROLE_SLAVE_POWER_OFF);

                char strSlave[8];
                sprintf(strSlave, " [%02X]", slave);
                strcat(strMember, strSlave);
                find = true;
            }
        }

        if(find)
        {
            strcat(strMember, " Power Off");
            LOG_INFO("%s", strMember);
        }
    }
}

// master: master group index
bool IsMemberPowerOffOK(unsigned char master)
{
    bool done = true;
    unsigned char slave = 0;

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];

        if(ShmPsuGrouping->GroupCollection[slave].Role != _GROLE_SLAVE && ShmPsuGrouping->GroupCollection[slave].Role != _GROLE_SWITCH_OFF_OK)
        {
            done = false;
        }
    }

    return done;
}

// master: master group index
void SetMemberPowerOffDone(unsigned char master)
{
    unsigned char slave = 0;

    if(ShmPsuGrouping->GroupCollection[master].Role == _GROLE_MASTER)
    {
        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].Partner.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].Partner.Member[i];

            if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SWITCH_OFF_OK)
            {
                SetPsuGroupRole(slave, _GROLE_WAIT_IDLE);
            }
            else if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE_POWER_OFF)
            {
                // can not power off normally
                SetPsuGroupRole(slave, _GROLE_TERMINATE);
            }
        }
    }
}

unsigned char _ParallelRelay[MAX_GROUP_QUANTITY];
void SetPCabinetParallelRelay(unsigned short parallelConfig)
{
    bool change = false;

    if(ShmChargerInfo->Control.CabinetRole == _CROLE_MASTER)
    {
        for(int i = 0; i < MAX_SLAVE_CABINET_QUANTITY; i++)
        {
            change = false;
            if(ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DeviceStatus_Idle ||
                ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DeviceStatus_Alarm ||
                ShmChargerInfo->ParallelCabinet.PCabinet[i].LocalStatus == _DeviceStatus_Charging)
            {
                for(int j = 0; j < GENERAL_GUN_QUANTITY; j++)
                {
                    _ParallelRelay[j] = (parallelConfig & (1 << j)) > 0 ? YES : NO;

                    if(_ParallelRelay[i] != ShmChargerInfo->ParallelCabinet.PCabinet[i].ParallelRelaySetting[i])
                    {
                        change = true;
                    }
                }

                if(change)
                {
                    char strParallel[128];
                    sprintf(strParallel, "Set PCabinet %d Parallel Relay:", i + 1);
                    for(int j = 0; j < GENERAL_GUN_QUANTITY; j++)
                    {
                        char strState[8];
                        sprintf(strState, " %3s", _ParallelRelay[j] ? "ON" : "OFF");
                        strcat(strParallel, strState);
                    }
                    LOG_INFO("%s", strParallel);
                }
                ShmChargerInfo->ParallelCabinet.PCabinet[i].ParallelRelaySetting[i] = _ParallelRelay[i];
            }
        }
    }
}

// master: master group index
// Yes_No: Yes: relay on, No: relay off
// role_condition: when role_condition = _GROLE_MASTER, parallel relay of all member do the action(on or off)
void SetParallelRelayOnOff(unsigned char master, unsigned char Yes_No, unsigned char role_condition)
{
    int ParallelConfig = 0;
    unsigned char slave = 0;
    PsuGroupPartner *partner;

    if(ShmPsuGrouping->GroupCollection[master].Role == _GROLE_MASTER ||
        (ShmPsuGrouping->GroupCollection[master].Role == _GROLE_REQUEST_TO_CHARGING && Yes_No))
    {
        ShmPsuGrouping->GroupCollection[master].ParallelCheck = 0;

        partner = role_condition == _GROLE_PRECHARGE_READY ? &ShmPsuGrouping->GroupCollection[master].PossibleMember : &ShmPsuGrouping->GroupCollection[master].Partner;

        for(int i = 0; i < partner->Quantity; i++)
        {
            slave = partner->Member[i];

            if(role_condition == _GROLE_MASTER || ShmPsuGrouping->GroupCollection[slave].Role != _GROLE_SLAVE)
            {
                ParallelConfig = ShmPsuGrouping->GroupCollection[master].ParallelConfig[slave];
                if(ParallelConfig != 0)
                {
                    ShmPsuGrouping->GroupCollection[master].ParallelCheck |= (1 << (ParallelConfig - 1));
                }
            }
        }
        if(Yes_No)
        {
            ShmPsuGrouping->ParallelRelayConfig.CtrlValue |= ShmPsuGrouping->GroupCollection[master].ParallelCheck;
        }
        else
        {
            ShmPsuGrouping->ParallelRelayConfig.CtrlValue &= ~ShmPsuGrouping->GroupCollection[master].ParallelCheck;
        }

        SetPCabinetParallelRelay(ShmPsuGrouping->ParallelRelayConfig.CtrlValue);
    }
}

// master: master group index
bool IsParallelRelayConfirmed(unsigned char master)
{
    bool confirmed = true;

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if((1 << i) & ShmPsuGrouping->GroupCollection[master].ParallelCheck)
        {
            if((ShmPsuGrouping->ParallelRelayConfig.CtrlValue & (1 << i)) != (ShmPsuGrouping->ParallelRelayConfirmed.CtrlValue & (1 << i)))
            {
                confirmed = false;
                break;
            }
        }
    }

    return confirmed;
}

// master: master group index
bool IsPossibleMemberReady(unsigned char master)
{
    bool ready = true;
    unsigned char slave = 0;

    if(ShmPsuGrouping->GroupCollection[master].PossibleMember.Quantity > 0)
    {
        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].PossibleMember.Quantity; i++)
        {
            slave = ShmPsuGrouping->GroupCollection[master].PossibleMember.Member[i];

            if(ShmPsuGrouping->GroupCollection[slave].Role != _GROLE_WAIT_SLAVE)
            {
                ready = false;
            }
        }
    }

    return ready;
}

// master: master group index
bool IsExtendPrechargeReady(unsigned char master)
{
    bool ready = true;
    unsigned char slave = 0;

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].PossibleMember.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].PossibleMember.Member[i];

        if(ShmPsuData->PsuGroup[slave].GroupPresentPsuQuantity == 0 || ShmPsuData->PsuGroup[slave].GroupAvailableCurrent == 0)
        {
            continue;
        }

        if(ShmPsuGrouping->GroupCollection[slave].Role != _GROLE_PREPARE_ATTACH_ON ||
            ShmPsuData->PsuGroup[slave].GroupPresentOutputVoltage > (ShmPsuData->PsuGroup[master].GroupPresentOutputVoltage + PRECHARGE_RANGE_VOLTAGE) ||
            ShmPsuData->PsuGroup[slave].GroupPresentOutputVoltage < (ShmPsuData->PsuGroup[master].GroupPresentOutputVoltage - PRECHARGE_OFFSET_VOLTAGE- PRECHARGE_RANGE_VOLTAGE))
        {
            ready = false;
        }
    }

    return ready;
}

// master: master group index
void SetExtendPrechargeCompleted(unsigned char master)
{
    unsigned char slave = 0;

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].PossibleMember.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].PossibleMember.Member[i];

        SetPsuGroupRole(slave, _GROLE_PRECHARGE_READY);
    }
}


// master: master group index
void SetExtendPrechargeStop(unsigned char master)
{
    unsigned char slave = 0;

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].PossibleMember.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].PossibleMember.Member[i];

        SetPsuGroupRole(slave, _GROLE_EXTEND_STOP);
    }
    memset(&ShmPsuGrouping->GroupCollection[master].PossibleMember, 0x00, sizeof(PsuGroupPartner));
}

// master: master group index
void AddExtendMember(unsigned char master)
{
    unsigned char slave = 0;

    for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].PossibleMember.Quantity; i++)
    {
        slave = ShmPsuGrouping->GroupCollection[master].PossibleMember.Member[i];

        if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_PRECHARGE_READY)
        {
            AddMember(slave, master);
        }
    }
}

// group: self group index
void CheckChargingRequest(unsigned char group)
{
    if(ShmPsuGrouping->GroupCollection[group].Role != _GROLE_IDLE)
    {
        return;
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ChargingRequest)
    {
        SetPsuGroupRole(group, _GROLE_REQUEST_TO_CHARGING);
    }
}

// group: self group index
void ChargingRequestProcess(unsigned char group)
{
    int time = 0;
    PsuGroupPartner partner;

    if(ShmPsuGrouping->GroupCollection[group].Role != _GROLE_REQUEST_TO_CHARGING)
    {
        return;
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ChargingRequest && !ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ChargingRequestConfirmed)
    {
        GetClockTime(&_ChargingRequest_time[group]);
        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ChargingRequest = false;
        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ChargingRequestConfirmed = true;
        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.GroupShareCheck = true;
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.GroupShareCheck && !ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ShareConfirmed)
    {
        // check is there psu group to grab
        if(PsuGroupGrabCheck(group, &partner))
        {
            GetClockTime(&_ChargingRequest_time[group]);
            ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.GrabGroupWait = true;
            PrepareToPowerOff(group + 1, &partner);
            memcpy(&ShmPsuGrouping->GroupCollection[group].PossibleMember, &partner, sizeof(PsuGroupPartner));
        }
        else
        {
            ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ShareCheckDone = true;
            LOG_INFO("Gun %d Grab Nothing", group + 1);
        }
        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ShareConfirmed = true;
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.GrabGroupWait && !ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ShareCheckDone)
    {
        // wait until grab psu ready or timeout
        bool ready = IsPossibleMemberReady(group);
        time = GetTimeoutValue(_ChargingRequest_time[group]) / uSEC_VAL;

        if(ready || time >= WAIT_GRAB_TIME)
        {
            ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ShareCheckDone = true;
            LOG_INFO("Gun %d Grab %s", group + 1, ready ? "OK" : "Timeout");
        }
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ShareCheckDone && !ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.FindGroupPartner)
    {
        GetClockTime(&_ChargingRequest_time[group]);
        AddAvailableMember(group);
        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.FindGroupPartner = true;
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.FindGroupPartner && !ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ParallelRelayOn)
    {
        // after a little delay, set parallel relay on
        time = GetTimeoutValue(_ChargingRequest_time[group]) / uSEC_VAL;

        if(time >= WAIT_PARALLEL_RELAY_DELAY)
        {
            unsigned short original = ShmPsuGrouping->ParallelRelayConfig.CtrlValue;
            GetClockTime(&_ChargingRequest_time[group]);
            SetParallelRelayOnOff(group, YES, _GROLE_MASTER);
            ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ParallelRelayOn = true;
            LOG_INFO("Gun %d Charging Request Set All Member Parallel Relay On %X -> %X", group + 1, original, ShmPsuGrouping->ParallelRelayConfig.CtrlValue);
        }
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ParallelRelayOn && !ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ParallelRelayConfirmed)
    {
        // wait until parallel relay on confirmed
        bool confirmed = IsParallelRelayConfirmed(group);
        time = GetTimeoutValue(_ChargingRequest_time[group]) / uSEC_VAL;

        //if(confirmed || time >= WAIT_RELAY_CONFIRMED_TIME)
        if(time >= WAIT_RELAY_CONFIRMED_TIME)
        {
            GetClockTime(&_ChargingRequest_time[group]);
            ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ParallelRelayConfirmed = true;
            LOG_INFO("Gun %d Charging Request Parallel Relay Confirmed %s", group + 1, confirmed ? "OK" : "Timeout");
        }
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ParallelRelayConfirmed && !ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.GroupingDone)
    {
        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.GroupingDone = true;
    }

    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.GroupingDone)
    {
        SetPsuGroupToMaster(group);
        ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.IdleCtrlValue = 0;
        LOG_INFO("Gun %d Grouping Completed", group + 1);
    }
}

// master: master group index
void PsuGroupDeratingProcess(unsigned char master)
{
    int time = 0;

    // slave group set NeedDerating flag to start re-assign
    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedDerating)
    {
        // reduce output current capability start
        GetClockTime(&_PsuGroupDerating_time[master]);
        unsigned short ReAssignCurrent = GetPresentTargetCurrent(master, _GROLE_SLAVE);
        ShmPsuGrouping->GroupCollection[master].ReAssignAvailableCurrent = ReAssignCurrent;
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.NeedDerating = false;

        LOG_INFO("Gun %d DeratingConfirmed%s, ReAssignAvailableCurrent = %d.%d A",
                master + 1,
                ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed ? " Again" : "",
                (ReAssignCurrent / 10), (ReAssignCurrent % 10));

        if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed)
        {
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.DeratingCtrlValue = 0;
        }
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed = true;
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingStart)
    {
        // wait until derating from ev or timeout
        bool start = CanMasterStartDerating(master);
        bool bypass = ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AlreadyInChargingMode ? false : true;
        time = GetTimeoutValue(_PsuGroupDerating_time[master]) / uSEC_VAL;

        if(start || time >= WAIT_EV_DERATING_TIMEOUT || bypass)
        {
            GetClockTime(&_PsuGroupDerating_time[master]);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingStart = true;
            LOG_INFO("Gun %d %s Start Derating%s", master + 1, start ? "Normal" : "Force", bypass ? " (Bypass)" : "");
            SetMemberStartPowerOff(master, _GROLE_PREPARE_SWITCH_OFF);

            if(!bypass)
            {
                // update stage max current and reset max current time
                StageMaxCurrent[master] = start ?
                    (int)(chargingInfo[master]->EvBatterytargetCurrent * 10) :
                    ShmPsuGrouping->GroupCollection[master].ReAssignAvailableCurrent;
                ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxStageCurrent = false;
                GetClockTime(&_StageCurrent_time[master]);
            }
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingStart && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingPowerOffDone)
    {
        // wait until psu member power off ok or timeout
        bool power_off_ok = IsMemberPowerOffOK(master);
        time = GetTimeoutValue(_PsuGroupDerating_time[master]) / uSEC_VAL;

        if(power_off_ok || time >= WAIT_SLAVE_POWER_OFF_TIMEOUT)
        {
            GetClockTime(&_PsuGroupDerating_time[master]);
            SetMemberPowerOffDone(master);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingPowerOffDone = true;
            LOG_INFO("Gun %d Set Derating Member Power Off %s", master + 1, power_off_ok ? "OK" : "Timeout");
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingPowerOffDone && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingRelayOff)
    {
        // after a little delay, set parallel relay off
        time = GetTimeoutValue(_PsuGroupDerating_time[master]) / uSEC_VAL;

        if(time >= WAIT_PARALLEL_RELAY_DELAY)
        {
            unsigned short original = ShmPsuGrouping->ParallelRelayConfig.CtrlValue;
            GetClockTime(&_PsuGroupDerating_time[master]);
            SetParallelRelayOnOff(master, NO, _GROLE_SWITCH_OFF_OK);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingRelayOff = true;
            LOG_INFO("Gun %d Set Parallel Relay Off %X -> %X", master + 1, original, ShmPsuGrouping->ParallelRelayConfig.CtrlValue);
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingRelayOff && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingRelayConfirmed)
    {
        // wait until parallel relay off confirmed
        bool confirmed = IsParallelRelayConfirmed(master);
        time = GetTimeoutValue(_PsuGroupDerating_time[master]) / uSEC_VAL;

        //if(confirmed || time >= WAIT_RELAY_CONFIRMED_TIME)
        if(time >= WAIT_RELAY_CONFIRMED_TIME)
        {
            GetClockTime(&_PsuGroupDerating_time[master]);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingRelayConfirmed = true;
            LOG_INFO("Gun %d Parallel Relay Confirmed %s", master + 1, confirmed ? "OK" : "Timeout");
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingRelayConfirmed && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingCompleted)
    {
        // remove all non group member
        RemoveNonGroupMember(master);
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingCompleted = true;
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingCompleted)
    {
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.DeratingCtrlValue = 0;
        UpdateGunAvailableCapability(master);
        LOG_INFO("Gun %d Derating Completed", master + 1);
    }
}

void MasterStopChargingProcess(unsigned char master)
{
    int time = 0;

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.StopChargingRequest && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.StopChargingConfirmed)
    {
        // set all member to power off
        GetClockTime(&_StopCharging_time[master]);
        SetMemberStartPowerOff(master, _GROLE_MASTER);
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.StopChargingConfirmed = true;
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.StopChargingConfirmed && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllPowerOffDone)
    {
        // wait until psu member power off ok or timeout
        bool power_off_ok = IsMemberPowerOffOK(master);
        time = GetTimeoutValue(_StopCharging_time[master]) / uSEC_VAL;

        if(power_off_ok || time >= WAIT_SLAVE_POWER_OFF_TIMEOUT)
        {
            GetClockTime(&_StopCharging_time[master]);
            SetMemberPowerOffDone(master);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllPowerOffDone = true;
            LOG_INFO("Gun %d Set All Member Power Off %s", master + 1, power_off_ok ? "OK" : "Timeout");
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllPowerOffDone && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllParallelRelayOff)
    {
        // after a little delay, set all member parallel relay off
        time = GetTimeoutValue(_StopCharging_time[master]) / uSEC_VAL;

        if(time >= WAIT_PARALLEL_RELAY_DELAY)
        {
            unsigned short original = ShmPsuGrouping->ParallelRelayConfig.CtrlValue;
            GetClockTime(&_StopCharging_time[master]);
            SetParallelRelayOnOff(master, NO, _GROLE_MASTER);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllParallelRelayOff = true;
            LOG_INFO("Gun %d Set All Member Parallel Relay Off %X -> %X", master + 1, original, ShmPsuGrouping->ParallelRelayConfig.CtrlValue);
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllParallelRelayOff && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllParallelRelayConfirmed)
    {
        // wait until parallel relay off confirmed
        bool confirmed = IsParallelRelayConfirmed(master);
        time = GetTimeoutValue(_StopCharging_time[master]) / uSEC_VAL;

        //if(confirmed || time >= WAIT_RELAY_CONFIRMED_TIME)
        if(time >= WAIT_RELAY_CONFIRMED_TIME)
        {
            GetClockTime(&_StopCharging_time[master]);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllParallelRelayConfirmed = true;
            LOG_INFO("Gun %d All Member Parallel Relay Confirmed %s", master + 1, confirmed ? "OK" : "Timeout");
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllParallelRelayConfirmed && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllMemberStopCompleted)
    {
        // remove all non group member
        RemoveNonGroupMember(master);
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllMemberStopCompleted = true;
        LOG_INFO("Gun %d All Member Stop Completed", master + 1);
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.AllMemberStopCompleted && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.StopChargingCompleted)
    {
        // check self group power down or not
        if(ShmPsuData->PsuGroup[master].GroupPresentOutputCurrent <= MAX_PSU_POWER_OFF_CURRENT)
        {
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.StopChargingCompleted = true;
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.StopChargingCompleted)
    {
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.MasterCtrlValue = 0;
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.StopChargingCtrlValue = 0;
        SetPsuGroupToIdle(master);
        LOG_INFO("Gun %d Stop Charging Completed", master + 1);
    }
}

void SlaveStopChargingProcess(unsigned char slave)
{
    int time = 0;
    unsigned char master = 0;
    PsuGroupPartner PowerOffMember, GrabMember;

    if(ShmPsuGrouping->GroupCollection[slave].Role != _GROLE_SLAVE)
    {
        return;
    }

    master = ShmPsuGrouping->GroupCollection[slave].TargetGroup - 1;

    if(ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlaveChargingRequest && !ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.CheckSlaveReady)
    {
        ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.CheckSlaveReady = true;

        if(ShmPsuGrouping->GroupCollection[master].Role == _GROLE_REQUEST_TO_CHARGING)
        {
            LOG_INFO("Gun %d Need Wait Gun %d Grouping Completed", slave + 1, master + 1);
            GetClockTime(&_CheckSlaveReady_time[slave]);
        }
        else if(ShmPsuGrouping->GroupCollection[master].Role == _GROLE_MASTER && ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed)
        {
            LOG_INFO("Gun %d Need Wait Gun %d Derating Completed", slave + 1, master + 1);
            GetClockTime(&_CheckSlaveReady_time[slave]);
        }
        else
        {
            ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlavePowerOffRequest = true;
            ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.WaitSlaveReady = true;
            LOG_INFO("Gun %d Need Power Off And Request To Charging", slave + 1);
        }
    }

    // wait until master derating completed
    if(ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.CheckSlaveReady && !ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.WaitSlaveReady)
    {
        time = GetTimeoutValue(_CheckSlaveReady_time[slave]) / uSEC_VAL;
        if(time >= WAIT_SLAVE_READY_TIME ||
            (ShmPsuGrouping->GroupCollection[master].Role == _GROLE_MASTER && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed))
        {
            if(!(ShmPsuGrouping->GroupCollection[master].Role == _GROLE_MASTER && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.DeratingConfirmed))
            {
                ShmPsuGrouping->GroupCollection[slave].GroupCtrl.RoleCtrl.SlaveCtrlValue = 0;
                LOG_INFO("Gun %d Wait Gun %d Timeout", slave + 1);
            }
            else
            {
                ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.WaitSlaveReady = true;
                LOG_INFO("Gun %d Is Ready", slave + 1);
                GetClockTime(&_CheckSlaveReady_time[slave]);
            }
        }
    }

    if(ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.WaitSlaveReady && !ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlavePowerOffRequest)
    {
        time = GetTimeoutValue(_CheckSlaveReady_time[slave]) / uSEC_VAL;

        if(time >= WAIT_SLAVE_DELAY)
        {
            ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlavePowerOffRequest = true;
        }
    }

    // self group, other slave or master set SlavePowerOffRequest flag to power off
    if(ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlavePowerOffRequest && !ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlavePowerOffConfirmed)
    {
        PsuGroupPowerOffCheck(slave, &PowerOffMember);

        if(PowerOffMember.Quantity == 1 && ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlaveChargingRequest)
        {
            // grab here
            if(PsuGroupGrabCheck(slave, &GrabMember))
            {
                for(int i = 0; i < GrabMember.Quantity; i++)
                {
                    PowerOffMember.Member[PowerOffMember.Quantity++] = GrabMember.Member[i];
                }
            }
        }

        if(PowerOffMember.Quantity > 0)
        {
            unsigned char target = ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlaveChargingRequest ? (slave + 1) : 0;
            PrepareToPowerOff(target, &PowerOffMember);
            if(PowerOffMember.Quantity > 1 && ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlaveChargingRequest)
            {
                ShmPsuGrouping->GroupCollection[slave].PossibleMember.Quantity = PowerOffMember.Quantity - 1;
                memcpy(ShmPsuGrouping->GroupCollection[slave].PossibleMember.Member, &PowerOffMember.Member[1], PowerOffMember.Quantity - 1);
            }
            ShmPsuGrouping->GroupCollection[slave].GroupCtrl.bits.SlavePowerOffConfirmed = true;
        }
        else
        {
            ShmPsuGrouping->GroupCollection[slave].GroupCtrl.RoleCtrl.SlaveCtrlValue = 0;
        }
    }
}

void MasterExtendCapabilityProcess(unsigned char master)
{
    int time = 0;

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.DeratingCtrlValue != 0 ||
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.StopChargingRequest)
    {
        if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.MorePowerConfirmed)
        {
            SetExtendPrechargeStop(master);
        }
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue = 0;
        return;
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.MorePowerRequest && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.MorePowerConfirmed)
    {
        GetClockTime(&_ExtendCapability_time[master]);
        memset(&ShmPsuGrouping->GroupCollection[master].PossibleMember, 0x00, sizeof(PsuGroupPartner));

        FindPsuGroupPartner(master, MAX_GROUP_QUANTITY, &ShmPsuGrouping->GroupCollection[master].PossibleMember);
        if(ShmPsuGrouping->GroupCollection[master].PossibleMember.Quantity > 0)
        {
            PrepareToExtendCapability(master + 1, &ShmPsuGrouping->GroupCollection[master].PossibleMember);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.MorePowerConfirmed = true;
        }
        else
        {
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue = 0;
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.MorePowerConfirmed && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendPrechargeDone)
    {
        unsigned short voltage = ShmPsuData->PsuGroup[master].GroupPresentOutputVoltage >= PRECHARGE_OFFSET_VOLTAGE ?
                ShmPsuData->PsuGroup[master].GroupPresentOutputVoltage - PRECHARGE_OFFSET_VOLTAGE : 0;

        for(int i = 0; i < ShmPsuGrouping->GroupCollection[master].PossibleMember.Quantity; i++)
        {
            unsigned char slave = ShmPsuGrouping->GroupCollection[master].PossibleMember.Member[i];

            if(ShmPsuData->PsuGroup[slave].GroupPresentPsuQuantity > 0 && ShmPsuData->PsuGroup[slave].GroupAvailableCurrent > 0)
            {
                ShmPsuGrouping->GroupOutput[slave].GTargetVoltage = voltage;
                ShmPsuGrouping->GroupOutput[slave].GTargetCurrent = ZERO_CURRENT;
            }
        }
        if(!ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendPrecharge)
        {
            GetClockTime(&_ExtendCapability_time[master]);
            LOG_INFO("Gun %d Set ExtendPrecharge Voltage %d.%d V", master + 1, (voltage / 10), (voltage % 10));
        }
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendPrecharge = true;
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendPrecharge && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendPrechargeDone)
    {
        bool ready = IsExtendPrechargeReady(master);
        time = GetTimeoutValue(_ExtendCapability_time[master]) / uSEC_VAL;

        if(ready || time >= WAIT_PRECHARGE_TIME)
        {
            LOG_INFO("Gun %d ExtendPrecharge %s", master + 1, ready ? "Ready" : "Timeout");
            if(ready)
            {
                GetClockTime(&_ExtendCapability_time[master]);
                SetExtendPrechargeCompleted(master);
                ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendPrechargeDone = true;
            }
            else
            {
                SetExtendPrechargeStop(master);
                ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue = 0;
            }
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendPrechargeDone && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendRelayOn)
    {
        // after a little delay, set extend parallel relay on
        time = GetTimeoutValue(_ExtendCapability_time[master]) / uSEC_VAL;

        if(time >= WAIT_PARALLEL_RELAY_DELAY)
        {
            unsigned short original = ShmPsuGrouping->ParallelRelayConfig.CtrlValue;
            GetClockTime(&_ExtendCapability_time[master]);
            SetParallelRelayOnOff(master, YES, _GROLE_PRECHARGE_READY);
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendRelayOn = true;
            LOG_INFO("Gun %d Set Extend Parallel Relay On %X -> %X", master + 1, original, ShmPsuGrouping->ParallelRelayConfig.CtrlValue);
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendRelayOn && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendRelayConfirmed)
    {
        // wait until extend parallel relay on confirmed
        bool confirmed = IsParallelRelayConfirmed(master);
        time = GetTimeoutValue(_ExtendCapability_time[master]) / uSEC_VAL;

        //if(confirmed || time >= WAIT_RELAY_CONFIRMED_TIME)
        if(time >= WAIT_RELAY_CONFIRMED_TIME)
        {
            ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendRelayConfirmed = true;
            LOG_INFO("Gun %d Extend Parallel Relay Confirmed %s", master + 1, confirmed ? "OK" : "Timeout");
        }
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendRelayConfirmed && !ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendCompleted)
    {
        AddExtendMember(master);
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendCompleted = true;
    }

    if(ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ExtendCompleted)
    {
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue = 0;
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.OutputCurrentStable = false;
        GetClockTime(&_ReachCurrent_time[master]);
        UpdateGunAvailableCapability(master);
        ShmPsuGrouping->GroupCollection[master].GroupCtrl.bits.ReachMaxStageCurrent = false;
        GetClockTime(&_StageCurrent_time[master]);
        LOG_INFO("Gun %d Extend Capability Completed", master + 1);
    }
}

void ShowGunVoltageCurrent(unsigned char master)
{
    unsigned short voltage = 0, current = 0, fireVoltage = 0;
    unsigned short diffVoltage = 0, diffCurrent = 0;

    if(ShmPsuGrouping->GroupCollection[master].Role == _GROLE_MASTER)
    {
        voltage = (int)(chargingInfo[master]->PresentChargingVoltage * 10);
        current = (int)(chargingInfo[master]->PresentChargingCurrent * 10);
        fireVoltage = chargingInfo[master]->FireChargingVoltage;

        diffVoltage = voltage >= evseOutVol[master] ? voltage - evseOutVol[master] : evseOutVol[master] - voltage;
        diffCurrent = current >= evseOutCur[master] ? current - evseOutCur[master] : evseOutCur[master] - current;

        if(diffVoltage >= 10 || diffCurrent >= 10)
        {
            evseOutputDelay[master] = SHOW_OUTPUT_DELAY;
            evseOutVol[master] = voltage;
            evseOutCur[master] = current;
        }

        if(evseOutputDelay[master] != 0)
        {
            LOG_INFO("Gun %d Need Voltage: %4d V, Current: %3d A, Output Voltage: %4d.%d V, Current: %3d.%d A, Fire Voltage: %4d V",
                master + 1, (int)chargingInfo[master]->EvBatterytargetVoltage, (int)chargingInfo[master]->EvBatterytargetCurrent,
                (voltage / 10), (voltage % 10), (current / 10), (current % 10), fireVoltage / 10);
            evseOutputDelay[master]--;
        }
    }
}

void PsuGroupControlProcess(void)
{
    int time = 0;
    unsigned char role = 0;
    //unsigned short TargetVoltage = 0, TargetCurrent = 0;

    for(byte group = 0; group < GENERAL_GUN_QUANTITY; group++)
    {
        role = ShmPsuGrouping->GroupCollection[group].Role;
        switch(role)
        {
            case _GROLE_IDLE:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.IdleCtrlValue = 0;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.MasterCtrlValue = 0;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.StopChargingCtrlValue = 0;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.DeratingCtrlValue = 0;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue = 0;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.SlaveCtrlValue = 0;
                    PSU_LOG("===== PSU Group[%02X] ===== Idle", group);
                    GetClockTime(&_PsuGroupRole_time[group]);

                    ShmPsuGrouping->GroupOutput[group].GTargetVoltage = 0;
                    ShmPsuGrouping->GroupOutput[group].GTargetCurrent = 0;
                    PreGroupOutput[group].GTargetVoltage = 0;
                    PreGroupOutput[group].GTargetCurrent = 0;
                    SetPsuGroupOutput(group);
                }

                if(isStartOutputSwitch[group])
                {
                    SetPsuGroupPowerOnOff(group, PSU_POWER_OFF);
                }

                if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.IdleCtrlValue != 0 &&
                    ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
                {
                    CheckChargingRequest(group);
                }
                break;

            case _GROLE_MASTER:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.MasterCtrlValue = 0;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.StopChargingCtrlValue = 0;
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.DeratingCtrlValue = 0;
                    PSU_LOG("===== PSU Group[%02X] ===== Master", group);
                    GetClockTime(&_PsuGroupRole_time[group]);

                    OutputConfigStep[group] = _CURRENT_MODE_NONE;
                    _preOutputConfigStep[group] = _CURRENT_MODE_NONE;
                    MaxCurrentDemand[group] = 0;
                    StageMaxCurrent[group] = 0;
                    _GfdStep[group] = PREPARE_STEP_NONE;
                    _VoltageResumeCnt[group] = 0;
                }

                if(!ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.AlreadyInChargingMode)
                {
                    if(chargingInfo[group]->SystemStatus == S_CHARGING && chargingInfo[group]->RelayK1K2Status)
                    {
                        LOG_INFO("Gun %d Enter Charging Mode", group + 1);
                        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.AlreadyInChargingMode = true;
                        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ReachMaxCurrentDemand = false;
                        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ReachMaxStageCurrent = false;
                        GetClockTime(&_MaxCurrent_time[group]);
                        GetClockTime(&_StageCurrent_time[group]);
                        GetClockTime(&_ChargingDelay_time[group]);
                    }
                }

                if((chargingInfo[group]->SystemStatus <= S_IDLE) ||
                    (chargingInfo[group]->SystemStatus >= S_TERMINATING && chargingInfo[group]->SystemStatus <= S_FAULT))
                {
                    if(!ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.StopChargingRequest)
                    {
                        LOG_INFO("Gun %d SystemStatus(%d) Need Stop Charging", group + 1, chargingInfo[group]->SystemStatus);
                    }
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.StopChargingRequest = true;
                }

                if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue == 0)
                {
                    if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ExtendAvailable)
                    {
                        time = GetTimeoutValue(_ExtendCapability_time[group]) / uSEC_VAL;

                        if(time >= EXTEND_CAPABILITY_DELAY)
                        {
                            int available = GetPsuGroupAvailable(group);

                            if(available > 0)
                            {
                                ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.MorePowerRequest = true;
                                LOG_INFO("Gun %d Start Extend Capability", group + 1);
                            }
                            ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ExtendAvailable = false;
                        }
                    }
                }

                if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.ExtendCapabilityCtrlValue != 0)
                {
                    MasterExtendCapabilityProcess(group);
                }

                // need derating
                if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.DeratingCtrlValue != 0 &&
                    !ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.StopChargingRequest)
                {
                    PsuGroupDeratingProcess(group);
                }

                if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.StopChargingRequest)
                {
                    ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.DeratingCtrlValue = 0;
                    ShmPsuGrouping->GroupOutput[group].GTargetVoltage = 0;
                    ShmPsuGrouping->GroupOutput[group].GTargetCurrent = 0;
                    MasterStopChargingProcess(group);
                }
                else
                {
                    UpdateGunLoading(group);
                    UpdatePsuGroupOutputConfig(group);
                    UpdateMasterPsuGroupLoading(group);
                    PsuGroupOutputConfigCheck(group);
                }
                ShowGunVoltageCurrent(group);
                SetPsuGroupOutput(group);
                break;

            case _GROLE_SLAVE:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Slave", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }

                if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.SlaveCtrlValue != 0)
                {
                    SlaveStopChargingProcess(group);
                }
                else
                {
                    SetPsuGroupOutput(group);
                }
                break;

            case _GROLE_PREPARE_SWITCH_OFF:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Prepare Off", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }

                time = GetTimeoutValue(_PsuGroupRole_time[group]) / uSEC_VAL;

                if(time >= MAX_PREPARE_SWITCH_OFF_TIME)
                {
                    // timeout shall not happen
                    SetPsuGroupRole(group, _GROLE_SLAVE_POWER_OFF);
                }
                else
                {
                    SetPsuGroupOutput(group);
                }
                break;

            case _GROLE_SLAVE_POWER_OFF:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Slave Power Off", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }

                time = GetTimeoutValue(_PsuGroupRole_time[group]) / uSEC_VAL;

                if(time >= MIN_POWER_OFF_TIME &&
                    ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent <= MAX_PSU_POWER_OFF_CURRENT)
                {
                    SetPsuGroupRole(group, _GROLE_SWITCH_OFF_OK);
                }
                else
                {
                    ShmPsuGrouping->GroupOutput[group].GTargetVoltage = 0;
                    ShmPsuGrouping->GroupOutput[group].GTargetCurrent = 0;
                    SetPsuGroupOutput(group);
                }
                break;

            case _GROLE_SWITCH_OFF_OK:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Switch Off OK, %d.%d V, %d.%d A", group,
                        (ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage / 10), (ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage % 10),
                        (ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent / 10), (ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent % 10));
                    GetClockTime(&_PsuGroupRole_time[group]);
                }
                break;

            case _GROLE_WAIT_IDLE:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Wait Idle, %d.%d V, %d.%d A", group,
                        (ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage / 10), (ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage % 10),
                        (ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent / 10), (ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent % 10));
                    GetClockTime(&_PsuGroupRole_time[group]);
                }
                break;

            case _GROLE_WAIT_SLAVE:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Wait Slave", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }

                time = GetTimeoutValue(_PsuGroupRole_time[group]) / uSEC_VAL;

                if(ShmPsuGrouping->GroupCollection[group].ReservedTarget != 0)
                {
                    if(time >= WAIT_SLAVE_TO_CHARGING && (ShmPsuGrouping->GroupCollection[group].ReservedTarget - 1) == group)
                    {
                        SetPsuGroupRole(group, _GROLE_REQUEST_TO_CHARGING);
                        ShmPsuGrouping->GroupCollection[group].GroupCtrl.bits.ChargingRequest = true;
                        ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.SlaveCtrlValue = 0;
                        break;
                    }
                }
                if(time >= WAIT_SLAVE_TIMEOUT)
                {
                    PSU_LOG("Group[%02X] Wait Slave Timeout", group);
                    SetPsuGroupToIdle(group);
                }
                break;

            case _GROLE_PREPARE_ATTACH_ON:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Prepare Attach On", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }

                SetPsuGroupOutput(group);
                break;

            case _GROLE_PRECHARGE_READY:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Precharge %d.%d V Ready",
                        group, (ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage / 10), (ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage % 10));
                    GetClockTime(&_PsuGroupRole_time[group]);
                }
                break;

            case _GROLE_EXTEND_STOP:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Extend Stop", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }

                time = GetTimeoutValue(_PsuGroupRole_time[group]) / uSEC_VAL;

                if(time >= MIN_POWER_OFF_TIME ||
                    (ShmPsuData->PsuGroup[group].GroupPresentOutputCurrent <= MAX_PSU_POWER_OFF_CURRENT &&
                    ShmPsuData->PsuGroup[group].GroupPresentOutputVoltage <= MAX_PSU_POWER_OFF_VOLTAGE))
                {
                    SetPsuGroupToIdle(group);
                }
                else
                {
                    ShmPsuGrouping->GroupOutput[group].GTargetVoltage = 0;
                    ShmPsuGrouping->GroupOutput[group].GTargetCurrent = 0;
                    SetPsuGroupOutput(group);
                }
                break;

            case _GROLE_REQUEST_TO_CHARGING:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Request To Charging", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }

                if(ShmPsuGrouping->GroupCollection[group].GroupCtrl.RoleCtrl.IdleCtrlValue != 0)
                {
                    ChargingRequestProcess(group);
                }
                break;

            case _GROLE_TERMINATE:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Terminate", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }
                break;

            case _GROLE_WAIT_TERMINATED:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Wait Terminated", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }
                break;

            case _GROLE_NONE:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== None", group);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }
                break;

            default:
                if(ShmPsuGrouping->GroupCollection[group].PreRole != role)
                {
                    ShmPsuGrouping->GroupCollection[group].PreRole = role;
                    PSU_LOG("===== PSU Group[%02X] ===== Unknown Role = %d", group, role);
                    GetClockTime(&_PsuGroupRole_time[group]);
                }

                SetPsuGroupRole(group, _GROLE_NONE);
                break;
        }
    }
}

// only for test & debug purpose
void PsuGroupSimulation(void)
{
    unsigned char master = 0;
    int _groupCurrent = 0, _groupPower = 0;

    for(int i = 0; i < ShmPsuData->GroupCount; i++)
    {
        master = ShmChargerInfo->PsuGrouping.GroupCollection[i].TargetGroup;

        // calculate output group capability
        if(master == 0)
        {
            chargingInfo[i]->AvailableChargingCurrent = ShmPsuData->PsuGroup[i].GroupAvailableCurrent;
            chargingInfo[i]->AvailableChargingPower = ShmPsuData->PsuGroup[i].GroupAvailablePower;
        }
        else
        {
            _groupCurrent = ShmPsuData->PsuGroup[master - 1].GroupAvailableCurrent;
            _groupPower = ShmPsuData->PsuGroup[master - 1].GroupAvailablePower;

            for(byte j = 0; j < ShmPsuGrouping->GroupCollection[master - 1].Partner.Quantity; j++)
            {
                byte slave = ShmPsuGrouping->GroupCollection[master - 1].Partner.Member[j];

                if(ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_SLAVE ||
                    ShmPsuGrouping->GroupCollection[slave].Role == _GROLE_PREPARE_SWITCH_OFF)
                {
                    _groupCurrent += ShmPsuData->PsuGroup[slave].GroupAvailableCurrent;
                    _groupPower += ShmPsuData->PsuGroup[slave].GroupAvailablePower;
                }
            }

            if(ShmPsuGrouping->GroupCollection[master - 1].GroupCtrl.bits.DeratingConfirmed)
            {
                chargingInfo[master - 1]->AvailableChargingCurrent = ShmPsuGrouping->GroupCollection[master - 1].ReAssignAvailableCurrent;
            }
            else
            {
                chargingInfo[master - 1]->AvailableChargingCurrent = _groupCurrent;
            }
            chargingInfo[master - 1]->AvailableChargingPower = _groupPower;

            if((master - 1) != i)
            {
                chargingInfo[i]->AvailableChargingCurrent = 0;;
                chargingInfo[i]->AvailableChargingPower = 0;
                chargingInfo[i]->RealRatingPower = 0;
                chargingInfo[i]->MaximumChargingVoltage = 0;
            }
        }
    }
}

void PsuGroupingInitial(void)
{
    for(int i = 0; i < ShmPsuData->GroupCount; i++)
    {
        ShmPsuGrouping->GroupCollection[i].Role = 0;
        ShmPsuGrouping->GroupCollection[i].PreRole = 0xFF;
        memset(&ShmPsuGrouping->GroupCollection[i].Partner, 0x00, sizeof(PsuGroupPartner));
        memset(&ShmPsuGrouping->GroupCollection[i].PossibleMember, 0x00, sizeof(PsuGroupPartner));
        ShmPsuGrouping->GroupCollection[i].TargetGroup = 0;
        ShmPsuGrouping->GroupCollection[i].ReservedTarget = 0;
        memset(&ShmPsuGrouping->GroupCollection[i].GroupCtrl, 0x00, sizeof(PsuGroupControl));
        ShmPsuGrouping->GroupCollection[i].ReAssignAvailableCurrent = 0;
        ShmPsuGrouping->GroupCollection[i].ParallelCheck = 0;
        ShmPsuGrouping->GroupCollection[i].GunLoading = 0;

        memset(&ShmPsuGrouping->GroupOutput[i], 0x00, sizeof(GroupOutputConfigInfo));
    }
}

void PsuCommLostCheck(void)
{
    if(ShmPsuData->Work_Step != INITIAL_START &&
        ShmPsuData->Work_Step != _NO_WORKING &&
        ShmPsuData->Work_Step != _INIT_PSU_STATUS)
    {
        if(!isCommStart)
        {
            isCommStart = true;
            ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt = 0;
            lostCnt = 0;
            GetClockTime(&_PsuCommCheck_time);
        }

        if((GetTimeoutValue(_PsuCommCheck_time) / uSEC_VAL) >= PSU_COMM_CHECK_TIME)
        {
            ShmChargerInfo->Control.CommInfo.PsuComm.CommCnt = ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt;
            ShmChargerInfo->Control.CommInfo.PsuComm.RxCnt = 0;

            if(ShmChargerInfo->Control.CommInfo.PsuComm.CommCnt > COMM_LOST_CRITICAL)
            {
                if(ShmChargerInfo->Control.PsuCtrl.bits.CommunicationLost)
                {
                    LOG_INFO("Psu Communication Recovery");
                }
                ShmChargerInfo->Control.PsuCtrl.bits.CommunicationLost = NO;
                lostCnt = 0;
            }
            else
            {
                lostCnt++;
                if(lostCnt >= LOST_CNT_CRITICAL)
                {
                    if(!ShmChargerInfo->Control.PsuCtrl.bits.CommunicationLost)
                    {
                        LOG_INFO("Psu Communication Lost");
                    }
                    ShmChargerInfo->Control.PsuCtrl.bits.CommunicationLost = YES;
                }
            }
            GetClockTime(&_PsuCommCheck_time);
        }
    }
    else
    {
        isCommStart = false;
        ShmChargerInfo->Control.PsuCtrl.bits.CommunicationLost = NO;
        lostCnt = 0;
        /*
        if(ShmChargerInfo->Control.PsuCtrl.bits.Paused)
        {
            system("ifconfig can1 down");
            sleep(1);
            system("ifconfig can1 up");
            sleep(1);
            LOG_INFO("Psu Can Port Down & Up");
        }
        ShmChargerInfo->Control.PsuCtrl.bits.Paused = NO;
        */
    }
}

int main(void)
{
    byte _TotalModuleCount = 0;
    byte _PrePsuWorkStep = 0;
    byte isInitialComp = NO;

	if(InitShareMemory() == FAIL)
	{
		#ifdef SystemLogMessage
		LOG_ERROR("InitShareMemory NG");
		#endif
		if(ShmStatusCodeData != NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
		}
		sleep(5);
		return 0;
	}

	LOG_INFO("InitShareMemory OK");

	signal(SIGCHLD, SIG_IGN);

	// register callback function
	RefreshStatus(&GetStatusCallback);
	RefreshModuleCount(&GetModuleCountCallback);
	RefreshAvailableCap(&GetAvailableCapCallback);
	RefreshFwVersion(&GetFwCallback);
	RefreshInputVol(&GetInputVoltageCallback);
	RefreshGetOutput(&GetPresentOutputCallback);
	RefreshMisInfo(&GetMisCallback);
	RefreshIavailable(&GetIavailableCallback);
	RefreshGetOutputF(&GetPresentOutputFCallback);

	// GetPresentOutputCallback & GetStatusCallback
	AutoMode_RefreshOutputAndTemp(&GetOutputAndTempCallback);
	// GetStatusCallback
	AutoMode_RefreshModuleStatus(&GetModuleStatusCallback);
	// GetInputVoltageCallback
	AutoMode_RefreshModuleInput(&GetModuleInputCallback);

	sleep(2);
	_gunCount = GENERAL_GUN_QUANTITY;
	_maxGroupCount = GENERAL_GUN_QUANTITY;
	_PrePsuWorkStep = _INIT_PSU_STATUS;
	ShmPsuData->Work_Step = INITIAL_START;
	isInitialComp = NO;
	isCommStart = false;

	LOG_INFO("PSU Work Status = %d", ShmPsuData->Work_Step);

	// initial object
	Initialization();
	InitialPsuData();
	libInitialize = InitialCommunication();

	//main loop
	while (libInitialize)
	{
	    PsuCommLostCheck();

		// 斷電狀態
        if (ShmChargerInfo->Control.RelayCtrl.bits.AcContactor == NO ||
            ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu == YES ||
            ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency == YES ||
            ShmChargerInfo->Control.PsuCtrl.bits.NeedSelfTest == YES ||
            ShmChargerInfo->Control.PsuCtrl.bits.Paused == YES)
		{
			//一但 AC Off PSU 斷電全部的 PSU Group ID 會全部清 0
			if (!isInitialComp)
			{
			    _PrePsuWorkStep = _INIT_PSU_STATUS;
				ShmPsuData->Work_Step = INITIAL_START;
				psuCmdSeq = _PSU_CMD_STATUS;
				_TotalModuleCount = 0;
				PsuGroupingInitial();

				sleep(2);
				InitialPsuData();
				isInitialComp = YES;
			}
			if(ShmChargerInfo->Control.PsuCtrl.bits.NeedSelfTest)
			{
			    ShmChargerInfo->Control.PsuCtrl.bits.NeedSelfTest = NO;
			    ShmChargerInfo->Control.PsuCtrl.bits.SelfTestOK = NO;
			    memset(ShmChargerInfo->Control.PsuInitQuantity, 0x00, sizeof(ShmChargerInfo->Control.PsuInitQuantity));
			    LOG_INFO("Psu Need Execute Self Test!");
			}
			sleep(1);
			continue;
		}
		else
		{
            if(isInitialComp)
            {
                system("ifconfig can1 down");
                sleep(1);
                system("ifconfig can1 up");
                LOG_INFO("Psu Can Port Down & Up");
            }
            isInitialComp = NO;
		}

        // only for test & debug purpose
        if(ShmChargerInfo->Control.TestCtrl.bits.ChargingSimulation)
        {
            ShmPsuData->Work_Step = _WORK_CHARGING;

            ShmPsuData->PsuGroup[0].GroupPresentPsuQuantity = 3;
            ShmPsuData->PsuGroup[1].GroupPresentPsuQuantity = 3;
            ShmPsuData->PsuGroup[2].GroupPresentPsuQuantity = 3;
            ShmPsuData->PsuGroup[3].GroupPresentPsuQuantity = 3;

            ShmPsuData->PsuGroup[0].GroupAvailableCurrent = ShmPsuData->PsuGroup[0].GroupPresentPsuQuantity *  1000;
            ShmPsuData->PsuGroup[1].GroupAvailableCurrent = ShmPsuData->PsuGroup[1].GroupPresentPsuQuantity *  1000;
            ShmPsuData->PsuGroup[2].GroupAvailableCurrent = ShmPsuData->PsuGroup[2].GroupPresentPsuQuantity *  1000;
            ShmPsuData->PsuGroup[3].GroupAvailableCurrent = ShmPsuData->PsuGroup[3].GroupPresentPsuQuantity *  1000;

            ShmPsuData->PsuGroup[0].GroupAvailablePower = ShmPsuData->PsuGroup[0].GroupPresentPsuQuantity * 300;
            ShmPsuData->PsuGroup[1].GroupAvailablePower = ShmPsuData->PsuGroup[1].GroupPresentPsuQuantity * 300;
            ShmPsuData->PsuGroup[2].GroupAvailablePower = ShmPsuData->PsuGroup[2].GroupPresentPsuQuantity * 300;
            ShmPsuData->PsuGroup[3].GroupAvailablePower = ShmPsuData->PsuGroup[3].GroupPresentPsuQuantity * 300;

            PsuGroupSimulation();
        }

		// 自檢失敗
		if (ShmPsuData->Work_Step == _NO_WORKING)
		{
			LOG_INFO("== PSU == self test fail.");
			sleep(5);
		}

		if((GetTimeoutValue(_PsuReceiveRecoveryCheck_time) / uSEC_VAL) >= PSU_TASK_CHECK_TIME)
		{
		    PsuReceiveRecoveryCheck();
		    GetClockTime(&_PsuReceiveRecoveryCheck_time);
		}

		switch(ShmPsuData->Work_Step)
		{
			case INITIAL_START:
			{
			    if(_PrePsuWorkStep != ShmPsuData->Work_Step)
			    {
			        _PrePsuWorkStep = ShmPsuData->Work_Step;
			        LOG_INFO("== PSU == INITIAL_START");
			    }

				sleep(5);
				SwitchPower(SYSTEM_CMD, PSU_POWER_OFF);
				SetWalkInConfig(SYSTEM_CMD, NO, 0);
				for (byte index = 0; index < ShmPsuData->GroupCount; index++)
				{
					isStartOutputSwitch[index] = false;
				}
				ShmPsuData->Work_Step = GET_PSU_COUNT;
			}
				break;
            case GET_PSU_COUNT:
            {
                if(_PrePsuWorkStep != ShmPsuData->Work_Step)
                {
                    _PrePsuWorkStep = ShmPsuData->Work_Step;
                    LOG_INFO("== PSU == GET_PSU_COUNT");
                    GetClockTime(&_PsuWorkStep_time);
                    GetClockTime(&_cmdSubPriority_time);
                }

				int time = GetTimeoutValue(_PsuWorkStep_time) / uSEC_VAL;
				int interval = GetTimeoutValue(_cmdSubPriority_time) / uSEC_VAL;

				if(interval > GET_PSU_COUNT_INTERVAL)
				{
				    _TotalModuleCount = 0;

				    for (byte index = 0; index < ShmPsuData->GroupCount; index++)
				    {
				        // 總和各群模組數量
				        _TotalModuleCount += ShmPsuData->PsuGroup[index].GroupPresentPsuQuantity;
				    }

					LOG_INFO("== PSU == indexCount = %d, moduleCount = %d, sysCount = %d",
                        ShmPsuData->GroupCount, _TotalModuleCount, ShmPsuData->SystemPresentPsuQuantity);

					// 判斷系統數量與各群數量一致
					if(_TotalModuleCount == ShmPsuData->SystemPresentPsuQuantity && _TotalModuleCount > 0 &&
					        time > GET_PSU_COUNT_TIME)
					{
						LOG_INFO("Psu Count = %d", _TotalModuleCount);
                        ShmPsuData->Work_Step = Get_PSU_LOCATION;
					}
					else
					{
	                    // 發送取得目前全部模組數量
	                    GetModuleCount(SYSTEM_CMD);

	                    for (byte index = 0; index < ShmPsuData->GroupCount; index++)
	                    {
	                        // 取各群模組數量
	                        GetModuleCount(index);
	                    }
					}
					GetClockTime(&_cmdSubPriority_time);
				}
			}
				break;
            case Get_PSU_LOCATION:
            {
                if(_PrePsuWorkStep != ShmPsuData->Work_Step)
                {
                    _PrePsuWorkStep = ShmPsuData->Work_Step;
                    LOG_INFO("== PSU == Get_PSU_LOCATION");

                    // clean psu location info
                    memset(ShmPsuPosition, 0x00, sizeof(PsuPositionInfoData));

                    GetClockTime(&_cmdSubPriority_time);
                }

                int interval = GetTimeoutValue(_cmdSubPriority_time) / mSEC_VAL;

                if(interval > GET_PSU_LOCATION_INTERVAL)
                {
                    for(byte index = 0; index < ShmPsuData->GroupCount; index++)
                    {
                        if(ShmPsuData->PsuGroup[index].GroupPresentPsuQuantity > 0)
                        {
                            // 取得狀態 : 支援模塊不須按照順序功能
                            GetStatus(index);
                        }
                    }
                }

                if(ShmPsuPosition->PsuLocationInit)
                {
#if 1
                    for(int i = 0; i < _maxGroupCount; i++)
                    {
                        if(ShmPsuPosition->GroupLocationInfo[i].GroupPsuQuantity > 0)
                        {
                            ShowGroupMember(i);
                        }
                    }
#endif

                    //ShmPsuData->Work_Step = Get_PSU_VERSION;
                    ShmPsuData->Work_Step = PSU_COUNT_CONFIRM;
                }
                if(ShmPsuPosition->ReInitPsuLocation)
                {
                    LOG_INFO("Retry Psu Location Initialization");
                    ShmPsuData->Work_Step = GET_PSU_COUNT;
                }
            }
				break;
            case PSU_COUNT_CONFIRM:
            {
                if(_PrePsuWorkStep != ShmPsuData->Work_Step)
                {
                    _PrePsuWorkStep = ShmPsuData->Work_Step;
                    LOG_INFO("== PSU == PSU_COUNT_CONFIRM");

                    GetClockTime(&_PsuWorkStep_time);
                    GetClockTime(&_cmdSubPriority_time);
                }

                int time = GetTimeoutValue(_PsuWorkStep_time) / uSEC_VAL;
                int interval = GetTimeoutValue(_cmdSubPriority_time) / mSEC_VAL;

                if(interval > PSU_COUNT_CONFIRM_INTERVAL)
                {
                    _TotalModuleCount = 0;

                    for (byte index = 0; index < _maxGroupCount; index++)
                    {
                        // 總和各群模組數量
                        _TotalModuleCount += ShmPsuData->PsuGroup[index].GroupPresentPsuQuantity;
                    }

                    if(time > PSU_COUNT_CONFIRM_TIME)
                    {
                        if(_TotalModuleCount == ShmPsuData->SystemPresentPsuQuantity && _TotalModuleCount > 0)
                        {
                            ShmPsuData->Work_Step = Get_PSU_VERSION;
                        }
                        else
                        {
                            LOG_INFO("Total PSU = %d, System PSU Quantity = %d", _TotalModuleCount, ShmPsuData->SystemPresentPsuQuantity);
                            LOG_INFO("PSU Quantity Confirm Fail");

                            ShmPsuData->Work_Step = GET_PSU_COUNT;
                        }
                        break;
                    }

                    // 發送取得目前全部模組數量
                    GetModuleCount(SYSTEM_CMD);

                    for (byte index = 0; index < ShmPsuData->GroupCount; index++)
                    {
                        // 取各群模組數量
                        GetModuleCount(index);
                    }
                    GetClockTime(&_cmdSubPriority_time);
                }
            }
                break;
            case Get_PSU_VERSION:
            {
                if(_PrePsuWorkStep != ShmPsuData->Work_Step)
                {
                    _PrePsuWorkStep = ShmPsuData->Work_Step;
                    LOG_INFO("== PSU == Get_PSU_VERSION");
                    GetClockTime(&_cmdSubPriority_time);

                    // clean version info
                    memset(ShmPsuData->PsuVersion, 0x00, sizeof(ShmPsuData->PsuVersion));
                }

                int interval = GetTimeoutValue(_cmdSubPriority_time) / mSEC_VAL;

                if (interval > GET_PSU_VERSION_INTERVAL)
                {
                    bool isGetVersion = true;
                    for(byte psu = 0; psu < ShmPsuData->SystemPresentPsuQuantity; psu++)
                    {
                        if (strcmp((char *)ShmPsuData->PsuVersion[psu].FwPrimaryVersion, "") == EQUAL)
                        {
                            isGetVersion = false;
                            break;
                        }
                    }

                    if(isGetVersion)
                    {
#if 1
                        for(int i = 0; i < _maxGroupCount; i++)
                        {
                            if(ShmPsuPosition->GroupLocationInfo[i].GroupPsuQuantity > 0)
                            {
                                ShowPsuVersion(i);
                            }
                        }
#endif
                        ShmPsuData->Work_Step = GET_SYS_CAP;
                    }
                    else
                    {
                        for(byte group = 0; group < _maxGroupCount; group++)
                        {
                            if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
                            {
                                // 取版號
                                GetModuleVer(group);
                            }
                        }
                    }
                    GetClockTime(&_cmdSubPriority_time);
                }
            }
                break;
			case GET_SYS_CAP:
			{
                if(_PrePsuWorkStep != ShmPsuData->Work_Step)
                {
                    _PrePsuWorkStep = ShmPsuData->Work_Step;
                    LOG_INFO("== PSU == GET_SYS_CAP");
                    GetClockTime(&_PsuWorkStep_time);
                    GetClockTime(&_cmdSubPriority_time);
                }

                int time = GetTimeoutValue(_PsuWorkStep_time) / uSEC_VAL;
				int interval = GetTimeoutValue(_cmdSubPriority_time) / mSEC_VAL;

				if (interval > GET_PSU_CAP_INTERVAL)
				{
				    if(time > GET_PSU_CAP_TIME && ShmPsuData->SystemAvailablePower > 0 &&
                        ShmPsuData->SystemAvailableCurrent > 0)
				    {
#if 1
                        for(int i = 0; i < _maxGroupCount; i++)
                        {
                            if(ShmPsuPosition->GroupLocationInfo[i].GroupPsuQuantity > 0)
                            {
                                ShowGroupAvailableCurrentPower(i);
                            }
                        }
#endif
                        // 判斷系統輸出額定功率與電流
                        LOG_INFO("SystemAvailableCurrent = %d, SystemAvailablePower = %d",
                            ShmPsuData->SystemAvailableCurrent, ShmPsuData->SystemAvailablePower);

                        ShmPsuData->Work_Step = BOOTING_COMPLETE;
				    }
				    else
				    {
                        for(byte index = 0; index < ShmPsuData->GroupCount; index++)
                        {
                            if(ShmPsuData->PsuGroup[index].GroupPresentPsuQuantity > 0)
                            {
                                // 取系統總輸出能力
                                GetModuleCap(index);
                            }
                        }
				    }
				    GetClockTime(&_cmdSubPriority_time);
				}
			}
				break;
			case BOOTING_COMPLETE:
			{
                if(_PrePsuWorkStep != ShmPsuData->Work_Step)
                {
                    _PrePsuWorkStep = ShmPsuData->Work_Step;
                    LOG_INFO("== PSU == BOOTING_COMPLETE");
                }

				if(ShmChargerInfo->Control.PsuCtrl.bits.SelfTestOK)
				{
					ShmPsuData->Work_Step = _WORK_CHARGING;
				}
				else
				{
				    LOG_INFO("== PSU == Self Test OK!");
                    for(int i = 0; i < MAX_GROUP_QUANTITY; i++)
                    {
                        ShmChargerInfo->Control.PsuInitQuantity[i] = ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity;
                    }
				}
				ShmChargerInfo->Control.PsuCtrl.bits.SelfTestOK = true;
				sleep(1);
			}
				break;
			case _WORK_CHARGING:
			{
                if(_PrePsuWorkStep != ShmPsuData->Work_Step)
                {
                    _PrePsuWorkStep = ShmPsuData->Work_Step;
                    LOG_INFO("== PSU == _WORK_CHARGING");
                    GetClockTime(&_PsuWorkStep_time);
                    GetClockTime(&_cmdSubPriority_time);

                    PsuGroupingInitial();
                }

				int time = GetTimeoutValue(_cmdSubPriority_time) / 1000;

				// 低 Priority 的指令
				if (time > 1000)
				{
					//PreCheckSmartChargingStep();
					startModuleFlag = true;

				    for(byte group = 0; group < GENERAL_GUN_QUANTITY; group++)
				    {
				        if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
				        {
				            GetStatus(group);
				        }
				    }
                    for(byte group = 0; group < GENERAL_GUN_QUANTITY; group++)
                    {
                        if(ShmPsuData->PsuGroup[group].GroupPresentPsuQuantity > 0)
                        {
                            GetModuleInput(group);
                        }
                    }
                    GetClockTime(&_cmdSubPriority_time);
				}

				PsuGroupRoutineQuery();

				PsuGroupControlProcess();
				break;
			}
			case _TEST_MODE:
			{
				// 在測試模式中，保持與模塊的通訊
				int time = GetTimeoutValue(_cmdSubPriority_time) / 1000;

				if (time > 1500)
				{
					for (byte index = 0; index < ShmPsuData->GroupCount; index++)
					{
						// 取系統總輸出能力
						GetModuleCap(index); Await();

						// 取各群輸出電壓電流 (float)
						GetModuleOutputF(index); Await();
					}

					GetClockTime(&_cmdSubPriority_time);
				}

				byte _switch = 0x00;
				if ((chargingInfo[0]->EvBatterytargetVoltage * 10) > 0 && (chargingInfo[0]->EvBatterytargetCurrent * 10) > 0)
					_switch = 0x01;

				for (byte _groupCount_1 = 0; _groupCount_1 < conn_1_count; _groupCount_1++)
				{
					SetDirModulePresentOutput(connector_1[_groupCount_1],
						(chargingInfo[0]->EvBatterytargetVoltage * 10),
						(chargingInfo[0]->EvBatterytargetCurrent * 10),
						_switch, _switch); Await();
				}

				for (byte _groupCount_2 = 0; _groupCount_2 < conn_2_count; _groupCount_2++)
				{
					SetDirModulePresentOutput(connector_2[_groupCount_2],
						(chargingInfo[0]->EvBatterytargetVoltage * 10),
						(chargingInfo[0]->EvBatterytargetCurrent * 10),
						_switch, _switch); Await();
				}
			}
				break;
			case _INIT_PSU_STATUS:
                if(_PrePsuWorkStep != ShmPsuData->Work_Step)
                {
                    _PrePsuWorkStep = ShmPsuData->Work_Step;
                    LOG_INFO("== PSU == _INIT_PSU_STATUS");
                    GetClockTime(&_cmdSubPriority_time);
                }
			    break;
			default:
			    break;
		}
		usleep(20000);
	}
	return FAIL;
}