SmartPDCode/f407/applications/cascade.c

#include "cascade.h"
#include "mb.h"
#include "lock.h"
#include "list.h"
#include "modbus.h"
#include <rtthread.h>
#include <unistd.h>
#include "pthread.h"
#include "stdio.h"
#include "string.h"
#include "power.h"
#include "paras.h"


typedef struct {
    uint8_t         cmd;
    uint8_t         obj;
    uint8_t         chId;
    // char            time_s[24];   //start time
    // char            time_e[24];   //end time
		uint8_t 			data[200];
}cmd_data_t;


typedef void * handle_t;

typedef struct {
    mb_inst_t  *h;
    uint8_t    mode;
    uint8_t    type;
}mb_conn_t;

typedef struct {
    mb_conn_t  rtu;
    mb_conn_t  tcp;
    
    rt_thread_t tid;
    uint8_t    quit;
    
    handle_t   rx;
    handle_t   tx;
    
}mb_handle_t;

typedef struct {
    int       addr;
    int       err;      //err times
}slave_t;





typedef struct cascade_info{
	uint8_t  				saddr;
	uint8_t 				md_type;
	//void* 					list_ch;					//cascade_slave list
	//cascade_data_t   cas_data;       
	slave_info_t			info;
	lock_t 					lock;
	void*           mb;
	slave_t         slaves[CASCADE_MAX+1];
	cmd_data_t    cmd;
	union {
		md_ac_dc_t ac_dc;
		md_3_ac_t  ac_3; 
	}data;						//modbus to user
}cascade_handle_t;




static int mb_write_read(cascade_handle_t *cas, int addr, data_t *wd, data_t *rd);
static int master_query(cascade_handle_t *cas);
void slave_func(uint16_t reg,void *r_w_data,uint32_t lenth);




const mb_cb_table_t mb_table = {
    .read_disc = mb_port_read_disc,      //读离散量输入
    .read_coil = mb_port_read_coil,      //读线圈
    .write_coil = mb_port_write_coil,    //写线圈
    .read_input = mb_port_read_input,    //读输入寄存器
    .read_hold = mb_port_read_hold,      //读保持寄存器
    .write_hold = mb_port_write_hold,    //写保持寄存器
};





static cascade_handle_t slave_info = {0};
static mb_cascade_fun_t func = {0};

uint8_t cascade_init(const char* uart,uint8_t mode,uint8_t addr,uint8_t baud)
{	
	list_cfg_t lc={0,LIST_FULL_FIFO,10};
	mb_para_t para;
	para.type = MB_TYPE_RTU;
	para.para.rtu.dev = (char *)uart;
	para.para.rtu.baudrate = baud;
	para.para.rtu.parity = 2;
	para.para.rtu.pin = -1;
  para.para.rtu.lvl = 0;
	paras_data_t* p_data = paras_get();
	addr = p_data->cas.addr;
	if(addr == 0){
		para.mode = MB_MODE_MASTER;
	}else
	{
		para.mode = MB_MODE_SLAVE;
		slave_info.saddr = addr;
	}
  slave_info.lock = lock_init();
	slave_info.mb = mb_init(&para);
  if(!slave_info.mb) {
      return -1;
  }
	if(para.mode == MB_MODE_SLAVE)
	{
		mb_handle_t *handle = (mb_handle_t *)(slave_info.mb);
		mb_set_slave(handle->rtu.h,slave_info.saddr);
		mb_set_cb_table(handle->rtu.h,&mb_table);
		func.slave_func = slave_func;
		mb_set_cb_cascade(handle->rtu.h,&func);
	}
	//cas data
	
	return 0;
}

static uint8_t master_scan(cascade_handle_t *cas)
{
	static uint8_t slave_addr = 1;
	if(slave_addr > CASCADE_MAX)
	{
		slave_addr = 1;
	}
	if(cas->slaves[slave_addr].addr == 0)
	{
		//scan
		uint16_t value = 0;
		lock_on(cas->lock);
		int r = mb_read(cas->mb,slave_addr,CASCADE_REG_SCAN,&value,1,300);
		lock_off(cas->lock);
		if(r > 0)
		{
			cas->slaves[slave_addr].addr = slave_addr;
			cas->slaves[slave_addr].err = 0;
			//获取当前
		}
	}
	slave_addr++;
}






void * cascade_scan_thread(void *arg)
{
	
	while(1)
	{
		if(slave_info.md_type == MB_MODE_MASTER)
		{
			master_scan(&slave_info);
		}else	//做从机//拷贝数据到北向
		{
			paras_data_t* p_data = paras_get();
			power_data_t power = power_data_get();
			if(p_data->prod.type == PDU_AC_I1O1 || p_data->prod.type == PDU_DC_I1O1)
			{
				slave_info.data.ac_dc.dev_cnt = (p_data->prod.type << 8 | power.chs);
				int cnt = power.chs > 64 ? 64 : power.chs;
				//电量信息
				for(int i = 0; i < cnt;i++)
				{
					slave_info.data.ac_dc.power[i].voltage 	= power.pch[i].power[0].voltage *1000;
					slave_info.data.ac_dc.power[i].current 	= power.pch[i].power[0].current *1000;
					slave_info.data.ac_dc.power[i].power 		= power.pch[i].power[0].power *1000;
					slave_info.data.ac_dc.power[i].consumer = power.pch[i].power[0].consump *1000;
					slave_info.data.ac_dc.power[i].factor 	= power.pch[i].power[0].factor *1000;
					slave_info.data.ac_dc.power[i].freq 		= power.pch[i].power[0].freq *1000;
				}
				//总信息
				//slave_info.data.ac_dc.power_all. = power.ttl.total;
				slave_info.data.ac_dc.power_all.all_consumer = power.ttl.total[0].consump *1000;
				slave_info.data.ac_dc.power_all.all_current = power.ttl.total[0].current *1000;
				slave_info.data.ac_dc.power_all.all_power = power.ttl.total[0].power *1000;
				slave_info.data.ac_dc.power_all.all_voltage = power.ttl.total[0].voltage *1000;
				//温湿度
				slave_info.data.ac_dc.temp = 0;				//后续加上传感器数据
				slave_info.data.ac_dc.humity = 0;
				for(int i = 0; i < cnt;i++)
					slave_info.data.ac_dc.switch_stu[i] = 0;
				for(int i = 0; i < cnt;i++)
				{
					slave_info.data.ac_dc.delay_open[i] = power.pch[i].info.start_delay;
				}
				for(int i = 0; i < cnt;i++)
				{
					slave_info.data.ac_dc.delay_close[i] = power.pch[i].info.stop_delay;
				}
			}else
			{
				slave_info.data.ac_3.dev_cnt = (p_data->prod.type << 8 | power.chs);
				for(int i = A_P; i <= C_P;i++)
				{
					slave_info.data.ac_3.ac_3_all_pw[i].consumer = power.ttl.total[i].consump *1000;
					slave_info.data.ac_3.ac_3_all_pw[i].current = power.ttl.total[i].current *1000;
					slave_info.data.ac_3.ac_3_all_pw[i].power = power.ttl.total[i].power *1000;
					slave_info.data.ac_3.ac_3_all_pw[i].voltage = power.ttl.total[i].voltage *1000;
				}
				
			}
		}
		
		
		
		sleep(1);
	}
}

static void* cascade_thread(void *arg)
{
    int r;
    //thread_handle_t *h=(thread_handle_t*)arg;
    cascade_handle_t *cas=&slave_info;
    //ModbusInfo_t *info=&cas->mInfo;
    mb_handle_t *handle=(mb_handle_t *)(cas->mb);
    LOGD("__ cascade %s\n", (cas->md_type==MODBUS_MASTER)?"master":"slave");
    while(handle->quit==0) {
        if(cas->md_type==MODBUS_MASTER) {      //主模
            r = master_query(cas);
            sleep(1);
        }
        else {                                  //从模式，等待主设备发起数据请�?
            //r = slave_receive(cas);
					mb_slave_fsm(handle->rtu.h);
        }  
    }
    
    pthread_exit(NULL);
}


static int slave_get_info(cascade_handle_t *cas)
{
	slave_info_t *info=&cas->info;
	power_data_t power = power_data_get();
	info->channels = power.chs;
	//info->channels=0;
	//memcpy(info->ch,board->pbrd[],)
	//copy mem to info
	if(info->channels  > SLAVE_CH_MAX)
			info->channels = SLAVE_CH_MAX;
	memcpy(info->ch,&power.pch[0],sizeof(power.pch[0]) * info->channels);
	
}


static void* off_on_thread(void *arg)
{
	cascade_handle_t *cas=&slave_info;
	cmd_data_t *pcmd=(cmd_data_t*)arg;
	if(pcmd->cmd==CASCADE_CMD_OPEN) {
     //   LOGD("____ slave CASCADE_CMD_OPEN\n");
  }
   else {
   //     LOGD("____ slave CASCADE_CMD_CLOSE\n");
    }
	int flag=((pcmd->cmd==CASCADE_CMD_OPEN)?1:0);
	if(pcmd->chId == 0xff) {
		// all
	}else
	{
		//one
	}
	 if(pcmd->cmd==CASCADE_CMD_OPEN) {
     //   sprintf(temp,"$开启$|$所有$|$通道$");
    }
    else {
     //   sprintf(temp,"$关闭$|$所有$|$通道$");
    }
		//data base
		free(pcmd);
		pthread_exit(NULL);
}







static int sendlen=0;



void slave_func(uint16_t reg,void *r_w_data,uint32_t lenth)
{
	cmd_data_t *cmd=NULL;
	mb_handle_t *handle = (mb_handle_t *)(slave_info.mb);
	pthread_t id = 0;
	switch (reg)
	{
		case CASCADE_REG_SCAN:

		break;
		case CASCADE_REG_WRITE:
		{
  
			cmd = (cmd_data_t*)(r_w_data);
      if(cmd->cmd>=CASCADE_CMD_GET_INFO) {
					slave_info.cmd = *cmd;
      }
      sendlen = 0;
      
			switch(cmd->cmd)
			{
				case CASCADE_CMD_OPEN:
        case CASCADE_CMD_CLOSE:
				{
					cmd_data_t *pcmd=malloc(sizeof(cmd_data_t));
          if(pcmd) {
            *pcmd = *cmd;
						//thread_start_simp(cmd_thread, pcmd, 4*MB);
						//pthread_create();
						pthread_create(&id,NULL,off_on_thread,pcmd);
						pthread_detach(id);
          }
				}
					break;
        case CASCADE_CMD_OPEN_NF:
        case CASCADE_CMD_CLOSE_NF:
				{
				}
					break;
        case CASCADE_CMD_SAVE:
        case CASCADE_CMD_SAVE3:
				{
				}
					break;
				case CASCADE_CMD_BREAKER_SAVE_ADD:
				{
				}
					break;
				case CASCADE_CMD_BREAKER_SAVE_UPDATE:
				{
				}
					break;
				case CASCADE_CMD_BREAKER_SAVE_DELETE:
				{
				}
					break;
			}
		}
		break;
		case CASCADE_REG_READ:
		{
			cmd = &slave_info.cmd;
			switch(cmd->cmd)
			{
				case CASCADE_CMD_GET_INFO:
				{
					slave_get_info(&slave_info);
					memcpy(r_w_data,&slave_info.info+sendlen,lenth*2);
				}
					break;
				case CASCADE_CMD_QUERY_CH:
				{
					slave_get_info(&slave_info);
					memcpy(r_w_data,&slave_info.info+sendlen,lenth*2);
				}
					break;
				case CASCADE_CMD_BREAKER_QUERY:
					break;
        case CASCADE_CMD_QUERY_VOL:break;
        case CASCADE_CMD_QUERY_CUR:break;
        case CASCADE_CMD_QUERY_PWR:break;
        case CASCADE_CMD_QUERY_PWRQ:break;
        case CASCADE_CMD_QUERY_HIS:break;
        case CASCADE_CMD_QUERY_TOTAL:break;
        case CASCADE_CMD_QUERY_TOTAL_PWR:break;
        case CASCADE_CMD_BREAKER_GET_INFO:break;
			}
			sendlen += lenth*2;
		}
		break;
		default:
		{
			
		}
		break;
	}
}

#define REGS(x)    (((x)+(x)%2)/2)


static int _mb_write(cascade_handle_t *cas, int addr, data_t *d)
{
	int i = 0,r=0,timeout=0;
  int wl,xlen,wlen=0,oncelen=250;
	uint16_t buff[MB_BUF_SIZE];
	if(d->dlen<=0) {
        return -1;
  }
	lock_on(cas->lock);
	while(1)
	{
		 if(wlen+oncelen>d->dlen) {
			xlen = d->dlen-wlen;
     } else 
		 {
       xlen = oncelen;
     }
		xlen += xlen%2;
		memcpy(buff, d->data+wlen, xlen);
		wl = mb_write(cas->mb, addr, CASCADE_REG_WRITE, buff, xlen/2);
		if(wl<0) {
			LOGE("___ _mb_write failed, addr: %d, reg: %d, cnt: %d, %s, retry: %d\n", addr, CASCADE_REG_WRITE, xlen/2,"write failed",i);
      r = -1; 
			break;
    }
		if(wlen+wl*2>=d->dlen) {
      break;
    }else {
      xlen = wl*2;
    }
    wlen += xlen;
	}
	lock_off(cas->lock);
}
static int _mb_read(cascade_handle_t *cas, int addr, data_t *d)
{
    int i=0,r=0,finish=0,timeout=0;
    int rl,xlen,rlen=0,oncelen=250;
    uint16_t buff[MB_BUF_SIZE];	
    if(d->dlen<=0) {
        return -1;
    }
		lock_on(cas->lock);
    while(1) {
			if(rlen+oncelen>d->dlen) {
         xlen = d->dlen-rlen;
      }else{
         xlen = oncelen;
      }
      xlen += xlen%2;
      rl = mb_read(cas->mb, addr, CASCADE_REG_READ, buff, xlen/2,500000);
      if(rl<0) {
        LOGE("___ _mb_read failed, %s, rlen: %d, retry: %d\n", "read error", rlen, i);
        r = -1; break;
      }
      if(rlen+rl*2>=d->dlen) {
        xlen = d->dlen-rlen;
				finish = 1;
      }else 
			{
        xlen = rl*2;
      }

      memcpy((char*)d->data+rlen, buff, xlen);
      rlen += xlen;
      if(finish) {
         break;
      }
    }
		
}

static int mb_write_read(cascade_handle_t *cas, int addr, data_t *wd, data_t *rd)
{
    int r=0;
    
    r = _mb_write(cas->mb, addr,wd);
    if(r==0) {
        r = _mb_read(cas->mb, addr,rd);
    }
    return r;
}

static int master_cmd(cascade_handle_t *cas,uint8_t cur_dev_addr ,cmd_data_t *cmd)
{
    int i,r;
    data_t rdata,wdata;
		
    if(cur_dev_addr==0) {
        return -1;
    }

    switch(cmd->cmd) {
        case CASCADE_CMD_OPEN:
        case CASCADE_CMD_CLOSE:
        case CASCADE_CMD_SAVE:
        case CASCADE_CMD_SAVE3:
        case CASCADE_CMD_OPEN_NF:
        case CASCADE_CMD_CLOSE_NF:
        {
            LOGD("____ master CMD: %d\n", cmd->cmd);

            wdata.dlen = sizeof(cmd_data_t);
            wdata.data = (uint8_t*)cmd;
            r = _mb_write(cas, cur_dev_addr, &wdata);
        }
        break;

        case CASCADE_CMD_GET_INFO:
        {
            wdata.dlen = sizeof(cmd_data_t);
            wdata.data = (uint8_t*)cmd;

            rdata.dlen = sizeof(slave_info_t)-sizeof(power_ch_t)*SLAVE_CH_MAX;
            rdata.data = (uint8_t*)&cas->info;

            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
            if(r==0) {
                //LOGD("______cas->info.cnt: %d\n", cas->sInfo.cnt);
                rdata.dlen = sizeof(slave_info_t)-sizeof(power_ch_t)*(SLAVE_CH_MAX - cas->info.channels);
                rdata.data = (uint8_t*)&cas->info;
                r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
                if(r==0) {
                    //power_add(cas);
                }
            }
            else {
                LOGE("_____ master CASCADE_CMD_GET_INFO failed\n");
            }
        }
        break;
        case CASCADE_CMD_BREAKER_GET_INFO:
        {
//            wdata.dlen = sizeof(cmd_data_t);
//            wdata.data = (uint8_t*)cmd;
//            rdata.dlen = sizeof(breaker_info_t)-sizeof(breaker_channel_info_t)*CH_MAX;
//            rdata.data = (uint8_t*)&cas->sBreaker;
//            LOGD("_____ master send CASCADE_CMD_BREAKER_GET_INFO\n");
//            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
//            if(r==0) {
//                LOGD("______cas->info.cnt: %d\n", cas->sBreaker.cnt);
//                rdata.dlen = sizeof(breaker_info_t)-sizeof(breaker_channel_info_t)*(CH_MAX-cas->sBreaker.cnt);
//                rdata.data = (uint8_t*)&cas->sBreaker;
//                r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
//                if(r==0) {
//                   breaker_add(cas);
//                }
//            }
        }
        break;
        case CASCADE_CMD_BREAKER_SAVE_UPDATE:
        case CASCADE_CMD_BREAKER_SAVE_DELETE:
        case CASCADE_CMD_BREAKER_SAVE_ADD:
        {
//            wdata.dlen = sizeof(cmd_data_t);
//            wdata.data = (uint8_t*)cmd;
//            r = mb_write(cas, cur_dev_addr, &wdata);
        }
        break;
        default:
        cas->cmd = *cmd;
        r = 0;
    }

    return r;
}


static int master_query(cascade_handle_t *cas)
{
    int i,r;
    cmd_data_t *cmd=&cas->cmd;
    data_t rdata,wdata;

    wdata.dlen = sizeof(cmd_data_t);
    wdata.data = (uint8_t*)cmd;
 
    switch(cmd->cmd) {

        case CASCADE_CMD_QUERY_CH:
        {

            //LOGD("__00__ master query CASCADE_CMD_QUERY_CH, cnt: %d\n", cas->sInfo.cnt);
            if(cas->info.channels==0 || cas->info.channels>SLAVE_CH_MAX) {
                return -1;
            }

            rdata.dlen = sizeof(slave_info_t)-sizeof(power_ch_t)*(CH_MAX-cas->info.channels);
            rdata.data = (uint8_t*)&cas->info;
            
            r = mb_write_read(cas, cas->saddr, &wdata, &rdata);
            if(r==0) {
                //power_update(cas);
                cmd->cmd = CASCADE_CMD_BREAKER_QUERY;
            }
            else {
                LOGE("____ master query CASCADE_CMD_QUERY_CH failed\n");
            }
            //LOGD("__11__ master query CASCADE_CMD_QUERY_CH, cnt: %d\n", cas->sInfo.cnt);
        }
        break;
        case CASCADE_CMD_BREAKER_QUERY:
        {
            
//            wdata.dlen = sizeof(cmd_data_t);
//            wdata.data = (uint8_t*)cmd;
//            rdata.dlen = sizeof(breaker_info_t)-sizeof(breaker_channel_info_t)*CH_MAX;
//            rdata.data = (uint8_t*)&cas->sBreaker;
//            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
//            LOGD("____ master query CASCADE_CMD_BREAKER_QUERY, cnt: %d\n", cas->sBreaker.cnt);
//            if(cas->sBreaker.cnt==0 || cas->sBreaker.cnt>CH_MAX)
//            {
//                breaker_clear(cas);
//                cmd->cmd = CASCADE_CMD_QUERY_CH;
//                return -1;
//            }
//            rdata.dlen = sizeof(breaker_info_t)-sizeof(breaker_channel_info_t)*(CH_MAX-cas->sBreaker.cnt);
//            rdata.data = (uint8_t*)&cas->sBreaker;
//            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
//            if(r == 0)
//            {
//                breaker_add(cas);
//                cmd->cmd = CASCADE_CMD_QUERY_CH;
//            }else
//            {
//                LOGE("____ master query CASCADE_CMD_BREAKER_QUERY failed\n");
//            }
        }
        break;
        case CASCADE_CMD_QUERY_VOL:
        {
//            if(cmd->obj==OBJ_CHANNEL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else if(cmd->obj==OBJ_OVERALL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else {
//                return -1;
//            }
        }
        break;

        case CASCADE_CMD_QUERY_CUR:
        {
//            if(cmd->obj==OBJ_CHANNEL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else if(cmd->obj==OBJ_OVERALL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else {
//                return -1;
//            }
        }
        break;

        case CASCADE_CMD_QUERY_PWR:
        {
//            if(cmd->obj==OBJ_CHANNEL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else if(cmd->obj==OBJ_OVERALL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else {
//                return -1;
//            }
        }
        break;

        case CASCADE_CMD_QUERY_PWRQ:
        {
//            if(cmd->obj==OBJ_CHANNEL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else if(cmd->obj==OBJ_OVERALL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else {
//                return -1;
//            }
        }
        break;

        case CASCADE_CMD_QUERY_HIS:
        {
//            if(cmd->obj==OBJ_CHANNEL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else if(cmd->obj==OBJ_OVERALL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else {
//                return -1;
//            }
        }
        break;

        case CASCADE_CMD_QUERY_TOTAL:
        {
//            if(cmd->obj==OBJ_CHANNEL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else if(cmd->obj==OBJ_OVERALL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else {
//                return -1;
//            }
        }
        break;

        case CASCADE_CMD_QUERY_TOTAL_PWR:
        {
//            if(cmd->obj==OBJ_CHANNEL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else if(cmd->obj==OBJ_OVERALL) {
//                //rdata.dlen = sizeof(chInfo);
//                //rdata.data = (uint8_t*)&chInfo;
//            }
//            else {
//                return -1;
//            }
        }
        break;

        default:
        //LOGD("____ master query cmd: %d\n", cmd->cmd);
        return -1;
    }

    return r;
}


int mb_port_read_disc(u16 addr, u8 *pbit)//读离散量输入, 返回 : 0-成功, -2-地址错误
{
    MB_ASSERT(pbit != NULL);
    
    return(-2);
}

int mb_port_read_coil(u16 addr, u8 *pbit)//读线圈, 返回 : 0-成功, -2-地址错误
{
    MB_ASSERT(pbit != NULL);
    
    return(-2);
}

int mb_port_write_coil(u16 addr, u8 bit)//写线圈, 返回 : 0-成功, -2-地址错误, -4-设备故障
{
    return(-2);
}

int mb_port_read_input(u16 addr, u16 *preg)//读输入寄存器, 返回 : 0-成功, -2-地址错误
{
    MB_ASSERT(preg != NULL);
    
    return(-2);
}

int mb_port_read_hold(u16 addr, u16 *preg)//读保持寄存器, 返回 : 0-成功, -2-地址错误
{
    MB_ASSERT(preg != NULL);
		uint16_t *data = NULL;
    if( AC_DC_DEV_CHN_REG <= addr &&  addr <= AC_DC_DRY_REG)
		{
			data = (uint16_t*)(&slave_info.data.ac_dc);
			uint32_t offset = addr - AC_DC_DEV_CHN_REG;
			*preg = *(data+offset);
			return 0;
		}
		if(AC_3_DEV_CHN_REG <= addr && addr <= AC_3_DRY_REG)
		{
			data = (uint16_t*)(&slave_info.data.ac_3);
			uint32_t offset = addr - AC_DC_DEV_CHN_REG;
			*preg = *(data+offset);
			return 0;
		}	
		return(-2);
}

int mb_port_write_hold(u16 addr, u16 reg)//写保持寄存器, 返回 : 0-成功, -2-地址错误, -3-值非法, -4-设备故障
{
	//board_all_t *board = get_control_board();
  power_data_t power = power_data_get();
	if(AC_DC_SET_DELAY_OPEN <= addr && addr <= AC_DC_ALL_SET_SWITCH_REG)
	{
		switch(addr)
		{
			case AC_DC_SET_DELAY_OPEN ... (AC_DC_SET_DELAY_CLOSE-1):
			{
				uint16_t channel = addr - AC_DC_SET_DELAY_OPEN;
				//获取通道控制接口 写入数据
				
				
			}
			break;
		}
		return 0;
	}
	return(-2);
}