SmartPDCode/pro/src/switch_ctrl.c

#include "switch_ctrl.h"
#include "sqlite_handle.h"
#include "modbus_handle.h"
#include "hlw8110_habdle.h"
#include "breaker_detection.h"
#include "cfg.h"


static int switch_addr_max=255;
int g_switch_init(int addr_max)
{
    switch_addr_max = addr_max;
    return 0;
}


/// @brief 获取继电器板类型以及通道
/// @param manger 
/// @param saddr 
/// @param type 
/// @param chn 
/// @return 
int g_switch_get_type(void* manger,int saddr, int* type,int* chn,int nPowerType)
{
    
    if(nPowerType==SmartPDU_AC||nPowerType==SmartPDU_Tree_AC_One_B) //交流无法使用需要
    {
        int ret = 0 ;
        unsigned short data_temp = 0 ;
        ret = g_modbus_read_reg(manger,saddr,_SWITCH_TYPE_CHN_INFO,&data_temp);
        //ret = g_modbus_read_reg(manger,saddr,_SWITCH_DCPDU_TYPE_CHN_INFO,&data_temp);
        if(ret!=TRUE)
        {
            log_w("%s",modbus_strerror(errno));
            return -1 ;
        }

        *type = (data_temp>>8)&0xFF;
        *chn = data_temp&0xFF;
        return 0;
    }
    else{ 
        //32位读取
        int ret = 0 ;
        unsigned short data_temp[4];
        memset(data_temp,0,sizeof(data_temp));
        // ret = g_modbus_read_reg(manger,saddr,_SWITCH_TYPE_CHN_INFO,data_temp);
        // if(ret!=TRUE)
        ret = g_modbus_read_x_reg(manger,saddr,_SWITCH_DCPDU_TYPE_CHN_INFO, 2, data_temp);
        log_d("ret:%d saddr:%d data:%d,%d.\n",ret,saddr,data_temp[1],data_temp[0]);
        if (ret<=0)
        {
            log_w("Modbus Error:%s\n",modbus_strerror(errno));
            return -1 ;
        }
        *type = (data_temp[0]>>8)&0xFF;
        *chn = data_temp[0]&0xFF;
        return 0;
    }
}

/// @brief 获取单相小电流继电器板信息
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param _power 
/// @return 
int g_switch_get_ac_single_s_cur_info(void* manger,int saddr,unsigned char chn,PowerInfo* _power,PowerWarningInfo* _warning)
{
    int ret = 0 ;
    unsigned int offset = 0;
    unsigned int val = 0 ;
    unsigned short data_temp[12] = {0};
    unsigned short status_temp = 0 ;
    if(chn>=8)
        return -1;
    offset = _SWITCH_AC_SINGLE_S_CUR_INFO+chn*12;
    //读取12个寄存器
    ret = g_modbus_read_x_reg(manger,saddr,offset,12,data_temp);
    if(ret<=0)
        return -1 ;
    //解电压数据
    val = (data_temp[1]<<16)|data_temp[0];
    _power->voltage = val/1000.0;
    //解电流数据
    val = (data_temp[3]<<16)|data_temp[2];
    _power->current = val/1000.0;
    //解功率数据
    val = (data_temp[5]<<16)|data_temp[4];
    _power->power = val/1000.0;
    //解频率数据
    val = (data_temp[7]<<16)|data_temp[6];
    _power->freq = val/1000.0;
    //解耗电量数据
    val = (data_temp[9]<<16)|data_temp[8];
    _power->consumption = val/1000.0;
    //解功率因素数据
    val = (data_temp[11]<<16)|data_temp[10];
    _power->factor = val/1000.0;

#if(0)
    printf("---------%d---------------\n",chn);
    printf("voltage:%0.2f\n", _power->voltage);
    printf("current:%0.2f\n", _power->current);
    printf("power:%0.2f\n", _power->power);
    printf("freq:%0.2f\n", _power->freq);
    printf("consumption:%0.2f\n", _power->consumption);
    printf("factor:%0.2f\n", _power->factor);
    printf("-----------------------\n");
#endif
    //获取开关状态
    offset = _SWITCH_AC_SINGLE_S_STS_INFO+chn;
    ret = g_modbus_read_reg(manger,saddr,offset,&status_temp);
    if(ret!=TRUE)
        return -1 ;
    _power->status              = status_temp & BIT_00;
    _warning->w_voltage_up      = status_temp & WARNING_V_UP;
    _warning->w_voltage_down    = status_temp & WARNING_V_DOWN;
    _warning->w_current         = status_temp & WARNING_A_UP;
    _warning->w_power           = status_temp & WARNING_W_UP;
    _warning->w_consumption     = status_temp & WARNING_P_UP;
    return 0;
}
int g_switch_get_ac_single_s_all_cur_info(void* manger,int saddr,int nNumb,PowerInfo* _power,PowerWarningInfo* _warning)
{
    unsigned int offset = 0;
    unsigned int val = 0;
    unsigned short data_temp[96] = {0};
    unsigned int status_temp = 0;
    int ret = 0;
    offset = _SWITCH_AC_SINGLE_S_CUR_INFO;
    // 读取4个寄存器
    // 读取寄存器
    memset(data_temp, 0, sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger, saddr, offset, 12*nNumb, data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_s_ac_in_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }

    // 解电压数据
    for (size_t i = 0; i < nNumb; i++)
    {
        int Index = i * 12;
        // 解电压数据
        val = (data_temp[1 + Index] << 16) | data_temp[0 + Index];
        _power[i].voltage = val / 1000.0;
        // 解电流数据
        val = (data_temp[3 + Index] << 16) | data_temp[2 + Index];
        _power[i].current = val / 1000.0;
        // 解功率数据
        val = (data_temp[5 + Index] << 16) | data_temp[4 + Index];
        _power[i].power = val / 1000.0;
        // 解频率数据
        val = (data_temp[7 + Index] << 16) | data_temp[6 + Index];
        _power[i].freq = val / 1000.0;
        // 解耗电量数据
        val = (data_temp[9 + Index] << 16) | data_temp[8 + Index];
        _power[i].consumption = val / 1000.0;
        // 解功率因素数据
        val = (data_temp[11 + Index] << 16) | data_temp[10 + Index];
        _power[i].factor = val / 1000.0;
    }

    offset = _SWITCH_AC_SINGLE_S_STS_INFO;
    memset(data_temp, 0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger, saddr, offset, nNumb, data_temp);
    // 解控制数据
    if (ret < 0)
    {
        return ret;
    }    
    for (size_t i = 0; i < nNumb; i++)
    {
        status_temp=data_temp[i];
        _power[i].status              = status_temp & (BIT_00);
        _warning[i].w_voltage_up      = status_temp & (WARNING_V_UP);
        _warning[i].w_voltage_down    = status_temp & (WARNING_V_DOWN);
        _warning[i].w_current         = status_temp & (WARNING_A_UP);
        _warning[i].w_power           = status_temp & (WARNING_W_UP);
        _warning[i].w_consumption     = status_temp & (WARNING_P_UP);
    }
    return 0;
}
/// @brief 获取单相大电流继电器板信息
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param _power 
/// @return 
int g_switch_get_ac_single_b_cur_info(void* manger,int saddr,unsigned char chn,PowerInfo* _power,PowerWarningInfo* _warning)
{
    unsigned int offset = 0;
    unsigned int val = 0 ;
    unsigned short data_temp[12] = {0};
    unsigned short status_temp = 0 ;
    if(chn>=4)
        return -1;
    offset = _SWITCH_AC_SINGLE_B_CUR_INFO+chn*12;
    //读取12个寄存器
    g_modbus_read_x_reg(manger,saddr,offset,12,data_temp);    
    //解电压数据
    val = (data_temp[0]<<16)|data_temp[1];
    _power->voltage = val;
    //解电流数据
    val = (data_temp[2]<<16)|data_temp[3];
    _power->current = val;
    //解功率数据
    val = (data_temp[4]<<16)|data_temp[5];
    _power->power = val;
    //解频率数据
    val = (data_temp[6]<<16)|data_temp[7];
    _power->freq = val;
    //解耗电量数据
    val = (data_temp[8]<<16)|data_temp[9];
    _power->consumption = val;
    //解功率因素数据
    val = (data_temp[10]<<16)|data_temp[11];
    _power->factor = val;

    //获取开关状态
    offset = _SWITCH_AC_SINGLE_B_STS_INFO+chn;
    g_modbus_read_reg(manger,saddr,offset,&status_temp);

    _power->status              = status_temp & BIT_00;
    _warning->w_voltage_up      = status_temp & WARNING_V_UP;
    _warning->w_voltage_down    = status_temp & WARNING_V_DOWN;
    _warning->w_current         = status_temp & WARNING_A_UP;
    _warning->w_power           = status_temp & WARNING_W_UP;
    _warning->w_consumption     = status_temp & WARNING_P_UP;
    return 0;
}

/// @brief 获取直流继电器一路输出信息
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param _power 
/// @return 
int g_switch_get_dc_out_info(void* manger,int saddr,unsigned char chn,PowerInfo* _power,PowerWarningInfo* _warning)
{
    unsigned int offset = 0;
    unsigned int val = 0 ;
    unsigned short data_temp[12] = {0};
    unsigned short status_temp = 0 ;
    if(chn>=1)
        return -1;
    offset = _SWITCH_DC_OUT_INFO+chn*6;
    //读取12个寄存器
    g_modbus_read_x_reg(manger,saddr,offset,6,data_temp);  
    //解电压数据
    val = (data_temp[0]<<16)|data_temp[1];
    _power->voltage = val;
    //解电流数据
    val = (data_temp[2]<<16)|data_temp[3];
    _power->current = val;
    //解功率数据
    val = (data_temp[4]<<16)|data_temp[5];
    _power->power = val;

    //获取开关状态
    offset = _SWITCH_DC_STS_INFO;
    g_modbus_read_reg(manger,saddr,offset,&status_temp);
    //_power->status = status_temp;
    _power->status              = status_temp & BIT_00;
    _warning->w_voltage_up      = status_temp & WARNING_V_UP;
    _warning->w_voltage_down    = status_temp & WARNING_V_DOWN;
    _warning->w_current         = status_temp & WARNING_A_UP;
    _warning->w_power           = status_temp & WARNING_W_UP;
    _warning->w_consumption     = status_temp & WARNING_P_UP;
    return 0;
}

/// @brief 获取直流总输入信息
/// @param manger 
/// @param saddr 
/// @param _power 
/// @param _sensorVal 
/// @return 
int g_switch_get_dc_in_info(void* manger,int saddr,PowerInfo* _power,SenorTempVal* _sensorVal)
{
    unsigned int offset = 0;
    unsigned int val = 0 ;
    unsigned short data_temp[12] = {0};
    
    offset = _SWITCH_DC_IN_INFO;
    //读取12个寄存器
    g_modbus_read_x_reg(manger,saddr,offset,8,data_temp);  
    //解电压数据
    val = (data_temp[0]<<16)|data_temp[1];
    _power->voltage = val;
    //解电流数据
    val = (data_temp[2]<<16)|data_temp[3];
    _power->current = val;
    //解功率数据
    val = (data_temp[4]<<16)|data_temp[5];
    _power->power = val;
    //解温度数据
    val = data_temp[6];
    _sensorVal->temperature = val;
    //解湿度数据
    val = data_temp[7];
    _sensorVal->humidity = val;   
    return 0;
}

/// @brief 设置AC单相小电流通道开启延时时间
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param time 单位ms
/// @return 
int g_switch_set_ac_single_s_start_time_delay(void* manger,int saddr,unsigned char chn,unsigned int time)
{
    unsigned int offset = 0;
    if(chn>=8)
        return -1;    
    offset = _SWITCH_AC_SINGLE_S_START_DELAY_TIME+chn;
    int reg=g_modbus_write_reg(manger,saddr,offset,time);
    if (reg>=0)
    {
        //log_d("StartDelayTime_Addr:%d OffSet:%d Time:%d  Ret=%d",saddr,offset,time,reg);
    }
    else
    {
        log_w("StartDelayTime_Addr:%d OffSet:%d Time:%d  Ret=%d:%s",saddr,offset,time,reg,modbus_strerror(errno));
    }
    return reg ;
}

/// @brief 设置AC单相小电流通道关闭延时时间
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param time 单位ms
/// @return 
int g_switch_set_ac_single_s_stop_time_delay(void* manger,int saddr,unsigned char chn,unsigned int time)
{
    unsigned int offset = 0;
    if(chn>=8)
        return -1;    
    offset = _SWITCH_AC_SINGLE_S_STOP_DELAY_TIME+chn;
    int reg=g_modbus_write_reg(manger,saddr,offset,time);
    if (reg>=0)
    {
        //log_d("StopDelayTime_Addr:%d OffSet:%d Time:%d Ret=%d",saddr,offset,time,reg);
    }
    else
    {        
        log_w("StopDelayTime_Addr:%d OffSet:%d Time:%d Ret=%d:%s",saddr,offset,time,reg,modbus_strerror(errno));
    }
    return reg;
}

/// @brief 设置AC单相大电流通道开启延时时间
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param time 
/// @return 
int g_switch_set_ac_single_b_start_time_delay(void* manger,int saddr,unsigned char chn,unsigned int time)
{
    unsigned int offset = 0;
    if(chn>=4)
        return -1;    
    offset = _SWITCH_AC_SINGLE_B_START_DELAY_TIME+chn*2;    
    return g_modbus_write_x_reg(manger,saddr,offset,2,(unsigned short*)&time);
}


/// @brief 设置AC单相大电流通道关闭延时时间
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param time 
/// @return 
int g_switch_set_ac_single_b_stop_time_delay(void* manger,int saddr,unsigned char chn,unsigned int time)
{
    unsigned int offset = 0;
    if(chn>=4)
        return -1;    
    offset = _SWITCH_AC_SINGLE_B_STOP_DELAY_TIME+chn*2;    
    return g_modbus_write_x_reg(manger,saddr,offset,2,(unsigned short*)&time);
}


/// @brief 设置直流继电器控制板
/// @param manger 
/// @param saddr 
/// @param time 
/// @return 
int g_switch_set_dc_start_time_delay(void* manger,int saddr,unsigned int time)
{
    unsigned int offset = 0;   
    offset = _SWITCH_DC_START_DELAY_TIME;

    return g_modbus_write_x_reg(manger,saddr,offset,2,(unsigned short*)&time) ;
}

/// @brief 设置直流继电器控制板
/// @param manger 
/// @param saddr 
/// @param time 
/// @return 
int g_switch_set_dc_stop_time_delay(void* manger,int saddr,unsigned int time)
{
    unsigned int offset = 0;   
    offset = _SWITCH_DC_STOP_DELAY_TIME;
    return g_modbus_write_x_reg(manger,saddr,offset,2,(unsigned short*)&time);
}


/// @brief 设置单相小电流通道开关状态
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param sts 
/// @return 
int g_switch_set_ac_single_s_chn_ctrl(void* manger,int saddr,unsigned char chn,unsigned short sts)
{
    unsigned int offset = 0;
    if(chn>=8)
        return -1;  
    offset = _SWITCH_AC_SINGLE_S_CHN_STS+chn;    
    return g_modbus_write_reg(manger,saddr,offset,sts);
}

/// @brief 设置单相小电流所有通道开关状态
/// @param manger 
/// @param saddr 
/// @param sts 
/// @return 
int g_switch_set_ac_single_s_ctrl(void* manger,int saddr,unsigned short* sts,int nsize)
{
    if (nsize < 1 || nsize > 8)
    {
        return 0 ;
    }

    unsigned int offset = 0;
    offset = _SWITCH_AC_SINGLE_S_CHN_STS;
    return g_modbus_write_x_reg(manger,saddr,offset,nsize,sts); ;
}



/// @brief 设置单相大电流通道开关状态
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param sts 
/// @return 
int g_switch_set_ac_single_b_chn_ctrl(void* manger,int saddr,unsigned char chn,unsigned short sts)
{
    unsigned int offset = 0;
    if(chn>=4)
        return -1;  
    offset = _SWITCH_AC_SINGLE_S_CHN_STS+chn;
    g_modbus_write_reg(manger,saddr,offset,offset);
    return 0 ;
}


/// @brief 设置单相大电流所有通道开关状态
/// @param manger 
/// @param saddr 
/// @param sts 
/// @return 
int g_switch_set_ac_single_b_ctrl(void* manger,int saddr,unsigned short* sts,int nsize)
{
    if (nsize < 1 || nsize > 4)
    {
        return 0 ;
    }
    
    unsigned int offset = 0;
    offset = _SWITCH_AC_SINGLE_S_CHN_STS;
    g_modbus_write_x_reg(manger,saddr,offset,nsize,sts);
    return 0 ;
}


/// @brief 设置直流所有通道开关状态
/// @param manger 
/// @param saddr 
/// @param sts 
/// @return 
int g_switch_set_dc_ctrl(void* manger,int saddr,unsigned short sts)
{
    unsigned int offset = 0;
    offset = _SWITCH_DC_STS;
    g_modbus_write_reg(manger,saddr,offset,sts);
    return 0 ;
}

/// @brief 设置单相小电流通道超限报警
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param _global_over_manager 
/// @return 
int g_switch_set_ac_single_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{   
    unsigned int offset = 0;
    unsigned int data_temp = 0 ;
    unsigned short data_buf[16] = {0};

    //电压上限
    data_temp =  (_global_over_manager->product_vol_upper_threshold*1000);
    data_buf[0] = data_temp;
    data_buf[1] = data_temp>>16;
    //电压下限
    data_temp =  (_global_over_manager->product_vol_lower_threshold*1000);
    data_buf[2] = data_temp;
    data_buf[3] = data_temp>>16;
    //电流上限
    data_temp =  (_global_over_manager->product_cur_upper_threshold*1000);
    data_buf[4] = data_temp;
    data_buf[5] = data_temp>>16;
    //电流下限
    data_temp =  (0);
    data_buf[6] = data_temp;
    data_buf[7] = data_temp>>16;

    //功率上限
    data_temp =  (_global_over_manager->product_pwr_upper_threshold*1000);
    data_buf[8] = data_temp;
    data_buf[9] = data_temp>>16;
    //功率下限
    data_temp =  0;
    data_buf[10] = data_temp;
    data_buf[11] = data_temp>>16;

    //电能上限
    data_temp =  (_global_over_manager->product_pwrcon_upper_threshold*1000);
    data_buf[12] = data_temp;
    data_buf[13] = data_temp>>16;
    //电能下限
    data_temp =  0;
    data_buf[14] = data_temp;
    data_buf[15] = data_temp>>16;

    offset = _SWITCH_AC_SINGLE_S_Threshold+chn*16;

    int ret= g_modbus_write_x_reg(manger,saddr,offset,16,data_buf);

    //log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
    return ret;
}
int g_switch_set_ac_reset(void *manger, int saddr)
{
    // 清空报警使能
    unsigned short data_temp1[8] = {0};
    unsigned int offset = 0;
    int ret = 0;
    offset = _SWITCH_AC_SINGLE_S_CHN_STS;
    PowerInfo *pPowerInfo = __globalDeviceManage.pCtrlBoard[saddr]._PowerInfo;
    if (pPowerInfo != NULL)
    {
        memset(data_temp1, 0, sizeof(data_temp1));
        for (size_t i = 0; i < __globalDeviceManage.pCtrlBoard[saddr].product_number; i++)
        {
            data_temp1[i] = pPowerInfo[i].status;
        }
        ret = g_modbus_write_x_reg(manger, saddr, offset, __globalDeviceManage.pCtrlBoard[saddr].product_number, data_temp1);
        if (ret < 0)
        {
            return ret;
        }
    }
    return ret;
}

/// @brief 设置单相小电流通道KB
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param sts 
/// @return 
int g_switch_set_ac_single_s_kb_val(void* manger,int saddr,unsigned char chn,SwitchKbVal* _kb_val)
{
    unsigned int offset = 0;
    unsigned int rval = 0 ;
    unsigned short data_temp[8] = {0};
    if(chn>=8)
        return -1;  
    offset = _SWITCH_AC_SINGLE_S_KB_VAL+chn*8;
    data_temp[0] = (unsigned short)_kb_val->voltage_k;
    data_temp[1] = (unsigned short)((_kb_val->voltage_k-data_temp[0])*1000);
    data_temp[2] = (unsigned short)_kb_val->voltage_b;
    data_temp[3] = (unsigned short)((_kb_val->voltage_b-data_temp[2])*1000);
    data_temp[4] = (unsigned short)_kb_val->current_k;
    data_temp[5] = (unsigned short)((_kb_val->current_k-data_temp[4])*1000);
    data_temp[6] = (unsigned short)_kb_val->current_b;
    data_temp[7] = (unsigned short)((_kb_val->current_b-data_temp[6])*1000);
    g_modbus_write_x_reg(manger,saddr,offset,8,data_temp);
    return 0 ;
}

/// @brief 设置单相大电流通道KB
/// @param manger 
/// @param saddr 
/// @param chn 
/// @param _kb_val 
/// @return 
int g_switch_set_ac_single_b_kb_val(void* manger,int saddr,unsigned char chn,SwitchKbVal* _kb_val)
{
    unsigned int offset = 0;
    unsigned int rval = 0 ;
    unsigned short data_temp[8] = {0};
    if(chn>=4)
        return -1;  
    offset = _SWITCH_AC_SINGLE_B_KB_VAL+chn*8;
    data_temp[0] = (unsigned short)_kb_val->voltage_k;
    data_temp[1] = (unsigned short)((_kb_val->voltage_k-data_temp[0])*1000);
    data_temp[2] = (unsigned short)_kb_val->voltage_b;
    data_temp[3] = (unsigned short)((_kb_val->voltage_b-data_temp[2])*1000);
    data_temp[4] = (unsigned short)_kb_val->current_k;
    data_temp[5] = (unsigned short)((_kb_val->current_k-data_temp[4])*1000);
    data_temp[6] = (unsigned short)_kb_val->current_b;
    data_temp[7] = (unsigned short)((_kb_val->current_b-data_temp[6])*1000);
    g_modbus_write_x_reg(manger,saddr,offset,8,data_temp);
    return 0 ;
}


/// @brief 设置直流KB值
/// @param manger 
/// @param saddr 
/// @param _kb_val 
/// @return 
int g_switch_set_dc_kb_val(void* manger,int saddr,SwitchKbVal* _kb_val)
{
    unsigned short offset = 0;
    unsigned short data_temp[8] = {0};
    offset = _SWITCH_DC_KB_VAL;
    data_temp[0] = (unsigned short)_kb_val->voltage_k;
    data_temp[1] = (unsigned short)((_kb_val->voltage_k-data_temp[0])*1000);
    data_temp[2] = (unsigned short)_kb_val->voltage_b;
    data_temp[3] = (unsigned short)((_kb_val->voltage_b-data_temp[2])*1000);
    data_temp[4] = (unsigned short)_kb_val->current_k;
    data_temp[5] = (unsigned short)((_kb_val->current_k-data_temp[4])*1000);
    data_temp[6] = (unsigned short)_kb_val->current_b;
    data_temp[7] = (unsigned short)((_kb_val->current_b-data_temp[6])*1000);
    g_modbus_write_x_reg(manger,saddr,offset,8, data_temp);
    return 0 ;
}

/// @brief 通用设置通道起始延时时间
/// @param manger   管理类
/// @param ntype    通道类型
/// @param saddr    地址
/// @param chn      偏移    
/// @param time     延时毫秒（ms）
/// @return 0:成功 1失败
int g_switch_set_all_start_time_delay(void* manger,int ntype,int saddr,unsigned char chn,unsigned int time)
{
    switch (ntype) 
    {
    case AC_SINGLE_S_TYPE:
    case AC_SINGLE_B_TYPE:
    {
        return g_switch_set_ac_single_s_start_time_delay(manger,saddr,(chn-1),time);
    }
    break;
    case DC_OUT_TYPE:
    {
        //g_switch_set_dc_start_time_delay(manger,saddr,chn,time);
    }
    break;
    case DCPDU_TYPE:
    {
        return g_switch_set_dcpdu_start_time_delay(manger, saddr,(chn-1), time/1000);
    }
    break;
    case TREE_AC_TYPE:
    {
        int ret = 0;
        if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree)
        {
            ret = g_switch_set_t_ac_start_time_delay(manger, saddr, (chn - 1) * 3, time / 1000);
            if (ret < 0)
            {
                ret = g_switch_set_t_ac_start_time_delay(manger, saddr, (chn - 1) * 3, time / 1000);
                if (ret < 0)
                    return ret;
            }
            ret = g_switch_set_t_ac_start_time_delay(manger, saddr, (chn - 1) * 3 + 1, time / 1000);
            if (ret < 0)
            {
                ret = g_switch_set_t_ac_start_time_delay(manger, saddr, (chn - 1) * 3 + 1, time / 1000);
                if (ret < 0)
                    return ret;
            }
            ret = g_switch_set_t_ac_start_time_delay(manger, saddr, (chn - 1) * 3 + 2, time / 1000);
            if (ret < 0)
            {
                ret = g_switch_set_t_ac_start_time_delay(manger, saddr, (chn - 1) * 3 + 2, time / 1000);
                if (ret < 0)
                    return ret;
                return ret;
            }
        }
        else
        {
            ret = g_switch_set_t_ac_start_time_delay(manger, saddr, (chn - 1), time / 1000);
            if (ret < 0)
            {
                ret = g_switch_set_t_ac_start_time_delay(manger, saddr, (chn - 1), time / 1000);
                if (ret < 0)
                    return ret;
            }
        }

        return 0;
    }
    case AC_MULTI_S_TYPE:
    case AC_MULTI_B_TYPE:
    case DC_IN_TYPE:
    default:
        return 1;
        break;
    }
    return 1;
}

/// @brief 通用设置通道起始延时时间
/// @param manger   管理类
/// @param ntype    通道类型
/// @param saddr    地址
/// @param chn      偏移    
/// @param time     延时毫秒（ms）
/// @return 0:成功 1失败
int g_switch_set_all_stop_time_delay(void* manger,int ntype,int saddr,unsigned char chn,unsigned int time)
{
    switch (ntype) 
    {
    case AC_SINGLE_S_TYPE:
    case AC_SINGLE_B_TYPE:
    {
        return g_switch_set_ac_single_s_stop_time_delay(manger, saddr, (chn - 1), time);
    }
    break;
    case DC_OUT_TYPE:
    {

    }
    break;
    case DCPDU_TYPE:
    {
        return g_switch_set_dcpdu_stop_time_delay(manger, saddr,(chn-1), time/1000);
    }
    break;
    case TREE_AC_TYPE:
    {
        int ret = 0;
        if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree)
        {
            ret = g_switch_set_t_ac_stop_time_delay(manger, saddr, (chn - 1) * 3, time / 1000);
            if (ret < 0)
            {
                ret = g_switch_set_t_ac_stop_time_delay(manger, saddr, (chn - 1) * 3, time / 1000);
                if (ret < 0)
                    return ret;
            }
            ret = g_switch_set_t_ac_stop_time_delay(manger, saddr, (chn - 1) * 3 + 1, time / 1000);
            if (ret < 0)
            {
                ret = g_switch_set_t_ac_stop_time_delay(manger, saddr, (chn - 1) * 3 + 1, time / 1000);
                if (ret < 0)
                    return ret;
            }
            ret = g_switch_set_t_ac_stop_time_delay(manger, saddr, (chn - 1) * 3 + 2, time / 1000);
            if (ret < 0)
            {
                ret = g_switch_set_t_ac_stop_time_delay(manger, saddr, (chn - 1) * 3 + 2, time / 1000);
                if (ret < 0)
                    return ret;
            }
        }
        else
        {
            ret = g_switch_set_t_ac_stop_time_delay(manger, saddr, (chn - 1), time / 1000);
            if (ret < 0)
            {
                ret = g_switch_set_t_ac_stop_time_delay(manger, saddr, (chn - 1), time / 1000);
                if (ret < 0)
                    return ret;
            }
        }
        return 0;
    }
    case AC_MULTI_S_TYPE:
    case AC_MULTI_B_TYPE:
    case DC_IN_TYPE:
    default:
        return 1;
        break;
    }
    return 1;
}
/// @brief 通用设置通道控制
/// @param manger   管理类
/// @param ntype    通道类型
/// @param saddr    地址
/// @param chn      偏移    
/// @param sts      open/close
/// @return 0:成功 1失败
int g_switch_set_all_chn_ctrl(void* manger,GlobalPowerManger* _globalPowerMangerTemp,int saddr,unsigned char chn,unsigned short sts,bool isgroup)
{

    switch (_globalPowerMangerTemp->product_ch_type)
    {
    case AC_SINGLE_S_TYPE:
    case AC_SINGLE_B_TYPE:
    {
       /* if (sts == 1)*/
        {
            if (_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable == 1)
                sts |= ENABLE_V_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable == 1)
                sts |= ENABLE_V_DOWN;
            if (_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable == 1)
                sts |= ENABLE_A_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable == 1)
                sts |= ENABLE_W_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable == 1)
                sts |= ENABLE_P_UP;
        }
        return g_switch_set_ac_single_s_chn_ctrl(manger, saddr, (chn - 1), sts);
    }
    break;
    /*
    case AC_SINGLE_B_TYPE:
    {
        if (sts==1)
        {
            if(_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable==1)sts|=ENABLE_V_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable==1)sts|=ENABLE_V_DOWN;
            if(_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable==1)sts|=ENABLE_A_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable==1)sts|=ENABLE_W_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable==1)sts|=ENABLE_P_UP;
        }
        return g_switch_set_ac_single_b_chn_ctrl(manger,saddr,(chn-1),sts);
    }
    break;*/
    case DC_OUT_TYPE:
    {
        // return g_switch_set_dc_ctrl();
    }
    break;
    case DCPDU_TYPE:
    {
        return g_switch_set_dcpdu_chn_ctrl(manger, saddr, (chn - 1), sts);
    }
    break;
    case TREE_AC_TYPE:
    {
        int t_ac_CtrlType=0;
        int nRet = 0;
        GlobalTreeACManager *_globalTACManager = NULL;
        list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
        {
            t_ac_CtrlType=_globalTACManager->product_ph_outputType;
        }
        if (t_ac_CtrlType == 2&&__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_Tree)
        {
            unsigned short phsts=0;
            
            list_for_each_entry(_globalTACManager, &_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
            {
                if (/*sts == 1&&*/_globalTACManager->product_ph_outputStatus==1)
                {
                    phsts=sts;
                    if (_globalTACManager->global_over_manager->product_vol_upper_enable == 1)
                        phsts |= ENABLE_TAC_V_UP;
                    if (_globalTACManager->global_over_manager->product_vol_lower_enable == 1)
                        phsts |= ENABLE_TAC_V_DOWN;
                    if (_globalTACManager->global_over_manager->product_cur_upper_enable == 1)
                        phsts |= ENABLE_TAC_A_UP;
                    if (_globalTACManager->global_over_manager->product_pwr_upper_enable == 1)
                        phsts |= ENABLE_TAC_W_UP;
                    if (_globalTACManager->global_over_manager->product_pwrcon_upper_enable == 1)
                        phsts |= ENABLE_TAC_P_UP;
                }else{
                    phsts=0;
                }
                nRet= g_switch_set_t_ac_phchn_ctrl(manger, _globalTACManager->product_saddr, _globalTACManager->product_ch_addr - 1, phsts);
                if (nRet<0)
                {
                    log_w("g_switch_set_t_ac_phchn_ctrl addr:%d chn:%d Error: %s",_globalTACManager->product_saddr, _globalTACManager->product_ch_addr - 1,modbus_strerror(errno));
                    nRet= g_switch_set_t_ac_phchn_ctrl(manger, saddr, _globalTACManager->product_ch_addr - 1, phsts);
                    if (nRet<0)
                    {
                        log_w("reset g_switch_set_t_ac_phchn_ctrl Error: %s",modbus_strerror(errno));
                        return nRet;
                    }                    
                }                
            }
            return 1;
        }
        else
        {
            //if (sts == 1)
            {
                if (_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable == 1)
                    sts |= ENABLE_TAC_V_UP;
                if (_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable == 1)
                    sts |= ENABLE_TAC_V_DOWN;
                if (_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable == 1)
                    sts |= ENABLE_TAC_A_UP;
                if (_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable == 1)
                    sts |= ENABLE_TAC_W_UP;
                if (_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable == 1)
                    sts |= ENABLE_TAC_P_UP;
            }
            /*
            if (isgroup)
            {
                sts |= ENABLE_TAC_STIME;
                sts |= ENABLE_TAC_ETIME;
            }*/
            if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One)
            {
                return g_switch_set_t_ac_phchn_ctrl(manger, saddr, (chn - 1), sts);
            }else{
                return g_switch_set_t_ac_chn_ctrl(manger, saddr, (chn - 1), sts);
            }
            
            
        }
    }
    case AC_MULTI_S_TYPE:
    case AC_MULTI_B_TYPE:
    case DC_IN_TYPE:
    default:
        return 1;
        break;
    }
    return 1;
}

int g_switch_set_all_ctrl(void* manger,int ntype,int saddr,unsigned short sts)
{
    GlobalPowerManger* _globalPowerMangerTemp = NULL ;
    unsigned short switch_ctrl[AC_SINGLE_S_CUR_CHN_NUM] = {0};
    for (size_t i = 0; i < AC_SINGLE_S_CUR_CHN_NUM; i++)
    {
        switch_ctrl[i] = sts ;
    }
    
    switch (ntype) 
    {
    case AC_SINGLE_S_TYPE:
    {
        int nchNum=0;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if(_globalPowerMangerTemp->product_saddr != saddr)continue;
            int nchAddr=_globalPowerMangerTemp->product_ch_addr-1;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable==1)switch_ctrl[nchAddr]|=ENABLE_V_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable==1)switch_ctrl[nchAddr]|=ENABLE_V_DOWN;
            if(_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable==1)switch_ctrl[nchAddr]|=ENABLE_A_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable==1)switch_ctrl[nchAddr]|=ENABLE_W_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable==1)switch_ctrl[nchAddr]|=ENABLE_P_UP;
            int nStatus=switch_ctrl[nchAddr]&BIT_00;
            if(nStatus==1)
            {
                switch_ctrl[nchAddr]|=ENABLE_ALL_UP;
            }else{
                switch_ctrl[nchAddr]|=ENABLE_ALL_DOWN;
            }

            nchNum++;
        }
        return g_switch_set_ac_single_s_ctrl(manger, saddr, switch_ctrl,nchNum);
    }
    break;
    case AC_SINGLE_B_TYPE:
    {
        int nchNum=0;
        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
        {
            if(_globalPowerMangerTemp->product_saddr != saddr)continue;
            int nchAddr=_globalPowerMangerTemp->product_ch_addr-1;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable==1)switch_ctrl[nchAddr]|=ENABLE_V_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable==1)switch_ctrl[nchAddr]|=ENABLE_V_DOWN;
            if(_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable==1)switch_ctrl[nchAddr]|=ENABLE_A_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable==1)switch_ctrl[nchAddr]|=ENABLE_W_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable==1)switch_ctrl[nchAddr]|=ENABLE_P_UP;
            int nStatus=switch_ctrl[nchAddr]&BIT_00;
            if(nStatus==1)
            {
                switch_ctrl[nchAddr]|=ENABLE_ALL_UP;
            }else{
                switch_ctrl[nchAddr]|=ENABLE_ALL_DOWN;
            }
            nchNum++;
        }
        return g_switch_set_ac_single_b_ctrl(manger,saddr,switch_ctrl,nchNum);
    }
    break;
    case DC_OUT_TYPE:
    {
        //return g_switch_set_dc_ctrl();
    }
    break;
    case DCPDU_TYPE:
    {
        return g_switch_set_dcpdu_ctrl(manger, saddr, switch_ctrl);
    }
    break;
    case TREE_AC_TYPE:
    {
        return g_switch_set_t_ac_ctrl(manger, saddr,switch_ctrl);
    }
    case AC_MULTI_S_TYPE:
    case AC_MULTI_B_TYPE:
    case DC_IN_TYPE:
    default:
        return 1;
        break;
    }
    return 1;
}

int g_switch_set_all_single_threshold(void* manger,int ntype,int saddr,char chn,GlobalPowerManger* _globalPowerMangerTemp)
{
    int ret =0;   
    int sts=_globalPowerMangerTemp->_PowerInfo.status;
    GlobalOverManager* _global_over_manager=_globalPowerMangerTemp->global_over_manager;
    if (chn == 0)
    {
        ret = g_switch_set_t_ac_in_threshold(manger, 1, _global_over_manager);
    }
    else
    {
        switch (ntype)
        {
        case AC_SINGLE_S_TYPE:
        case AC_SINGLE_B_TYPE:
        {
            ret = g_switch_set_ac_single_threshold(manger, saddr, (chn - 1), _global_over_manager);
            if (_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable == 1)
                sts |= ENABLE_V_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable == 1)
                sts |= ENABLE_V_DOWN;
            if (_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable == 1)
                sts |= ENABLE_A_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable == 1)
                sts |= ENABLE_W_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable == 1)
                sts |= ENABLE_P_UP;
            ret = g_switch_set_ac_alarm_ctrl(manger, saddr, (chn - 1), _global_over_manager);
            return g_switch_set_ac_single_s_chn_ctrl(manger, saddr, (chn - 1), sts);
        }
        break;
        case DC_OUT_TYPE:
        {
            // return g_switch_set_dc_ctrl();
        }
        break;
        case DCPDU_TYPE:
        {
            ret = g_switch_set_dcpdu_max_vol_threshold(manger, saddr, (chn - 1), _global_over_manager);
            ret = g_switch_set_dcpdu_min_vol_threshold(manger, saddr, (chn - 1), _global_over_manager);
            ret = g_switch_set_dcpdu_max_cur_threshold(manger, saddr, (chn - 1), _global_over_manager);
            ret =g_switch_set_dcpdu_max_power_threshold(manger, saddr, (chn - 1), _global_over_manager);
            ret =g_switch_set_dcpdu_max_pwrcon_threshold(manger, saddr, (chn - 1), _global_over_manager);

            ret = g_switch_set_dcpdu_alarm_ctrl(manger, saddr, (chn - 1), _global_over_manager);
            return ret;
        }
        break;
        case TREE_AC_TYPE:
        {
            ret = g_switch_set_t_ac_max_vol_threshold(manger, saddr, (chn - 1), _global_over_manager);
            if (ret < 0)
            {
                log_e("Threshold Set Error=%s", modbus_strerror(errno));
            }
            ret = g_switch_set_t_ac_min_vol_threshold(manger, saddr, (chn - 1), _global_over_manager);
            if (ret < 0)
            {
                log_e("Threshold Set Error=%s", modbus_strerror(errno));
            }
            ret = g_switch_set_t_ac_max_cur_threshold(manger, saddr, (chn - 1), _global_over_manager);
            if (ret < 0)
            {
                log_e("Threshold Set Error=%s", modbus_strerror(errno));
            }
            ret = g_switch_set_t_ac_max_power_threshold(manger, saddr, (chn - 1), _global_over_manager);
            if (ret < 0)
            {
                log_e("Threshold Set Error=%s", modbus_strerror(errno));
            }
            ret = g_switch_set_t_ac_max_pwrcon_threshold(manger, saddr, (chn - 1), _global_over_manager);
            if (ret < 0)
            {
                log_e("Threshold Set Error=%s", modbus_strerror(errno));
            }
            ret = g_switch_set_t_ac_alarm_ctrl(manger, saddr, (chn - 1), _global_over_manager);
            if (ret < 0)
            {
                log_e("Threshold AlarmCtrl Set Error=%s", modbus_strerror(errno));
            }
            if (_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable == 1)
                sts |= ENABLE_TAC_V_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable == 1)
                sts |= ENABLE_TAC_V_DOWN;
            if (_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable == 1)
                sts |= ENABLE_TAC_A_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable == 1)
                sts |= ENABLE_TAC_W_UP;
            if (_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable == 1)
                sts |= ENABLE_TAC_P_UP;
            if (__globalDeviceManage._globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One)
            {
                return g_switch_set_t_ac_phchn_ctrl(manger, saddr, (chn - 1), sts);
            }else{
                return g_switch_set_t_ac_chn_ctrl(manger, saddr, (chn - 1), sts);
            }
            
            return ret;
        }
        break;
        case AC_MULTI_S_TYPE:
        case AC_MULTI_B_TYPE:
        case DC_IN_TYPE:
        default:
            return 1;
            break;
        }
    }
    return 1;
}
int g_switch_get_all_out_info(void* manger,int ntype,int saddr,int nNumb,PowerInfo* _power,PowerWarningInfo* _warning)
{
    switch (ntype)
    {
    case AC_SINGLE_S_TYPE:
    case AC_SINGLE_B_TYPE:
    {
        return g_switch_get_ac_single_s_all_cur_info(manger, saddr, nNumb, _power, _warning);
    }
    break;
    case DCPDU_TYPE:
    {
        return g_switch_get_dcpdu_all_out_info(manger, saddr, nNumb, _power, _warning);
    }
    break;
    case TREE_AC_TYPE:
    {
        return g_switch_get_t_ac_all_out_info(manger, saddr, nNumb, _power, _warning);
    }
    break;
    case AC_MULTI_S_TYPE:
    case AC_MULTI_B_TYPE:
    case DC_IN_TYPE:
    default:
        return 1;
        break;
    }
    return 1;
}
int g_switch_get_all_reset(void* manger,int ntype,int saddr)
{
    switch (ntype)
    {
    case AC_SINGLE_S_TYPE:
    case AC_SINGLE_B_TYPE:
    {
        return g_switch_set_ac_reset(manger, saddr);
    }
    break;
    case DCPDU_TYPE:
    {
        return g_switch_set_dcpdu_reset(manger, saddr);
    }
    break;
    case TREE_AC_TYPE:
    {
        return g_switch_set_t_ac_reset(manger, saddr);
    }
    break;
    case AC_MULTI_S_TYPE:
    case AC_MULTI_B_TYPE:
    case DC_IN_TYPE:
    default:
        return 1;
        break;
    }
    return 1;

}
int g_switch_get_dcpdu_out_info(void* manger,int saddr,unsigned char chn,PowerInfo* _power,PowerWarningInfo* _warning)
{
    unsigned int offset = 0;
    unsigned int val = 0 ;
    unsigned short data_temp[12] = {0};
    unsigned int status_temp = 0 ;
   
    offset = _SWITCH_DCPDU_OUT_INFO + chn * 4;
    //读取4个寄存器
    int ret = g_modbus_read_x_reg(manger,saddr,offset,8,data_temp);  
    //解电压数据
    float value = (data_temp[1] << 16) + data_temp[0];
    _power->voltage = value / 1000.0;
    //解电流数据
    value = (data_temp[3] << 16) + data_temp[2];
    _power->current = value / 1000.0;
    //解功率数据
    value = (data_temp[5] << 16) + data_temp[4];
    _power->power = value / 1000.0;

    value = (data_temp[7] << 16) + data_temp[6];
    _power->consumption = value / 1000.0;

    //获取开关状态
    offset = _SWITCH_DCPDU_STS_INFO;
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset, 2, data_temp);
    status_temp = (data_temp[1] << 16) + data_temp[0];
    _power->status = (status_temp >> chn) & 0x1;

    //获取故障状态
    offset = _SWITCH_DCPDU_STS_ERROR;
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset, 2, data_temp);
    status_temp = (data_temp[1] << 16) + data_temp[0];
    _warning->w_voltage_up = (status_temp >> chn) & 0x1;
    return ret;
}
int g_switch_get_dcpdu_all_out_info(void* manger,int saddr,int nNumb,PowerInfo* _power,PowerWarningInfo* _warning)
{
    unsigned int offset = 0;
    unsigned int value = 0;
    unsigned short data_temp[64] = {0};
    unsigned int status_temp = 0;
    int ret = 0;
    offset = _SWITCH_DCPDU_OUT_INFO;
    // 读取4个寄存器
    // 读取寄存器
    memset(data_temp, 0, sizeof(data_temp));
   
   //一次读2个
   /*
    ret = g_modbus_read_x_reg(manger, saddr, offset, 16, data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_t_dcpdu_info:addrs:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }
    offset = _SWITCH_T_AC_OUT_INFO + 8;
    unsigned short *DataTemp = data_temp + 16;
    ret = g_modbus_read_x_reg(manger, saddr, offset, 16, DataTemp);
    if (ret < 0)
    {
        log_w("g_switch_get_t_dcpdu_info:addrs:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }
    offset = _SWITCH_T_AC_OUT_INFO + 16;
    DataTemp = data_temp + 32;
    ret = g_modbus_read_x_reg(manger, saddr, offset, 16, DataTemp);
    if (ret < 0)
    {
        log_w("g_switch_get_t_dcpdu_info:addrs:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }
    offset = _SWITCH_T_AC_OUT_INFO + 24;
    DataTemp = data_temp + 48;
    ret = g_modbus_read_x_reg(manger, saddr, offset, 16, DataTemp);
    if (ret < 0)
    {
        log_w("g_switch_get_t_dcpdu_info:addrs:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }
    */
    //一次读4个
    ret = g_modbus_read_x_reg(manger, saddr, offset, 32, data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_t_dcpdu_info:addrs:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }
    offset = _SWITCH_DCPDU_OUT_INFO + 16;
    unsigned short *DataTemp = data_temp + 32;
    ret = g_modbus_read_x_reg(manger, saddr, offset, 32, DataTemp);
    if (ret < 0)
    {
        log_w("g_switch_get_t_dcpdu_info:addrs:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }



    // 解电压数据
    for (size_t i = 0; i < nNumb; i++)
    {
        int Index = i * 8;
        // 解电压数据
        float value = (data_temp[1 + Index] << 16) + data_temp[0 + Index];
        _power[i].voltage = value / 1000.0;
        // 解电流数据
        value = (data_temp[3 + Index] << 16) + data_temp[2 + Index];
        _power[i].current = value / 1000.0;
        // 解功率数据
        value = (data_temp[5 + Index] << 16) + data_temp[4 + Index];
        _power[i].power = value / 1000.0;

        value = (data_temp[7 + Index] << 16) + data_temp[6 + Index];
        _power[i].consumption = value / 1000.0;
    }

    offset = _SWITCH_DCPDU_STS_INFO;
    // 读取寄存器
    memset(data_temp, 0, sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger, saddr, offset, 2, data_temp);
    // 解控制数据
    if (ret < 0)
    {
        return ret;
    }
    for (size_t i = 0; i < nNumb; i++)
    {
        status_temp = (data_temp[1] << 16) + data_temp[0];
        _power[i].status = (status_temp >> i) & 0x1;
    }
    // 获取报警状态
    offset = _SWITCH_DCPDU_WARNING;
    memset(data_temp, 0, sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger, saddr, offset, 16, data_temp);
    if (ret < 0)
    {
        return ret;
    }
    for (size_t i = 0; i < nNumb; i++)
    {
        int Index = i * 2;
        _warning[i].w_voltage_up = data_temp[0 + Index] & BIT_00;
        _warning[i].w_voltage_down = data_temp[0 + Index] & BIT_01;
        _warning[i].w_current = data_temp[0 + Index] & BIT_02;
        _warning[i].w_power = data_temp[0 + Index] & BIT_03;
        _warning[i].w_consumption = data_temp[0 + Index] & BIT_04;
    }
    return 0;
}
int g_switch_get_dcpdu_in_info(void* manger,int saddr,PowerInfo* _power)
{
    unsigned int offset = 0;
    unsigned int value = 0 ;
    unsigned short data_temp[18] = {0};
    
    offset = _SWITCH_DCPDU_IN_INFO;
    //读取4个寄存器
    g_modbus_read_x_reg(manger,saddr,offset,16,data_temp);  
    //解电压数据
    value = (data_temp[1] << 16) + data_temp[0];
    _power->voltage = value / 1000.0;
    //解电流数据
    value = (data_temp[3] << 16) + data_temp[2];
    _power->current = value / 1000.0;
    //解功率数据
    value = (data_temp[5] << 16) + data_temp[4];
    _power->power = value / 1000.0;
    value = (data_temp[7] << 16) + data_temp[6];
    _power->consumption = value / 1000.0;

    return 0;
}

int g_switch_get_dcpdu_start_time_delay(void* manger,int saddr,unsigned int* time)
{
    unsigned int offset = 0;
    unsigned short data_temp[16];
    offset = _SWITCH_DCPDU_START_DELAY_TIME;
    int ret = g_modbus_read_x_reg(manger,saddr,offset,16,data_temp);
    unsigned int value = 0;
    for(int i = 0; i < 8; i++)
    {
        value = (data_temp[i * 2  + 1] << 16) + data_temp[i * 2];
        time[i] = value;
    }

    return ret;
}

int g_switch_get_dcpdu_stop_time_delay(void* manger,int saddr,unsigned int* time)
{
    unsigned int offset = 0;
    unsigned short data_temp[16];
    offset = _SWITCH_DCPDU_STOP_DELAY_TIME;
    int ret = g_modbus_read_x_reg(manger,saddr,offset,16,data_temp);
    unsigned int value = 0;
    for(int i = 0; i < 8; i++)
    {
        value = (data_temp[i * 2  + 1] << 16) + data_temp[i * 2];
        time[i] = value;
    }

    return ret;
}

int g_switch_set_dcpdu_start_time_delay(void* manger,int saddr, int ch,unsigned int time)
{
    unsigned int offset = 0;
    unsigned short data_temp[4];

    offset = _SWITCH_DCPDU_START_DELAY_TIME + ch ;
    data_temp[0] = time & 0xFFFF;
    data_temp[1] = (time >> 16) & 0XFFFF;
    
    int reg = g_modbus_write_x_reg(manger,saddr,offset,2,data_temp);
    if (reg>=0)
    {
        log_d("StartDelayTime_Addr:%d ch:%d OffSet:%d Time:%d Ret=%d",saddr,ch,offset,time,reg);
    }
    else
    {        
        log_w("StartDelayTime_Addr:%d ch:%d OffSet:%d Time:%d Ret=%d:%s",saddr,ch,offset,time,reg,modbus_strerror(errno));
    }
    return reg;
    
}

int g_switch_set_dcpdu_stop_time_delay(void* manger,int saddr, int ch, unsigned int time)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    
    offset = _SWITCH_DCPDU_STOP_DELAY_TIME + ch;
    data_temp[0] = time & 0XFFFF;
    data_temp[1] = (time >> 16) & 0xFFFF;

    int reg =  g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
    if (reg>=0)
    {
        log_d("StopDelayTime_Addr:%d ch:%d OffSet:%d Time:%d Ret=%d",saddr,ch,offset,time,reg);
    }
    else
    {        
        log_w("StopDelayTime_Addr:%d ch:%d OffSet:%d Time:%d Ret=%d:%s",saddr,ch,offset,time,reg,modbus_strerror(errno));
    }
    return reg;
}

int g_switch_set_dcpdu_chn_ctrl(void* manger,int saddr,unsigned char chn,unsigned short sts)
{
    unsigned int offset = 0;
    if(chn > 8 || chn < 0) return -1;
    offset = _SWITCH_DCPDU_STS_INFO;

    unsigned short data_temp[2]; 
    //memset(data_temp,0,sizeof(data_temp));

    int ret=g_modbus_read_x_reg_delay(manger,saddr,offset,2, data_temp);
    if (ret<0)
    {
        log_w("Ctrl Error Ret=%d:%s",ret,modbus_strerror(errno));
        return -1;
    }
    log_w("Ctrl get addr%d Mark=%d,%d",saddr,data_temp[1],data_temp[0]);
    unsigned short mask = ~(1 << chn);
    data_temp[0] &= mask;
    data_temp[0] |= (sts << chn);
    
    log_w("Ctrl set addr%d chn %d Mark=%d,%d",saddr,chn,data_temp[1],data_temp[0]);
    return g_modbus_write_x_reg(manger,saddr,offset, 2, data_temp);
}
//一次性刷新一个板子的数据
int g_switch_set_dcpdu_chns_ctrl(void* manger,int saddr,unsigned short sts,int nSet)
{
    unsigned int offset = 0;
    offset = _SWITCH_DCPDU_STS_INFO;

    unsigned short data_temp[2]; 
    //memset(data_temp,0,sizeof(data_temp));

    int ret=g_modbus_read_x_reg_delay(manger,saddr,offset,2, data_temp);
    if (ret<0)
    {
        log_w("Ctrl Error Ret=%d:%s",ret,modbus_strerror(errno));
        return -1;
    }
    log_w("Ctrl get addr%d Mark=%d,%d",saddr,data_temp[1],data_temp[0]);
    if (nSet==0)
    {  //关闭
        sts=~sts;
        data_temp[0] &= sts;
    }else{
        //开启
        data_temp[0] |= sts;
    }   
    
    log_w("Ctrl set addr%d Mark=%d,%d",saddr,data_temp[1],data_temp[0]);
    return g_modbus_write_x_reg(manger,saddr,offset, 2, data_temp);
}
int g_switch_set_dcpdu_ctrl(void* manger,int saddr,unsigned short* sts)
{
    unsigned int offset = 0;
    unsigned short data_temp[2];

    if (sts[0] == 1)
    {
        offset = _SWITCH_DCPDU_ALL_OPEN_INFO;
        data_temp[0] = 0xFFFF;
        data_temp[1] = 0xFFFF;
    }
    else
    {
        offset = _SWITCH_DCPDU_ALL_CLOSE_INFO;
        data_temp[0] = 0;
        data_temp[1] = 0;
    }    
    return g_modbus_write_x_reg(manger,saddr,offset, 2, data_temp);
}

int g_switch_get_dcpdu_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;

    offset = _SWITCH_DCPDU_MAX_VOL_THRESHOLD + chn;
    int ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    _global_over_manager->product_vol_upper_threshold = value / 1000.0;

    offset = _SWITCH_DCPDU_MIN_VOL_THRESHOLD + chn;
    ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    _global_over_manager->product_vol_lower_threshold = value / 1000.0;
    
    offset = _SWITCH_DCPDU_MAX_CUR_THRESHOLD + chn;
    ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    _global_over_manager->product_cur_upper_threshold = value / 1000.0;

    offset = _SWITCH_DCPDU_MIN_CUR_THRESHOLD + chn;
    ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    _global_over_manager->product_cur_lower_threshold = value / 1000.0;

    return ret;
}

int g_switch_set_dcpdu_max_vol_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;
    
    offset = _SWITCH_DCPDU_MAX_VOL_THRESHOLD + chn;
    value = _global_over_manager->product_vol_upper_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    

    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}

int g_switch_set_dcpdu_min_vol_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;
   
    offset = _SWITCH_DCPDU_MIN_VOL_THRESHOLD + chn;
    value = _global_over_manager->product_vol_lower_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    

    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}

int g_switch_set_dcpdu_max_cur_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;
    
    offset = _SWITCH_DCPDU_MAX_CUR_THRESHOLD + chn;
    value = _global_over_manager->product_cur_upper_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    

    return g_modbus_write_x_reg(manger,saddr,offset, 2, data_temp);
}

int g_switch_set_dcpdu_min_cur_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;
    
    offset = _SWITCH_DCPDU_MIN_CUR_THRESHOLD + chn;
    value = _global_over_manager->product_cur_lower_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    

    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}
int g_switch_set_dcpdu_max_power_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;
    
    offset = _SWITCH_DCPDU_MAX_POWER_THRESHOLD + chn;
    value = _global_over_manager->product_pwr_upper_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    

    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}
int g_switch_set_dcpdu_max_pwrcon_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;
    
    offset = _SWITCH_DCPDU_MAX_POWERCON_THRESHOLD + chn;
    value = _global_over_manager->product_pwrcon_upper_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF;
    

    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}

int g_switch_set_dcpdu_reset(void* manger,int saddr)
{
    return 0;
}

int g_switch_set_dcpdu_chn_reset(void* manger,int saddr,int nChn)
{
    if (saddr <= 0 || saddr > switch_addr_max)
    {
        return -1;
    }
    unsigned int offset = 0;
    unsigned short data_temp[2];
    int ret = 0;
    
    offset = _SWITCH_DCPDU_RESET_CONSUMPTION+nChn;
    data_temp[0] = 1;
    data_temp[1] = 1;
    ret = g_modbus_write_x_reg(manger, saddr, offset, 2, data_temp);
    if (ret < 0)
    {
        return ret;
    }
    return 0;
}

int g_switch_get_t_ac_out_info(void* manger,int saddr,unsigned char chn,PowerInfo* _power,PowerWarningInfo* _warning)
{
    unsigned int offset = 0;
    unsigned int val = 0 ;
    unsigned short data_temp[16] = {0};
    unsigned int status_temp = 0 ;
   
    offset = _SWITCH_T_AC_OUT_INFO + chn * 8;
    //读取4个寄存器
    int ret = g_modbus_read_x_reg(manger,saddr,offset,16,data_temp);  
    //解电压数据
    float value = (data_temp[1] << 16) + data_temp[0];
    _power->voltage = value / 1000.0;
    //解电流数据
    value = (data_temp[3] << 16) + data_temp[2];
    _power->current = value / 1000.0;
    //解功率数据
    value = (data_temp[5] << 16) + data_temp[4];
    _power->power = value / 1000.0;    
    //无功
    value = (data_temp[7] << 16) + data_temp[6];
    //视在功率
    value = (data_temp[9] << 16) + data_temp[8];
    //解频率数据
    val = (data_temp[11]<<16)+data_temp[10];
    _power->freq = val/1000.0;
    //解耗电量数据
    val = (data_temp[13]<<16)+data_temp[12];
    _power->consumption = val/1000.0;
    //解功率因素数据
    val = (data_temp[15]<<16)+data_temp[14];
    _power->factor = val/1023.0;
    //获取开关状态
    offset = _SWITCH_T_AC_OUT_ENABLE+ chn;
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset, 2,data_temp);
    _power->status = data_temp[0] & BIT_00;

    //获取故障状态
    offset = _SWITCH_T_AC_OUT_ERROR+ chn;
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset, 2,data_temp);
    _warning->w_voltage_up      = data_temp[0] & BIT_00;
    _warning->w_voltage_down    = data_temp[0] & BIT_01;
    _warning->w_current         = data_temp[0] & BIT_02;
    _warning->w_power           = data_temp[0] & BIT_03;
    _warning->w_consumption     = data_temp[0] & BIT_04;

    return ret;
}
int g_switch_get_t_ac_all_out_info(void* manger,int saddr,int nNumb,PowerInfo* _power,PowerWarningInfo* _warning)
{
    unsigned int offset = 0;
    unsigned int val = 0 ;
    unsigned short data_temp[144] = {0};
    unsigned int status_temp = 0 ;
   
    offset = _SWITCH_T_AC_OUT_INFO;
    //读取4个寄存器

    int ret = g_modbus_read_x_reg(manger, saddr, offset, 80, data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_T_ac_in_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        return ret;
    }
    offset = _SWITCH_T_AC_OUT_INFO+40;
    unsigned short* DataTemp=data_temp+80;
    ret = g_modbus_read_x_reg(manger, saddr, offset, 64, DataTemp);
    if (ret < 0)
   {
    log_w("g_switch_get_T_ac_in_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
       return ret;
    }
    //offset = _SWITCH_T_AC_OUT_INFO+48;
    //DataTemp=data_temp+96;
   // ret = g_modbus_read_x_reg(manger, saddr, offset, 48, DataTemp);
   // if (ret < 0)
    //{
    //    log_w("g_switch_get_T_ac_in_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
     //   return ret;
   // }
    for (size_t i = 0; i < nNumb; i++)
    {
        int Index = i * 16;
        // 解电压数据
        float value = (data_temp[1+Index] << 16) + data_temp[0+Index];
        _power[i].voltage = value / 1000.0;
        // 解电流数据
        value = (data_temp[3+Index] << 16) + data_temp[2+Index];
        _power[i].current = value / 1000.0;
        // 解功率数据
        value = (data_temp[5+Index] << 16) + data_temp[4+Index];
        _power[i].power = value / 1000.0;
        // 无功
        value = (data_temp[7+Index] << 16) + data_temp[6+Index];
        // 视在功率
        value = (data_temp[9+Index] << 16) + data_temp[8+Index];
        // 解频率数据
        val = (data_temp[11+Index] << 16) + data_temp[10+Index];
        _power[i].freq = val / 1000.0;
        // 解耗电量数据
        val = (data_temp[13+Index] << 16) + data_temp[12+Index];
        _power[i].consumption = val / 1000.0;
        // 解功率因素数据
        val = (data_temp[15+Index] << 16) + data_temp[14+Index];
        _power[i].factor = val / 1023.0;
    }
    //获取通道开关状态及零线状态 
    //_SWITCH_T_AC_OUT_ENABLE +18
    //_SWITCH_T_AC_NF_STATUS +2
    offset = _SWITCH_T_AC_OUT_ENABLE;
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset, 20,data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_T_ac_in_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        return ret;
    }
    for (size_t i = 0; i < nNumb; i++)
    {
        int Index = i * 2;
        _power[i].status = data_temp[0+Index] & BIT_00;
        _power[i].NF_status = data_temp[18] & BIT_00;
    }

    //获取零线状态
    /*offset = _SWITCH_T_AC_NF_STATUS;
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset, 2,data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_T_ac_in_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        return ret;
    }
    for (size_t i = 0; i < nNumb; i++)
    {
        _power[i].NF_status = data_temp[18] & BIT_00;
    }*/
    //获取故障状态
    offset = _SWITCH_T_AC_OUT_ERROR;
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset, 18,data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_T_ac_in_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        return ret;
    }
    for (size_t i = 0; i < nNumb; i++)
    {
        int Index = i * 2;
        _warning[i].w_voltage_up      = data_temp[0+Index] & BIT_00;
        _warning[i].w_voltage_down    = data_temp[0+Index] & BIT_01;
        _warning[i].w_current         = data_temp[0+Index] & BIT_02;
        _warning[i].w_power           = data_temp[0+Index] & BIT_03;
        _warning[i].w_consumption     = data_temp[0+Index] & BIT_04;
    }
    return ret;
}

int g_switch_get_t_ac_start_time_delay(void* manger,int saddr,unsigned int* time)
{
    unsigned int offset = 0;
    unsigned short data_temp[16];
    offset = _SWITCH_T_AC_START_DELAY_TIME;
    int ret = g_modbus_read_x_reg(manger,saddr,offset,16,data_temp);
    unsigned int value = 0;
    for(int i = 0; i < 8; i++)
    {
        value = (data_temp[i * 2  + 1] << 16) + data_temp[i * 2];
        time[i] = value;
    }
    return ret;
}
int g_switch_get_t_ac_stop_time_delay(void* manger,int saddr,unsigned int* time)
{
    unsigned int offset = 0;
    unsigned short data_temp[16];
    offset = _SWITCH_T_AC_STOP_DELAY_TIME;
    int ret = g_modbus_read_x_reg(manger,saddr,offset,16,data_temp);
    unsigned int value = 0;
    for(int i = 0; i < 8; i++)
    {
        value = (data_temp[i * 2  + 1] << 16) + data_temp[i * 2];
        time[i] = value;
    }
    return ret; 
}
int g_switch_get_t_ac_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;
    float fvalue=0.0;
    offset = _SWITCH_T_AC_MAX_VOL_THRESHOLD + chn;
    int ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    fvalue=(float)value;
    _global_over_manager->product_vol_upper_threshold = fvalue / 1000.0;

    offset = _SWITCH_T_AC_MIN_VOL_THRESHOLD + chn;
    ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    fvalue=(float)value;
    _global_over_manager->product_vol_lower_threshold = fvalue / 1000.0;
    
    offset = _SWITCH_T_AC_MAX_CUR_THRESHOLD + chn;
    ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    fvalue=(float)value;
    _global_over_manager->product_cur_upper_threshold = fvalue / 1000.0;

    offset = _SWITCH_T_AC_MAX_PWR_THRESHOLD + chn;
    ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    fvalue=(float)value;
    _global_over_manager->product_pwr_upper_threshold = fvalue / 1000.0;

    offset = _SWITCH_T_AC_MAX_PWRCON_THRESHOLD + chn;
    ret = g_modbus_read_x_reg(manger,saddr,offset,2,data_temp);
    value = (data_temp[1] << 16) + data_temp[0];
    fvalue=(float)value;
    _global_over_manager->product_pwrcon_upper_threshold = fvalue / 1000.0;

    return ret;
}
int g_switch_set_t_ac_max_vol_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;    
    offset = _SWITCH_T_AC_MAX_VOL_THRESHOLD + chn;
    value = _global_over_manager->product_vol_upper_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF; 
    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}
int g_switch_set_t_ac_min_vol_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;    
    offset = _SWITCH_T_AC_MIN_VOL_THRESHOLD + chn;
    value = _global_over_manager->product_vol_lower_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF; 
    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}
int g_switch_set_t_ac_max_cur_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
        unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;    
    offset = _SWITCH_T_AC_MAX_CUR_THRESHOLD + chn;
    value = _global_over_manager->product_cur_upper_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF; 
    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}
int g_switch_set_t_ac_max_power_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
        unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;    
    offset = _SWITCH_T_AC_MAX_PWR_THRESHOLD + chn;
    value = _global_over_manager->product_pwr_upper_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF; 
    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}
int g_switch_set_t_ac_max_pwrcon_threshold(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
        unsigned int offset = 0;   
    unsigned short data_temp[4];
    memset(data_temp,0,sizeof(data_temp));
    unsigned int value = 0;    
    offset = _SWITCH_T_AC_MAX_PWRCON_THRESHOLD + chn;
    value = _global_over_manager->product_pwrcon_upper_threshold * 1000;
    data_temp[0] = value & 0XFFFF;
    data_temp[1] = (value >> 16) & 0xFFFF; 
    return g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
}
//报警控制方式
int g_switch_set_t_ac_alarm_ctrl(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;
    offset = _SWITCH_T_AC_ALARM_CTRL+chn;
    int nStatus = 0;
    if(_global_over_manager->product_vol_over_upper_threshold_ctrl==1)nStatus|=BIT_01;
    if(_global_over_manager->product_vol_over_lower_threshold_ctrl==1)nStatus|=BIT_02;
    if(_global_over_manager->product_cur_over_upper_threshold_ctrl==1)nStatus|=BIT_00;
    if(_global_over_manager->product_pwr_over_upper_threshold_ctrl==1)nStatus|=BIT_03;
    if(_global_over_manager->product_pwrcon_over_upper_threshold_ctrl==1)nStatus|=BIT_04;  
    return g_modbus_write_reg(manger,saddr,offset,nStatus);
}

int g_switch_set_ac_alarm_ctrl(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;
    offset = _SWITCH_AC_ALARM_CTRL+chn;
    int nStatus = 0;
    if(_global_over_manager->product_vol_over_upper_threshold_ctrl==1)nStatus|=BIT_01;
    if(_global_over_manager->product_vol_over_lower_threshold_ctrl==1)nStatus|=BIT_02;
    if(_global_over_manager->product_cur_over_upper_threshold_ctrl==1)nStatus|=BIT_00;
    if(_global_over_manager->product_pwr_over_upper_threshold_ctrl==1)nStatus|=BIT_03;
    if(_global_over_manager->product_pwrcon_over_upper_threshold_ctrl==1)nStatus|=BIT_04;  
    return g_modbus_write_reg(manger,saddr,offset,nStatus);
}

int g_switch_set_dcpdu_alarm_ctrl(void* manger,int saddr,char chn,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;
    offset = _SWITCH_DCPDU_ALARM_CTRL+chn;
    int nStatus = 0;
    if(_global_over_manager->product_vol_over_upper_threshold_ctrl==1)nStatus|=BIT_01;
    if(_global_over_manager->product_vol_over_lower_threshold_ctrl==1)nStatus|=BIT_02;
    if(_global_over_manager->product_cur_over_upper_threshold_ctrl==1)nStatus|=BIT_00;
    if(_global_over_manager->product_pwr_over_upper_threshold_ctrl==1)nStatus|=BIT_03;
    if(_global_over_manager->product_pwrcon_over_upper_threshold_ctrl==1)nStatus|=BIT_04;  
    return g_modbus_write_reg(manger,saddr,offset,nStatus);
}
/**
 * @brief 设置 AC 告警丢失相位
 *
 * 通过给定的管理器对象，设置 AC 告警丢失相位的状态。
 *
 * @param manger 管理器对象指针
 * @param saddr 地址
 * @param MissStatus 丢失相位状态指针
 *
 * @return 返回操作结果，成功返回 0，失败返回非零值
 */
int g_switch_set_t_ac_alarm_missing_ph(void* manger,int saddr,int* MissStatus)
{
    unsigned int offset = 0;
    unsigned int value = 0;
    unsigned short data_temp[6] = {0};
    unsigned int status_temp = 0;
    int ret = 0;
    offset = _SWITCH_T_AC_ALARM_MISSING_PH;
    // 读取4个寄存器
    // 读取寄存器
    memset(data_temp, 0, sizeof(data_temp));
    //一次读4个
    ret = g_modbus_read_x_reg(manger, saddr, offset, 6, data_temp);
    if (ret < 0)
    {
        //log_w("g_switch_get_t_ac_alarm_missing_ph:addrs:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }
    for(int i = 0; i < 3; i++)
    {
        
        value = 0;
        if(data_temp[i * 2]>0)
        {
            value=1;
        }
        MissStatus[i] = value;
    }
    return 0;
}
int g_switch_set_t_ac_start_time_delay(void* manger,int saddr,int ch, unsigned int time)
{
    unsigned int offset = 0;
    unsigned short data_temp[4];

    offset = _SWITCH_T_AC_START_DELAY_TIME + ch ;
    data_temp[0] = time & 0xFFFF;
    data_temp[1] = (time >> 16) & 0XFFFF;
    
    int reg = g_modbus_write_x_reg(manger,saddr,offset,2,data_temp);
    if (reg>=0)
    {
        log_d("StartDelayTime_Addr:%d ch:%d OffSet:%d Time:%d Ret=%d",saddr,ch,offset,time,reg);
    }
    else
    {        
        log_w("StartDelayTime_Addr:%d ch:%d OffSet:%d Time:%d Ret=%d:%s",saddr,ch,offset,time,reg,modbus_strerror(errno));
    }
    return reg;
}
int g_switch_set_t_ac_stop_time_delay(void* manger,int saddr,int ch, unsigned int time)
{
 unsigned int offset = 0;   
    unsigned short data_temp[4];
    
    offset = _SWITCH_T_AC_STOP_DELAY_TIME + ch;
    data_temp[0] = time & 0XFFFF;
    data_temp[1] = (time >> 16) & 0xFFFF;

    int reg =  g_modbus_write_x_reg(manger,saddr,offset,2, data_temp);
    if (reg>=0)
    {
        log_d("StopDelayTime_Addr:%d ch:%d OffSet:%d Time:%d Ret=%d",saddr,ch,offset,time,reg);
    }
    else
    {        
        log_w("StopDelayTime_Addr:%d ch:%d OffSet:%d Time:%d Ret=%d:%s",saddr,ch,offset,time,reg,modbus_strerror(errno));
    }
    return reg;
}
int g_switch_set_t_ac_chn_ctrl(void* manger,int saddr,unsigned char chn,unsigned short sts)
{
    unsigned int offset = 0;
    if(chn > 3 || chn < 0) return -1;
    unsigned short data_temp[2]; 
    memset(data_temp,0,sizeof(data_temp));
    if(chn>=3)
        return -1;  
    offset = _SWITCH_T_AC_CH_OUT_ENABLE+chn;   
    data_temp[0]=sts;
    return g_modbus_write_x_reg(manger,saddr,offset, 2, data_temp);
}

int g_switch_set_t_ac_chn_NF_ctrl(void* manger,int saddr,unsigned char chn,unsigned short sts)
{
    int r=0;
#ifdef USE_NF_CTRL
    unsigned int offset = 0;
    if(chn >= 3 || chn < 0) return -1;
    unsigned short data_temp[2]; 
    memset(data_temp,0,sizeof(data_temp)); 
    offset = _SWITCH_T_AC_NF_STATUS;   
    data_temp[0]=sts;
    data_temp[1]=0;
    r = g_modbus_write_x_reg(manger,saddr,offset, 2, data_temp);
#endif
    return r;
}

int g_switch_set_t_ac_phchn_ctrl(void* manger,int saddr,unsigned char chn,unsigned short sts)
{
    //三个一组进行设置
        unsigned int offset = 0;
    if(chn > 9 || chn < 0) return -1;
    unsigned short data_temp[2]; 
    memset(data_temp,0,sizeof(data_temp));
    if(chn>=9)
        return -1;  
    offset = _SWITCH_T_AC_OUT_ENABLE+chn;   
    data_temp[0]=sts;
    return g_modbus_write_x_reg(manger,saddr,offset, 2, data_temp);
}
int g_switch_set_t_ac_ctrl(void* manger,int saddr,unsigned short* sts)
{
    unsigned int offset = 0;
    unsigned short data_temp[2];

    if (sts[0] == 1)
    {
        offset = _SWITCH_T_AC_ALL_OPEN_INFO;
        data_temp[0] = 0xFFFF;
        data_temp[1] = 0xFFFF;
    }
    else
    {
        offset = _SWITCH_T_AC_ALL_CLOSE_INFO;
        data_temp[0] = 0;
        data_temp[1] = 0;
    }    
    return g_modbus_write_x_reg(manger,saddr,offset, 2, data_temp);
}
//重置通道状态
int g_switch_set_t_ac_phchn_reset(void *manger, int saddr, int nChn)
{
    if (saddr <= 0 || saddr > switch_addr_max)
    {
        return -1;
    }
    unsigned int offset = 0;
    unsigned short data_temp[2];
    int ret = 0;
    
    offset = _SWITCH_T_AC_RESET_CONSUMPTION_PH+nChn;
    data_temp[0] = 1;
    data_temp[1] = 1;
    ret = g_modbus_write_x_reg(manger, saddr, offset, 2, data_temp);
    if (ret < 0)
    {
        return ret;
    }
    return 0;
}

int g_switch_set_t_ac_chn_reset(void *manger, int saddr, int nChn)
{
    if (saddr <= 0 || saddr > switch_addr_max)
    {
        return -1;
    }
    unsigned int offset = 0;
    unsigned short data_temp[2];
    int ret = 0;
    
    offset = _SWITCH_AC_RESET_CONSUMPTION+nChn;
    data_temp[0] = 1;
    data_temp[1] = 1;
    ret = g_modbus_write_x_reg(manger, saddr, offset, 2, data_temp);
    if (ret < 0)
    {
        return ret;
    }
    return 0;
}



//重设板子信息
int g_switch_set_t_ac_reset(void* manger,int saddr)
{
    if (saddr <= 0 || saddr > switch_addr_max)
    {
        return -1;
    }
    unsigned int offset = 0;
    unsigned short data_temp[10];
    int ret=0;
    //重置耗电量
    offset = _SWITCH_T_AC_RESET_CONSUMPTION;
    data_temp[0] = data_temp[1] = data_temp[2] = 1;
    ret= g_modbus_write_x_reg(manger,saddr,offset,3,data_temp);
    if (ret<0)
    {
        return ret;        
    }
    //初始化报警阈值
    unsigned short data_temp1[18];
    memset(data_temp1,0,sizeof(data_temp1));
    unsigned int value = 0;    
    offset = _SWITCH_T_AC_MAX_VOL_THRESHOLD;
    ret = g_modbus_write_x_reg(manger,saddr,offset,18,data_temp1);
    if (ret<0)
    {
        return ret;        
    }
    offset = _SWITCH_T_AC_MIN_VOL_THRESHOLD;
    ret = g_modbus_write_x_reg(manger,saddr,offset,18,data_temp1);
    if (ret<0)
    {
        return ret;        
    }
    offset = _SWITCH_T_AC_MAX_CUR_THRESHOLD;
    ret = g_modbus_write_x_reg(manger,saddr,offset,18,data_temp1);
    if (ret<0)
    {
        return ret;        
    }
    offset = _SWITCH_T_AC_MAX_PWR_THRESHOLD;
    ret = g_modbus_write_x_reg(manger,saddr,offset,18,data_temp1);
    if (ret<0)
    {
        return ret;        
    }
    offset = _SWITCH_T_AC_MAX_PWRCON_THRESHOLD;
    ret = g_modbus_write_x_reg(manger,saddr,offset,18,data_temp1);
    if (ret<0)
    {
        return ret;        
    }
    if (__globalDeviceManage.pCtrlBoard[saddr].product_saddr<=0)
    {
        return -1;
    }    
    PowerInfo* pPowerInfo= __globalDeviceManage.pCtrlBoard[saddr]._PowerInfo;
    if (pPowerInfo!=NULL)
    {
        for (size_t i = 0; i < __globalDeviceManage.pCtrlBoard[saddr].product_number; i++)
        {
            memset(data_temp1, 0, sizeof(data_temp1));
            offset = _SWITCH_T_AC_OUT_ENABLE + i;
            data_temp1[0] = pPowerInfo[i].status;
            ret = g_modbus_write_x_reg(manger, saddr, offset, 2, data_temp1);
            if (ret < 0)
            {
                return ret;
            }
        }
    }
    if (ret<0)
    {
        return ret;        
    }
    return 0;
}

//输入状态及报警
int g_switch_get_t_ac_in_info(void* manger,int saddr,PowerInfo* _power,PowerWarningInfo *_warning)
{
    unsigned int offset = 0;
    unsigned int value = 0 ;
    unsigned short data_temp[24] = {0};
    int ret=0;
    offset = _SWITCH_T_AC_IN_INFO;
    //读取4个寄存器
    //读取寄存器
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset,24,data_temp);  
    if (ret<0)
    {
        log_w("g_switch_get_t_ac_in_info:%d OffSet:%d Ret=%d:%s",saddr,offset,ret,modbus_strerror(errno));
        //log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }
    
    //解电压数据
    for (size_t i = 0; i < 3; i++)
    {
        int Index=i*2;
         value = (data_temp[1+Index] << 16) + data_temp[0+Index];
        _power[i].voltage = value / 1000.0;
        //解电流数据
        value = (data_temp[7+Index] << 16) + data_temp[6+Index];
        _power[i].current = value / 1000.0;
        //解功率数据
        value = (data_temp[13+Index] << 16) + data_temp[12+Index];
        _power[i].power = value / 1000.0;
        value = (data_temp[19+Index] << 16) + data_temp[18+Index];
        _power[i].consumption = value / 1000.0;
        _power[i].freq=0;
    }    

    offset = _SWITCH_T_AC_IN_ERROR;
    //读取寄存器
    memset(data_temp,0,sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger,saddr,offset, 2,data_temp); 
    //解报警数据
    if (ret<0)
    {
        return ret;
    }
    for (size_t i = 0; i < 3; i++)
    {
        _warning[i].w_voltage_up      = data_temp[0] & (BIT_00<<i);
        _warning[i].w_voltage_down    = data_temp[0] & (BIT_03<<i);
        _warning[i].w_current         = data_temp[0] & (BIT_06<<i);
        _warning[i].w_power           = data_temp[1] & (BIT_00<<i);
        _warning[i].w_consumption     = data_temp[1] & (BIT_03<<i);
        //_warning[i].w_phase_loss      = data_temp[1] & (BIT_06<<i);
    }    
    return 0;
}
//阈值获取
int g_switch_get_t_ac_in_threshold(void* manger,int saddr,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;
    unsigned short data_temp[10] = {0};
    memset(data_temp, 0, sizeof(data_temp));;
    offset = _SWITCH_T_AC_SINGLE_IN_Threshold;
    int ret= g_modbus_read_x_reg(manger,saddr,offset,10,data_temp);
    unsigned int value = 0;
    float fvalue=0.0; 
   //电压上限
    value = (data_temp[1] << 16) + data_temp[0];
    fvalue=(float)value;
    _global_over_manager->product_vol_upper_threshold = fvalue / 1000.0;
    //电压下限
    value = (data_temp[3] << 16) + data_temp[2];
    fvalue=(float)value;
    _global_over_manager->product_vol_lower_threshold = fvalue / 1000.0;
    //电流上限
    value = (data_temp[5] << 16) + data_temp[4];
    fvalue=(float)value;
    _global_over_manager->product_cur_upper_threshold = fvalue / 1000.0;
    //功率上限
    value = (data_temp[7] << 16) + data_temp[6];
    fvalue=(float)value;
    _global_over_manager->product_pwr_upper_threshold = fvalue / 1000.0;
    //电能上限
    value = (data_temp[9] << 16) + data_temp[8];
    fvalue=(float)value;
    _global_over_manager->product_pwrcon_upper_threshold = fvalue / 1000.0;
    

    //log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
    return ret;
}
//阈值设置
int g_switch_set_t_ac_in_threshold(void* manger,int saddr,GlobalOverManager* _global_over_manager)
{
    unsigned int offset = 0;
    unsigned int data_temp = 0 ;
    unsigned short data_buf[10] = {0};
    int ret= 0;
    memset(data_buf, 0, sizeof(data_buf));;
    offset = _SWITCH_T_AC_SINGLE_IN_Threshold;
    //电压上限
    data_temp =  (_global_over_manager->product_vol_upper_threshold*1000);
    data_buf[0] = data_temp;
    data_buf[1] = data_temp>>16;
    ret=g_modbus_write_x_reg(manger,saddr,offset,2,data_buf);
    //电压下限
    data_temp =  (_global_over_manager->product_vol_lower_threshold*1000);
    data_buf[0] = data_temp;
    data_buf[1] = data_temp>>16;
    ret=g_modbus_write_x_reg(manger,saddr,offset+1,2,data_buf);
    //电流上限
    data_temp =  (_global_over_manager->product_cur_upper_threshold*1000);
    data_buf[0] = data_temp;
    data_buf[1] = data_temp>>16;
    ret=g_modbus_write_x_reg(manger,saddr,offset+2,2,data_buf);
    //功率上限
    data_temp =  (_global_over_manager->product_pwr_upper_threshold*1000);
    data_buf[0] = data_temp;
    data_buf[1] = data_temp>>16;
    ret=g_modbus_write_x_reg(manger,saddr,offset+3,2,data_buf);
    //电能上限
    data_temp =  (_global_over_manager->product_pwrcon_upper_threshold*1000);
    data_buf[0] = data_temp;
    data_buf[1] = data_temp>>16;
    ret=g_modbus_write_x_reg(manger,saddr,offset+4,2,data_buf);


    //int ret= g_modbus_write_x_reg(manger,saddr,offset,10,data_buf);
    if (ret<0)
    {
        log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }
    memset(data_buf, 0, sizeof(data_buf));;
    if(_global_over_manager->product_vol_upper_enable==1)data_buf[0]|=ENABLE_TAC_V_UP;
    if(_global_over_manager->product_vol_lower_enable==1)data_buf[0]|=ENABLE_TAC_V_DOWN;
    if(_global_over_manager->product_cur_upper_enable==1)data_buf[0]|=ENABLE_TAC_A_UP;
    if(_global_over_manager->product_pwr_upper_enable==1)data_buf[0]|=ENABLE_TAC_W_UP;
    if(_global_over_manager->product_pwrcon_upper_enable==1)data_buf[0]|=ENABLE_TAC_P_UP;  
    offset = _SWITCH_T_AC_IN_ENABLE;
    ret= g_modbus_write_x_reg(manger,saddr,offset,2,data_buf);
    return ret;

}
/**
 * @brief 获取 GPIO 状态
 *
 * 根据给定的 GPIO 编号，获取 GPIO 的状态（高电平或低电平）。
 *
 * @param ngpio GPIO 编号
 * @param status 用于存储 GPIO 状态的指针
 *
 * @return 成功返回 0，失败返回非 0 错误码
 */
int g_switch_get_gpio_status(int ngpio,int* nStatus)
{
    char value_path[64];  
    char buf[3];  // 用于存储读取到的GPIO值，通常为'0'或'1'  
    ssize_t bytesRead;  
    int fd;  
    // 构造GPIO值的路径  
    snprintf(value_path, sizeof(value_path), GPIO_VALUE_PATH, ngpio);  
  
    // 打开GPIO值文件以读取  
    fd = open(value_path, O_RDONLY);  
    if (fd == -1) {  
        perror("Failed to open GPIO value for reading");  
        return -1;  
    }  
  
    // 读取GPIO的值  
    bytesRead = read(fd, buf, sizeof(buf) - 1);  
    if (bytesRead == -1) {  
        perror("Failed to read from GPIO value");  
        close(fd);  
        return -2;  
    }  
    if (nStatus==NULL)
    {
        perror("Failed to IO_nStatus NULL");  
        close(fd);  
        return -3;  
    }
    // 确保字符串以null终止  
    buf[bytesRead] = '\0';  
  
    // 打印读取到的GPIO值  
   // printf("GPIO %d value: %s\n", GPIO_PE3, buf);  
    if (buf[0]=='0')
    {
        *nStatus=1;
    }else{
        *nStatus=0;
    }
    

    // 关闭文件描述符  
    close(fd);  
  
    return 0;  
}

/**
 * @brief 清除全局电源管理器
 *
 * 清除指定的全局电源管理器对象，并释放相关资源。
 *
 * @param _globalDeviceManager 全局电源管理器对象指针
 *
 * @return 返回值表示操作是否成功，成功返回0，失败返回非0值
 */
int power_clear(GlobalPowerManger *globalPowerManager)
{

    GlobalPowerManger* _globalPowerMangerTemp,* pos;
    GlobalTreeACManager *_pTreeACPowerPhData,*pos1;
    _PowerDSManage_t* _powerDsManageTemp,*pos2;
    if (globalPowerManager == NULL)
    {
        return -1;
    }
    list_for_each_entry_safe(_globalPowerMangerTemp, pos, &globalPowerManager->list, list)
    {
        if (_globalPowerMangerTemp == NULL)
        {
            continue;
        }
        
        list_for_each_entry_safe(_powerDsManageTemp, pos2,&_globalPowerMangerTemp->list_DS, list)
        {
            list_del(&_powerDsManageTemp->list);
            free(_powerDsManageTemp);
        }
        list_for_each_entry_safe(_pTreeACPowerPhData, pos1,&_globalPowerMangerTemp->list_Tree_AC, list_Tree_AC)
        {
            list_del(&_pTreeACPowerPhData->list_Tree_AC);
            if(_pTreeACPowerPhData->global_over_manager) {
                free(_pTreeACPowerPhData->global_over_manager);
            }
            free(_pTreeACPowerPhData);
        }
        list_del(&_globalPowerMangerTemp->list);
        if (_globalPowerMangerTemp->global_over_manager)
        {
            free(_globalPowerMangerTemp->global_over_manager);
        }
        if (_globalPowerMangerTemp->_PowerSXManage)
        {
            free(_globalPowerMangerTemp->_PowerSXManage);
        }
        free(_globalPowerMangerTemp);
    }
    return 0;
}

/**
 * @brief 重新加载电源管理对象
 *
 * 清除指定的全局电源管理器对象，并重新加载相关资源。
 *
 * @param nCtrlType 0：全新设备，1：刷新设备
 *
 * @return 返回值表示操作是否成功，成功返回0，失败返回非0值
 */
int ResetChmData(int nCtrlType)
{
    // 搜索子地址
    int ret = 0;
    int chn = 1;
    int type = 0;
    int nTac_chn=3;
    GlobalDeviceManager* _globalDeviceManager=&__globalDeviceManage;    
    ProductInfo_t *prod=&_globalDeviceManager->_globalDevInfo.product;
    int nGroups=prod->ch_delay;
    __globalDeviceManage.useSlaveCount = 0;

    power_clear(&_globalDeviceManager->_globalPowerManger);
    for (size_t i = 0; i <= switch_addr_max; i++)
    {
        type = 0;
        int nMaxChn = 0;
        ret = g_switch_get_type(&__globalDeviceManage._globalRelaySampManger,
                                i,
                                &type,
                                &nMaxChn,
                                __globalDeviceManage._globalDevInfo.product.pwr_type);
        log_d("ret:%d saddr:%d type:%d ch_num:%d.\n", ret, i, type, nMaxChn);
        // 有效地址记录

        if (ret == 0)
        {
            _globalDeviceManager->useSlaveCount ++ ;
            _globalDeviceManager->pCtrlBoard[i].product_saddr = i;
            _globalDeviceManager->pCtrlBoard[i].product_number = nMaxChn;
            _globalDeviceManager->pCtrlBoard[i].product_type = type;
            switch (type)
            {
            case AC_SINGLE_S_TYPE: // AC单相小电流 8路继电器
            case AC_SINGLE_B_TYPE:
            {
                log_i("Address=%d AC_SINGLE_S_TYPE!\n", i);
                for (size_t j = 0; j < nMaxChn; j++)
                {
                    GlobalPowerManger *_globalPowerMangerTemp = (GlobalPowerManger *)malloc(sizeof(GlobalPowerManger));
                    if (_globalPowerMangerTemp == NULL)
                    {
                        // log_e("_globalPowerManger malloc error.\n");
                        return -1;
                    }
                    memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                    _globalPowerMangerTemp->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                    if (_globalPowerMangerTemp->global_over_manager == NULL)
                    {
                        // log_e("_globalPowerManger->global_over_manager malloc error.\n");
                        return -1;
                    }
                    memset(_globalPowerMangerTemp->global_over_manager, 0, sizeof(GlobalOverManager));
                    // 查询是否由通道信息
                    ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                    _globalDeviceManager->_globalDevInfo.product.id,
                                                    i,
                                                    j + 1, // 1*8+j
                                                    _globalPowerMangerTemp);
                    // 未查询到信息 则插入
                    if (ret == -1)
                    {
                        _globalPowerMangerTemp->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                        _globalPowerMangerTemp->product_saddr = i;
                        _globalPowerMangerTemp->product_ch_id = chn;
                        _globalPowerMangerTemp->product_ch_addr = j + 1;
                        sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                        _globalPowerMangerTemp->product_ch_type = type;
                        _globalPowerMangerTemp->product_ch_status = 0;
                        _globalPowerMangerTemp->product_ch_NF_status = 0;

                        _globalPowerMangerTemp->product_ch_start_delay = 1000 * (chn % nGroups != 0 ? chn % nGroups : nGroups);
                        _globalPowerMangerTemp->product_ch_stop_delay = 1000 * (chn % nGroups != 0 ? chn % nGroups : nGroups);

                        if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                                         _globalDeviceManager->_globalDevInfo.product.id,
                                                         _globalPowerMangerTemp->product_ch_id,
                                                         _globalPowerMangerTemp) != 0)
                        {
                            log_e("address %d chn %d data inserted error.\n", i, chn);
                            return 0;
                        }
                        /*
                        else
                        {
                            log_i("chn %d data inserted ok.\n",(i-1)*AC_SINGLE_S_CUR_CHN_NUM+j+1);
                        }
                        */
                    }
                    INIT_LIST_HEAD(&_globalPowerMangerTemp->list_Tree_AC);
                    if ( _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One_B)
                    {
                        // 初始化三相子通道
                        GlobalTreeACManager *_globalTACManager = NULL;
                        
                        for (size_t indexT = 0; indexT < 3; indexT++)
                        {
                            _globalTACManager = (GlobalTreeACManager *)malloc(sizeof(GlobalTreeACManager));
                            memset(_globalTACManager, 0, sizeof(GlobalTreeACManager));
                            if (_globalTACManager == NULL)
                            {
                                log_e("_globalTACManager malloc error.\n");
                                return -1;
                            }
                            _globalTACManager->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                            memset(_globalTACManager->global_over_manager, 0, sizeof(GlobalOverManager));
                            if (_globalTACManager->global_over_manager == NULL)
                            {
                                log_e("_globalTACManager->global_over_manager malloc error.\n");
                                return -1;
                            }
                            ret = dev_get_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                 _globalDeviceManager->_globalDevInfo.product.id, i,
                                                                 j + 1, // 1*8+j
                                                                 indexT,
                                                                 _globalTACManager);
                            _globalTACManager->product_ch_addr = j + 1;
                            // 未查询到信息 则插入
                            if (ret == -1)
                            {
                                _globalTACManager->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                                _globalTACManager->product_saddr = i;
                                _globalTACManager->product_ch_id = _globalPowerMangerTemp->product_ch_id;
                                _globalTACManager->product_ch_addr = j + 1;
                                _globalTACManager->product_ph_id = nTac_chn;
                                _globalTACManager->product_ph_type = indexT;
                                _globalTACManager->product_ph_outputType = 2; // 1三相2单相
                                if (indexT == ((nTac_chn-3)/(prod->ph_group*3)+3)%3)
                                {
                                    _globalTACManager->product_ph_outputStatus = 1; // 1输出2不输出
                                }
                                else
                                {
                                    _globalTACManager->product_ph_outputStatus = 2; // 1输出2不输出
                                }

                                if (dev_insert_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                      _globalDeviceManager->_globalDevInfo.product.id,
                                                                      _globalTACManager->product_ch_id,
                                                                      _globalTACManager) != 0)
                                {
                                    log_e("address %d ph_chn %d data inserted error.\n", i, nTac_chn);
                                    return 0;
                                }
                            }
                            // 绑定到三项通道
                            _globalTACManager->product_saddr = i;
                            _globalTACManager->product_ph_type = indexT;
                            if (nCtrlType)
                            {
                                _globalTACManager->product_ph_id = nTac_chn;
                                _globalTACManager->product_saddr = i;
                                _globalTACManager->product_ph_type = indexT;
                                if (indexT == ((nTac_chn - 3) / (prod->ph_group * 3) + 3) % 3)
                                {
                                    _globalTACManager->product_ph_outputStatus = 1; // 1输出2不输出
                                }
                                else
                                {
                                    _globalTACManager->product_ph_outputStatus = 2; // 1输出2不输出
                                }
                                if (dev_update_t_ac_power_manage_info(__globalDeviceManage.db, _globalTACManager) != 0)
                                {
                                    log_e("update pwr general data err.");
                                }
                            }
                            if (_globalPowerMangerTemp)
                            {
                                list_add_tail(&_globalTACManager->list_Tree_AC, &_globalPowerMangerTemp->list_Tree_AC);
                            }
                            nTac_chn += 1;
                        }
                    }
                    if (nCtrlType)
                    {
                        _globalPowerMangerTemp->product_ch_id = chn;
                        sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                        if (dev_update_power_manage_genera_info_addr(__globalDeviceManage.db, _globalDeviceManager->_globalDevInfo.product.id, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, _globalPowerMangerTemp) != 0)
                        {
                            log_e("update pwr general data err.");
                        }
                    }
                    // 添加到队尾
                    list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
                    chn += 1;
                }
            }
            break;
            case AC_MULTI_S_TYPE: // 预留
                break;
            case AC_MULTI_B_TYPE: // 预留
                break;
            case DC_OUT_TYPE: // DC输出继电器 1路
                break;
            case DC_IN_TYPE: // DC采集
            {
                log_i("Address=%d DC_IN_TYPE!\n", i);
                for (size_t j = 0; j < nMaxChn; j++) // AC与DC长度一致
                {
                    GlobalPowerManger *_globalPowerMangerTemp = (GlobalPowerManger *)malloc(sizeof(GlobalPowerManger));
                    if (_globalPowerMangerTemp == NULL)
                    {
                        // log_e("_globalPowerManger malloc error.\n");
                        return -1;
                    }
                    memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                    _globalPowerMangerTemp->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                    if (_globalPowerMangerTemp->global_over_manager == NULL)
                    {
                        // log_e("_globalPowerManger->global_over_manager malloc error.\n");
                        return -1;
                    }
                    memset(_globalPowerMangerTemp->global_over_manager, 0, sizeof(GlobalOverManager));
                    // 查询是否由通道信息
                    ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                    _globalDeviceManager->_globalDevInfo.product.id, i,
                                                    j + 1, // 1*8+j
                                                    _globalPowerMangerTemp);
                    // 未查询到信息 则插入
                    if (ret == -1)
                    {
                        _globalPowerMangerTemp->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                        _globalPowerMangerTemp->product_saddr = i;
                        _globalPowerMangerTemp->product_ch_id = chn;
                        _globalPowerMangerTemp->product_ch_addr = j + 1;
                        sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                        _globalPowerMangerTemp->product_ch_type = type;
                        _globalPowerMangerTemp->product_ch_status = 0;
                        _globalPowerMangerTemp->product_ch_NF_status = 0;
                        _globalPowerMangerTemp->product_ch_start_delay = 1000;
                        _globalPowerMangerTemp->product_ch_stop_delay = 1000;
                        if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                                         _globalDeviceManager->_globalDevInfo.product.id,
                                                         _globalPowerMangerTemp->product_ch_id,
                                                         _globalPowerMangerTemp) != 0)
                        {
                            log_e("address %d chn %d data inserted error.\n", i, chn);
                            return 0;
                        }
                        /*
                        else
                        {
                            log_i("chn %d data inserted ok.\n",(i-1)*AC_SINGLE_S_CUR_CHN_NUM+j+1);
                        }
                        */
                    }
                    _globalPowerMangerTemp->product_saddr = i;
                    INIT_LIST_HEAD(&_globalPowerMangerTemp->list_Tree_AC);
                    // 添加到队尾
                    list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
                    chn += 1;
                }
            }
            break;
            case DCPDU_TYPE: // DCPDU
            {
                log_i("DCPDU_TYPE!\n");
                for (size_t j = 0; j < nMaxChn; j++)
                {
                    GlobalPowerManger *_globalPowerMangerTemp = (GlobalPowerManger *)malloc(sizeof(GlobalPowerManger));
                    if (_globalPowerMangerTemp == NULL)
                    {
                        // log_e("_globalPowerManger malloc error.\n");
                        return -1;
                    }
                    memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                    _globalPowerMangerTemp->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                    if (_globalPowerMangerTemp->global_over_manager == NULL)
                    {
                        // log_e("_globalPowerManger->global_over_manager malloc error.\n");
                        return -1;
                    }

                    memset(_globalPowerMangerTemp->global_over_manager, 0, sizeof(GlobalOverManager));
                    // 查询是否由通道信息
                    ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                    _globalDeviceManager->_globalDevInfo.product.id, i,
                                                    j + 1, // 1*8+j
                                                    _globalPowerMangerTemp);
                    _globalPowerMangerTemp->product_ch_addr = j + 1;
                    // 未查询到信息 则插入
                    if (ret == -1)
                    {
                        _globalPowerMangerTemp->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                        _globalPowerMangerTemp->product_saddr = i;
                        _globalPowerMangerTemp->product_ch_id = chn;
                        _globalPowerMangerTemp->product_ch_addr = j + 1;
                        sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                        _globalPowerMangerTemp->product_ch_type = type;
                        _globalPowerMangerTemp->product_ch_status = 0;
                        _globalPowerMangerTemp->product_ch_NF_status = 0;

                        _globalPowerMangerTemp->product_ch_start_delay = 1000 * (chn % nGroups != 0 ? chn % nGroups : nGroups);
                        _globalPowerMangerTemp->product_ch_stop_delay = 1000 * (chn % nGroups != 0 ? chn % nGroups : nGroups);

                        if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                                         _globalDeviceManager->_globalDevInfo.product.id,
                                                         _globalPowerMangerTemp->product_ch_id,
                                                         _globalPowerMangerTemp) != 0)
                        {
                            log_e("address %d chn %d data inserted error.\n", i, chn);
                            return 0;
                        }
                        /*
                        else
                        {
                            log_i("chn %d data inserted ok.\n",(i-1)*AC_SINGLE_S_CUR_CHN_NUM+j+1);
                        }
                        */
                    }
                    _globalPowerMangerTemp->product_saddr = i;
                    _globalPowerMangerTemp->product_ch_type = type;
                    INIT_LIST_HEAD(&_globalPowerMangerTemp->list_Tree_AC);
                    if (nCtrlType)
                    {
                        _globalPowerMangerTemp->product_ch_id = chn;
                        sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                        if (dev_update_power_manage_genera_info_addr(__globalDeviceManage.db, _globalDeviceManager->_globalDevInfo.product.id, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, _globalPowerMangerTemp) != 0)
                        {
                            log_e("update pwr general data err.");
                        }
                    }
                    // 添加到队尾
                    list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
                    chn += 1;
                }
            }
            break;
            case TREE_AC_TYPE: // 三相供电
            {
                log_i("TreeAC_TYPE!\n");
                GlobalPowerManger *_globalPowerMangerTemp = NULL;
                for (size_t j = 0; j < nMaxChn; j++)
                {
                    if (_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_Tree_AC_One)
                    {
                        log_i("TreeAC_TYPE_3-1!\n");
                        _globalPowerMangerTemp = (GlobalPowerManger *)malloc(sizeof(GlobalPowerManger));
                        if (_globalPowerMangerTemp == NULL)
                        {
                            log_e("_globalPowerManger malloc error.\n");
                            return -1;
                        }
                        memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                        INIT_LIST_HEAD(&_globalPowerMangerTemp->list_Tree_AC);
                        _globalPowerMangerTemp->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                        if (_globalPowerMangerTemp->global_over_manager == NULL)
                        {
                            log_e("_globalPowerManger->global_over_manager malloc error.\n");
                            return -1;
                        }
                        memset(_globalPowerMangerTemp->global_over_manager, 0, sizeof(GlobalOverManager));
                        // 查询是否由通道信息
                        ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                        _globalDeviceManager->_globalDevInfo.product.id, i,
                                                        j + 1, // 1*8+j
                                                        _globalPowerMangerTemp);
                        _globalPowerMangerTemp->product_ch_addr = j + 1;
                        // 未查询到信息 则插入
                        if (ret == -1)
                        {
                            _globalPowerMangerTemp->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                            _globalPowerMangerTemp->product_saddr = i;
                            _globalPowerMangerTemp->product_ch_id = chn;
                            _globalPowerMangerTemp->product_ch_addr = j + 1;
                            sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                            _globalPowerMangerTemp->product_ch_type = type;
                            _globalPowerMangerTemp->product_ch_status = 0;
                            _globalPowerMangerTemp->product_ch_NF_status = 0;

                            _globalPowerMangerTemp->product_ch_start_delay = 1000 * (chn % nGroups != 0 ? chn % nGroups : nGroups);
                            _globalPowerMangerTemp->product_ch_stop_delay = 1000 * (chn % nGroups != 0 ? chn % nGroups : nGroups);

                            if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                                             _globalDeviceManager->_globalDevInfo.product.id,
                                                             _globalPowerMangerTemp->product_ch_id,
                                                             _globalPowerMangerTemp) != 0)
                            {
                                log_e("address %d chn %d data inserted error.\n", i, chn);
                                return 0;
                            }
                        }
                        _globalPowerMangerTemp->product_saddr = i;
                        _globalPowerMangerTemp->product_ch_type = type;
                        if (nCtrlType)
                        {
                            _globalPowerMangerTemp->product_ch_id = chn;
                            sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                            if (dev_update_power_manage_genera_info_addr(__globalDeviceManage.db, _globalDeviceManager->_globalDevInfo.product.id, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, _globalPowerMangerTemp) != 0)
                            {
                                log_e("update pwr general data err.");
                            }
                        }
                        // 添加到队尾
                        list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
                        chn += 1;
                        // 初始化三相子通道三进1出
                        GlobalTreeACManager *_globalTACManager = NULL;
                        for (size_t indexT = 0; indexT < 3; indexT++)
                        {
                            _globalTACManager = (GlobalTreeACManager *)malloc(sizeof(GlobalTreeACManager));
                            memset(_globalTACManager, 0, sizeof(GlobalTreeACManager));
                            if (_globalTACManager == NULL)
                            {
                                log_e("_globalTACManager malloc error.\n");
                                return -1;
                            }
                            _globalTACManager->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                            memset(_globalTACManager->global_over_manager, 0, sizeof(GlobalOverManager));
                            if (_globalTACManager->global_over_manager == NULL)
                            {
                                log_e("_globalTACManager->global_over_manager malloc error.\n");
                                return -1;
                            }
                            ret = dev_get_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                 _globalDeviceManager->_globalDevInfo.product.id, i,
                                                                 j + 1, // 1*8+j
                                                                 indexT,
                                                                 _globalTACManager);
                            _globalTACManager->product_ch_addr = j + 1;
                            // 未查询到信息 则插入
                            if (ret == -1)
                            {
                                _globalTACManager->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                                _globalTACManager->product_saddr = i;
                                _globalTACManager->product_ch_id = _globalPowerMangerTemp->product_ch_id;
                                _globalTACManager->product_ch_addr = j + 1;
                                _globalTACManager->product_ph_id = nTac_chn;
                                _globalTACManager->product_ph_type = indexT;
                                _globalTACManager->product_ph_outputType = 2; // 1三相2单相
                                if (indexT == (j + 3) % 3)
                                {
                                    _globalTACManager->product_ph_outputStatus = 1; // 1输出2不输出
                                }
                                else
                                {
                                    _globalTACManager->product_ph_outputStatus = 2; // 1输出2不输出
                                }

                                if (dev_insert_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                      _globalDeviceManager->_globalDevInfo.product.id,
                                                                      _globalTACManager->product_ch_id,
                                                                      _globalTACManager) != 0)
                                {
                                    log_e("address %d ph_chn %d data inserted error.\n", i, nTac_chn);
                                    return 0;
                                }
                            }
                            // 绑定到三项通道
                            _globalTACManager->product_saddr = i;
                            _globalTACManager->product_ph_type = indexT;
                            if (nCtrlType)
                            {
                                _globalTACManager->product_ph_id = nTac_chn;
                                _globalTACManager->product_saddr = i;
                                _globalTACManager->product_ph_type = indexT;
                                if (dev_update_t_ac_power_manage_info(__globalDeviceManage.db, _globalTACManager) != 0)
                                {
                                    log_e("update pwr general data err.");
                                }
                            }
                            if (_globalPowerMangerTemp)
                            {
                                list_add_tail(&_globalTACManager->list_Tree_AC, &_globalPowerMangerTemp->list_Tree_AC);
                            }
                            nTac_chn += 1;
                        }
                    }
                    else
                    {
                        log_i("TreeAC_TYPE_3-3!\n");
                        if ((j + 3) % 3 == 0) // 线路段初始化
                        {
                            _globalPowerMangerTemp = (GlobalPowerManger *)malloc(sizeof(GlobalPowerManger));
                            if (_globalPowerMangerTemp == NULL)
                            {
                                log_e("_globalPowerManger malloc error.\n");
                                return -1;
                            }
                            memset(_globalPowerMangerTemp, 0, sizeof(GlobalPowerManger));
                            INIT_LIST_HEAD(&_globalPowerMangerTemp->list_Tree_AC);
                            _globalPowerMangerTemp->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                            if (_globalPowerMangerTemp->global_over_manager == NULL)
                            {
                                log_e("_globalPowerManger->global_over_manager malloc error.\n");
                                return -1;
                            }
                            memset(_globalPowerMangerTemp->global_over_manager, 0, sizeof(GlobalOverManager));
                            // 查询是否由通道信息
                            ret = dev_get_power_manage_info(_globalDeviceManager->db,
                                                            _globalDeviceManager->_globalDevInfo.product.id, i,
                                                            j / 3 + 1, // 1*8+j
                                                            _globalPowerMangerTemp);
                            _globalPowerMangerTemp->product_ch_addr = j / 3 + 1;
                            // 未查询到信息 则插入
                            if (ret == -1)
                            {
                                _globalPowerMangerTemp->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                                _globalPowerMangerTemp->product_saddr = i;
                                _globalPowerMangerTemp->product_ch_id = chn;
                                _globalPowerMangerTemp->product_ch_addr = j / 3 + 1;
                                sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                                _globalPowerMangerTemp->product_ch_type = type;
                                _globalPowerMangerTemp->product_ch_status = 0;
                                _globalPowerMangerTemp->product_ch_NF_status = 0;

                                _globalPowerMangerTemp->product_ch_start_delay = 1000 * (chn % nGroups != 0 ? chn % nGroups : nGroups);
                                _globalPowerMangerTemp->product_ch_stop_delay = 1000 * (chn % nGroups != 0 ? chn % nGroups : nGroups);

                                if (dev_insert_power_manage_info(_globalDeviceManager->db,
                                                                 _globalDeviceManager->_globalDevInfo.product.id,
                                                                 _globalPowerMangerTemp->product_ch_id,
                                                                 _globalPowerMangerTemp) != 0)
                                {
                                    log_e("address %d chn %d data inserted error.\n", i, chn);
                                    return 0;
                                }
                            }
                            _globalPowerMangerTemp->product_saddr = i;
                            _globalPowerMangerTemp->product_ch_type = type;
                            if (nCtrlType)
                            {
                                _globalPowerMangerTemp->product_ch_id = chn;
                                sprintf(_globalPowerMangerTemp->product_ch_name, "CH%d", _globalPowerMangerTemp->product_ch_id);
                                if (dev_update_power_manage_genera_info_addr(__globalDeviceManage.db, _globalDeviceManager->_globalDevInfo.product.id, _globalPowerMangerTemp->product_saddr, _globalPowerMangerTemp->product_ch_addr, _globalPowerMangerTemp) != 0)
                                {
                                    log_e("update pwr general data err.");
                                }
                            }
                            // 添加到队尾
                            list_add_tail(&_globalPowerMangerTemp->list, &_globalDeviceManager->_globalPowerManger.list);
                            chn += 1;
                        }
                        // 初始化三相子通道三进三出
                        GlobalTreeACManager *_globalTACManager = NULL;
                        _globalTACManager = (GlobalTreeACManager *)malloc(sizeof(GlobalTreeACManager));
                        memset(_globalTACManager, 0, sizeof(GlobalTreeACManager));
                        if (_globalTACManager == NULL)
                        {
                            log_e("_globalTACManager malloc error.\n");
                            return -1;
                        }
                        _globalTACManager->global_over_manager = (GlobalOverManager *)malloc(sizeof(GlobalOverManager));
                        memset(_globalTACManager->global_over_manager, 0, sizeof(GlobalOverManager));
                        if (_globalTACManager->global_over_manager == NULL)
                        {
                            log_e("_globalTACManager->global_over_manager malloc error.\n");
                            return -1;
                        }
                        ret = dev_get_t_ac_power_manage_info(_globalDeviceManager->db,
                                                             _globalDeviceManager->_globalDevInfo.product.id, i,
                                                             j + 1, // 1*8+j
                                                             (j + 3) % 3,
                                                             _globalTACManager);
                        _globalTACManager->product_ch_addr = j + 1;
                        // 未查询到信息 则插入
                        if (ret == -1)
                        {
                            _globalTACManager->product_id = _globalDeviceManager->_globalDevInfo.product.id;
                            _globalTACManager->product_saddr = i;
                            _globalTACManager->product_ch_id = _globalPowerMangerTemp->product_ch_id;
                            _globalTACManager->product_ch_addr = j + 1;
                            _globalTACManager->product_ph_id = nTac_chn;
                            _globalTACManager->product_ph_type = (j + 3) % 3;
                            _globalTACManager->product_ph_outputType = 1;   // 1三相2单相
                            _globalTACManager->product_ph_outputStatus = 1; // 1输出
                            if (dev_insert_t_ac_power_manage_info(_globalDeviceManager->db,
                                                                  _globalDeviceManager->_globalDevInfo.product.id,
                                                                  _globalTACManager->product_ch_id,
                                                                  _globalTACManager) != 0)
                            {
                                log_e("address %d ph_chn %d data inserted error.\n", i, nTac_chn);
                                return 0;
                            }
                        }
                        // 绑定到三项通道
                        _globalTACManager->product_saddr = i;
                        _globalTACManager->product_ph_type = (j + 3) % 3;
                        if (nCtrlType)
                        {
                            _globalTACManager->product_ph_id = nTac_chn;
                            _globalTACManager->product_saddr = i;
                             if (dev_update_t_ac_power_manage_info(__globalDeviceManage.db, _globalTACManager) != 0)
                            {
                                log_e("update pwr general data err.");
                            }
                        }
                        if (_globalPowerMangerTemp)
                        {
                            list_add_tail(&_globalTACManager->list_Tree_AC, &_globalPowerMangerTemp->list_Tree_AC);
                        }
                        nTac_chn += 1;
                    }
                }
            }
            }
        }else
        {
            _globalDeviceManager->pCtrlBoard[i].product_saddr = 0;
            _globalDeviceManager->pCtrlBoard[i].product_number = 0;
            _globalDeviceManager->pCtrlBoard[i].product_type = 0;
        }
    }
    char strLog[200]={"MODBUS"};
    sprintf(strLog,"%s$|$通道",language_alarm_Init_Success[0]);
    char number[10];
    sprintf(number,"%d",chn-1);
    dev_Alarm_Run_message(_globalDeviceManager,strLog,number);
    dev_get_power_ds(_globalDeviceManager->db,&_globalDeviceManager->_globalPowerManger,NULL);
    return ret;
}

int g_switch_get_breaker_info(void* manger,int ntype,int saddr,GlobalBreakerManager* _breaker)
{
    switch (ntype)
    {
    case AC_SINGLE_S_TYPE:
    case AC_SINGLE_B_TYPE:
    {
        return g_switch_get_ac_breaker_info(manger, saddr, _breaker);
    }
    break;
    case DCPDU_TYPE:
    break;
    case TREE_AC_TYPE:
    {
        return g_switch_get_t_ac_breaker_info(manger, saddr, _breaker);
    }
    break;
    case AC_MULTI_S_TYPE:
    case AC_MULTI_B_TYPE:
    case DC_IN_TYPE:
    default:
        return 1;
        break;
    }
    return 1;
}

int g_switch_get_ac_breaker_info(void* manger,int saddr,GlobalBreakerManager* _breaker)
{
    if (_breaker == NULL)
    {
        return -1;
    }
    
    unsigned int offset = 0;
    unsigned int val = 0;
    unsigned short data_temp[2] = {0};
    unsigned int status_temp = 0;
    int ret = 0;
    offset = _SWITCH_AC_BREAKER_INFO;
    // 读取寄存器
    memset(data_temp, 0, sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger, saddr, offset, 1, data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_ac_breaker_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }

    status_temp=data_temp[0];
    // 解开关状态数据，单相控制板最多支持2个开关检测
    if (_breaker->breaker_chn==1)
    {
        _breaker->breaker_status  = status_temp & (BIT_00);
    }
    else if (_breaker->breaker_chn==2)
    {
        _breaker->breaker_status  = status_temp>>1 & (BIT_00);
    }
    else _breaker->breaker_status  = 0;
    
    return 0;
}
int g_switch_get_t_ac_breaker_info(void* manger,int saddr,GlobalBreakerManager* _breaker)
{
    if (_breaker == NULL)
    {
        return -1;
    }
    
    unsigned int offset = 0;
    unsigned int val = 0;
    unsigned short data_temp[2] = {0};
    unsigned int status_temp = 0;
    int ret = 0;
    offset = _SWITCH_T_AC_BREAKER_INFO;
    // 读取寄存器
    memset(data_temp, 0, sizeof(data_temp));
    ret = g_modbus_read_x_reg(manger, saddr, offset, 1, data_temp);
    if (ret < 0)
    {
        log_w("g_switch_get_ac_breaker_info:%d OffSet:%d Ret=%d:%s", saddr, offset, ret, modbus_strerror(errno));
        // log_d("threshold_Addr:%d OffSet:%d Ret=%d",saddr,offset,ret);
        return ret;
    }

    status_temp=data_temp[0];
    // 解开关状态数据，三相控制板最多支持1个开关检测
    if (_breaker->breaker_chn==1)
    {
        _breaker->breaker_status  = status_temp & (BIT_00);
    }
    else _breaker->breaker_status  = 0;
    
    return 0;
}