SmartPDCode/ip/src/switch_ctrl.c

#include "switch_ctrl.h"
#include "modbus_handle.h"
#include "hlw8110_habdle.h"

/// @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) //交流无法使用需要
    {
        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, 8, 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,&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,&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,&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,&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;
}




/// @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 int 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_reg(manger,saddr,offset,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._global_device_info->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._global_device_info->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._global_device_info->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=1;
                    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._global_device_info->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;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_V_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_V_DOWN;
            if(_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_A_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_W_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_P_UP;
            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;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_upper_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_V_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_vol_lower_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_V_DOWN;
            if(_globalPowerMangerTemp->global_over_manager->product_cur_upper_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_A_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwr_upper_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_W_UP;
            if(_globalPowerMangerTemp->global_over_manager->product_pwrcon_upper_enable==1)switch_ctrl[_globalPowerMangerTemp->product_ch_addr]|=ENABLE_P_UP;
            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,GlobalOverManager* _global_over_manager)
{
    int ret =0;
    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:
        {
            return g_switch_set_ac_single_threshold(manger, saddr, (chn - 1), _global_over_manager);
        }
        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);
            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));
            }

            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 RS485_Type:
    {
    
           _power->current = hlw8110_read_IA(__globalDeviceManage._RS485LowConfData);
            //log_d("get _power->current sucessful!!!\n");
           _power->voltage  = hlw8110_read_UV(__globalDeviceManage._RS485LowConfData);
            //log_d("get _power->voltage sucessful!!!\n");
           _power->power =  hwl8110_read_PA(__globalDeviceManage._RS485LowConfData);
           // log_d("get _power->power sucessful!!!\n");
           _power->factor = hwl8110_read_PF(__globalDeviceManage._RS485LowConfData);
            // log_d("get _power->factor sucessful!!!\n");
           _power->freq = hwl8110_read_LineFreq(__globalDeviceManage._RS485LowConfData);
           //_power->a = hlw8110_read_Angle(__globalDeviceManage._RS485LowConfData);
            _power->consumption = hwl8110_read_EA(__globalDeviceManage._RS485LowConfData);
            //log_d("get _power->consumption sucessful!!!\n");            
            int ret=hlw8110_read_Status(__globalDeviceManage._RS485LowConfData,&_power->status);
            if (ret==1)
            {
                log_d("error gpio ReadError");
            }
            
            /* log_d("V:%0.3f,A:%0.3f,P:%0.3f,PF:%0.3f,F_consumption:%0.3f,F_Factor:%0.3f",_power->voltage,
                                                                                    _power->current,
                                                                                    _power->power,
                                                                                    _power->freq,
                                                                                    _power->consumption,
                                                                                    _power->factor); */

    }
        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));
    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_T_AC_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_STS_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 < nNumb; i++)
    {
        status_temp = (data_temp[1] << 16) + data_temp[0];
        _warning[i].w_voltage_up = (status_temp >> i) & 0x1;
    }
    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_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/1000.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] & ENABLE_TAC_V_UP;
    _warning->w_voltage_down    = data_temp[0] & ENABLE_TAC_V_DOWN;
    _warning->w_current         = data_temp[0] & ENABLE_TAC_A_UP;
    _warning->w_power           = data_temp[0] & ENABLE_TAC_W_UP;
    _warning->w_consumption     = data_temp[0] & ENABLE_TAC_P_UP;

    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, 48, 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+24;
    unsigned short* DataTemp=data_temp+48;
    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;
    }
    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 / 1000.0;
    }
    //获取开关状态
    offset = _SWITCH_T_AC_OUT_ENABLE;
    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;
        _power[i].status = data_temp[0+Index] & 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] & ENABLE_TAC_V_UP;
        _warning[i].w_voltage_down    = data_temp[0+Index] & ENABLE_TAC_V_DOWN;
        _warning[i].w_current         = data_temp[0+Index] & ENABLE_TAC_A_UP;
        _warning[i].w_power           = data_temp[0+Index] & ENABLE_TAC_W_UP;
        _warning[i].w_consumption     = data_temp[0+Index] & ENABLE_TAC_P_UP;
    }
    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_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_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_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;
    }    

    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;

}

int  ResetChmData()
{
    //搜索子地址
    int ret=0;
    int chn = 1;
    int type=0;
    __globalDeviceManage.useSlaveCount=0;

    for (size_t i = 0; i <= MAX_CHN_COUNT; i++)
    {
        type = 0 ;
        int nMaxChn=0;
        ret = g_switch_get_type(&__globalDeviceManage._globalRelaySampManger,
                          i,
                          &type,
                          &nMaxChn,
                          __globalDeviceManage._global_device_info->product_pwr_type);
        log_d("ret:%d saddr:%d type:%d ch_num:%d.\n",ret,i,type,nMaxChn);
        //int i =1 ;
        //type = AC_SINGLE_S_TYPE ;
        //chn = i ;

        if(ret==0)
        {
            //有效地址记录
            __globalDeviceManage.useSlaveCount ++ ;
            switch (type)
            {
                case AC_SINGLE_S_TYPE://AC单相小电流 8路继电器
                case AC_SINGLE_B_TYPE://AC单相大电流 4路继电器
                {
                    log_i("Address=%d AC_SINGLE_S_TYPE!\n",i);
                    for (size_t j = 0; j < nMaxChn; j++)
                    {
                        bool isLoad=false ;
                        GlobalPowerManger* _globalPowerMangerTemp=NULL;
                        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                        {
                            if (_globalPowerMangerTemp->product_saddr==i&&_globalPowerMangerTemp->product_ch_addr==j+1)
                            {
                                isLoad=true;
                                break;
                            }
                        }
                        if (!isLoad)
                        {
                            _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(__globalDeviceManage.db,
                                                        __globalDeviceManage._global_device_info->product_id,i,
                                                        j+1, //1*8+j
                                                        _globalPowerMangerTemp);
                        //未查询到信息 则插入
                        if(ret==-1)
                        {
                            _globalPowerMangerTemp->product_id = __globalDeviceManage._global_device_info->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_start_delay = 1000;
                            _globalPowerMangerTemp->product_ch_stop_delay = 1000;
                            if(dev_insert_power_manage_info(__globalDeviceManage.db,
                                                        __globalDeviceManage._global_device_info->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 ;
                        //添加到队尾
                        if (!isLoad)
                        {
                            list_add_tail(&_globalPowerMangerTemp->list,&__globalDeviceManage._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采集
                {


                }
                break;
                case DCPDU_TYPE:    // DCPDU
                {
                    log_i("DCPDU_TYPE!\n");
                    for (size_t j = 0; j < nMaxChn; j++)
                    {
                        bool isLoad=false ;
                        GlobalPowerManger* _globalPowerMangerTemp=NULL;
                        list_for_each_entry(_globalPowerMangerTemp, &__globalDeviceManage._globalPowerManger.list, list)
                        {
                            if (_globalPowerMangerTemp->product_saddr==i&&_globalPowerMangerTemp->product_ch_addr==j+1)
                            {
                                isLoad=true;
                                break;
                            }
                        }
                        if (!isLoad)
                        {
                            _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(__globalDeviceManage.db,
                                                        __globalDeviceManage._global_device_info->product_id,i,
                                                        j+1, //1*8+j
                                                        _globalPowerMangerTemp);
                        _globalPowerMangerTemp->product_ch_addr = j+1;
                        //未查询到信息 则插入
                        if(ret==-1)
                        {
                            _globalPowerMangerTemp->product_id = __globalDeviceManage._global_device_info->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_start_delay = 1000;
                            _globalPowerMangerTemp->product_ch_stop_delay = 1000;
                            if(dev_insert_power_manage_info(__globalDeviceManage.db,
                                                        __globalDeviceManage._global_device_info->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 (dev_update_power_manage_genera_info(__globalDeviceManage.db,__globalDeviceManage._global_device_info->product_id,chn,_globalPowerMangerTemp) != 0)
                        {
                            log_e("update pwr general data err.");
                        }
                        //添加到队尾
                        if (!isLoad)
                        {
                            list_add_tail(&_globalPowerMangerTemp->list,&__globalDeviceManage._globalPowerManger.list);
                        }                        
                        chn+=1;
                    }
                }
                break;
            }
        }
        else
            break;
    }

}