|
|
@@ -30,10 +30,9 @@
|
|
|
|
|
|
|
|
|
|
|
|
-
|
|
|
-
|
|
|
int cur_dev_addr=1;
|
|
|
static cascade_handle_t casHandle={.inited=0};
|
|
|
+static void* cmd_thread(void *arg);
|
|
|
|
|
|
//////////////////////////////////////////////////
|
|
|
static inline GlobalDeviceManager* get_dm(void)
|
|
|
@@ -74,15 +73,30 @@ static int slave_init(cascade_handle_t *cas)
|
|
|
}
|
|
|
static int slave_add(cascade_handle_t *cas, int addr)
|
|
|
{
|
|
|
+ if(addr<=0) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
cas->slaves[addr].addr = addr;
|
|
|
cas->slaves[addr].err = 0;
|
|
|
return 0;
|
|
|
}
|
|
|
+static int slave_rm(cascade_handle_t *cas, int addr)
|
|
|
+{
|
|
|
+ if(addr<=0) {
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ cas->slaves[addr].addr = -1;
|
|
|
+ cas->slaves[addr].err = 0;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
static int slave_cnt(cascade_handle_t *cas)
|
|
|
{
|
|
|
int i,cnt=0;
|
|
|
for(i=1; i<=CASCADE_MAX; i++) {
|
|
|
- if(cas->slaves[i].addr>=0) {
|
|
|
+ if(cas->slaves[i].addr>0) {
|
|
|
cnt++;
|
|
|
}
|
|
|
}
|
|
|
@@ -94,7 +108,7 @@ static slave_t* slave_get(cascade_handle_t *cas, int addr)
|
|
|
}
|
|
|
static int slave_find(cascade_handle_t *cas, int addr)
|
|
|
{
|
|
|
- if(cas->slaves[addr].addr>=0) {
|
|
|
+ if(cas->slaves[addr].addr>0) {
|
|
|
return 1;
|
|
|
}
|
|
|
return 0;
|
|
|
@@ -262,13 +276,40 @@ static int mb_deinit(cascade_handle_t *cas)
|
|
|
g_modbus_deinit(&cas->m);
|
|
|
return 0;
|
|
|
}
|
|
|
+static int _mb_scan(cascade_handle_t *cas, int addr)
|
|
|
+{
|
|
|
+ uint16_t tmp;
|
|
|
+ return g_modbus_read_x_reg(&cas->m, addr, CASCADE_REG_SCAN, 1, &tmp);
|
|
|
+}
|
|
|
static int _mb_read(cascade_handle_t *cas, int addr, uint16_t reg, uint16_t *data, int cnt)
|
|
|
{
|
|
|
- return g_modbus_read_x_reg(&cas->m, addr, reg, cnt, data);
|
|
|
+ int r;
|
|
|
+ r = g_modbus_read_x_reg(&cas->m, addr, reg, cnt, data);
|
|
|
+ if(r<0) {
|
|
|
+ cas->slaves[addr].err++;
|
|
|
+ if(cas->slaves[addr].err>ERR_MAX) {
|
|
|
+ slave_rm(cas, addr);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ cas->slaves[addr].err = 0;
|
|
|
+ }
|
|
|
+ return r;
|
|
|
}
|
|
|
static int _mb_write(cascade_handle_t *cas, int addr, uint16_t reg, uint16_t *data, int cnt)
|
|
|
{
|
|
|
- return g_modbus_write_x_reg(&cas->m, addr, reg, cnt, data);
|
|
|
+ int r;
|
|
|
+ r = g_modbus_write_x_reg(&cas->m, addr, reg, cnt, data);
|
|
|
+ if(r<0) {
|
|
|
+ cas->slaves[addr].err++;
|
|
|
+ if(cas->slaves[addr].err>ERR_MAX) {
|
|
|
+ slave_rm(cas, addr);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ cas->slaves[addr].err = 0;
|
|
|
+ }
|
|
|
+ return r;
|
|
|
}
|
|
|
static int _mb_recv(cascade_handle_t *cas, uint8_t *buf)
|
|
|
{
|
|
|
@@ -320,6 +361,18 @@ static void memcpy_swap(uint8_t *dst, uint8_t *src, int len)
|
|
|
dst[i+1] = src[i];
|
|
|
}
|
|
|
}
|
|
|
+static int print_hdr(char *s, mb_hdr_t *h)
|
|
|
+{
|
|
|
+ LOGD("____%s___ h.addr: %d\n", s, h->addr);
|
|
|
+ LOGD("____%s___ h.func: %d\n", s, h->func);
|
|
|
+ LOGD("____%s___ h.reg: %d\n", s, h->reg);
|
|
|
+ LOGD("____%s___ h.regcnt: %d\n", s, h->regcnt);
|
|
|
+ LOGD("____%s___ h.dlen: %d\n", s, h->dlen);
|
|
|
+ LOGD("____%s___ h.data: %d\n", s, h->data);
|
|
|
+ LOGD("\n");
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
static int mb_hdr(uint8_t *data, int datalen, mb_hdr_t *h)
|
|
|
{
|
|
|
h->addr = data[0];
|
|
|
@@ -335,6 +388,7 @@ static int mb_hdr(uint8_t *data, int datalen, mb_hdr_t *h)
|
|
|
|
|
|
memswap(h->data, h->dlen+h->dlen%2);
|
|
|
}
|
|
|
+ //print_hdr("sss", h);
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
@@ -406,8 +460,7 @@ static int mb_write(cascade_handle_t *cas, int addr, data_t *d)
|
|
|
memcpy(buff, d->data+wlen, xlen);
|
|
|
r = _mb_write(cas, addr, CASCADE_REG_WRITE, buff, xlen/2);
|
|
|
if(r<0) {
|
|
|
- //LOGE("___ _mb_write, addr: %d, reg: %d, cnt: %d\n", addr, CASCADE_REG_WRITE, xlen/2);
|
|
|
- LOGE("___ _mb_write failed, errno: %d, %s\n", errno, modbus_strerror(errno));
|
|
|
+ LOGE("___ _mb_write, addr: %d, reg: %d, cnt: %d, %s\n", addr, CASCADE_REG_WRITE, xlen/2, modbus_strerror(errno));
|
|
|
return -1;
|
|
|
}
|
|
|
if(wlen+r*2>=d->dlen) {
|
|
|
@@ -434,19 +487,17 @@ static int mb_write_read(cascade_handle_t *cas, int addr, data_t *wd, data_t *rd
|
|
|
}
|
|
|
static int mb_receive(cascade_handle_t *cas)
|
|
|
{
|
|
|
- int r=0,rlen=0;
|
|
|
+ int r=-1,rc,rlen=0;
|
|
|
mb_hdr_t h;
|
|
|
- board_info_t info;
|
|
|
- modbus_mapping_t *map=NULL;
|
|
|
uint8_t buff[MODBUS_RTU_MAX_ADU_LENGTH];
|
|
|
- static int precmd=-1;
|
|
|
static int sendlen=0;
|
|
|
+ cmd_data_t *cmd=NULL;
|
|
|
|
|
|
- r = _mb_recv(cas, buff);
|
|
|
- if(r<0) {
|
|
|
+ rc = _mb_recv(cas, buff);
|
|
|
+ if(rc<0) {
|
|
|
return -1;
|
|
|
}
|
|
|
- mb_hdr(buff, r, &h);
|
|
|
+ mb_hdr(buff, rc, &h);
|
|
|
|
|
|
#if 1
|
|
|
//do not know why slave can receive all address data
|
|
|
@@ -454,64 +505,33 @@ static int mb_receive(cascade_handle_t *cas)
|
|
|
return -1;
|
|
|
}
|
|
|
#endif
|
|
|
- //LOGD("____ slave recv, reg: %d\n", h.reg);
|
|
|
|
|
|
- //如果是非自定义寄存器则跳出
|
|
|
- if(h.reg==CASCADE_REG_READ || h.reg==CASCADE_REG_WRITE) {
|
|
|
- if(h.data) {
|
|
|
- cmd_data_t *cmd = (cmd_data_t*)h.data;
|
|
|
- cas->cmd = *cmd;
|
|
|
-
|
|
|
- precmd = cmd->cmd;
|
|
|
- sendlen = 0;
|
|
|
+ switch(h.reg) {
|
|
|
+ case CASCADE_REG_SCAN:
|
|
|
+ {
|
|
|
+ r = _mb_reply(cas, buff, rc, cas->map2);
|
|
|
}
|
|
|
+ break;
|
|
|
+
|
|
|
+ case CASCADE_REG_WRITE:
|
|
|
+ {
|
|
|
+ if(h.data) {
|
|
|
+ cmd = (cmd_data_t*)h.data;
|
|
|
+ if(cmd->cmd>=CASCADE_CMD_GET_INFO) {
|
|
|
+ cas->cmd = *cmd;
|
|
|
+ }
|
|
|
+ sendlen = 0;
|
|
|
+ }
|
|
|
|
|
|
- if(h.reg==CASCADE_REG_WRITE) {
|
|
|
- switch(cas->cmd.cmd) {
|
|
|
+ switch(cmd->cmd) {
|
|
|
case CASCADE_CMD_OPEN:
|
|
|
case CASCADE_CMD_CLOSE:
|
|
|
{
|
|
|
- int i,t=0;
|
|
|
- char buff[80];
|
|
|
- board_info_t *info=&cas->info;
|
|
|
- GlobalDeviceManager *dm=get_dm();
|
|
|
-
|
|
|
- if(cas->cmd.cmd==CASCADE_CMD_OPEN) {
|
|
|
- LOGD("____ slave CASCADE_CMD_OPEN\n");
|
|
|
- }
|
|
|
- else {
|
|
|
- LOGD("____ slave CASCADE_CMD_CLOSE\n");
|
|
|
- }
|
|
|
-
|
|
|
- int flag=(cas->cmd.cmd==CASCADE_CMD_OPEN)?1:0;
|
|
|
- if(cas->cmd.chId == 0xff) {
|
|
|
- for(i=0; i<info->cnt; i++) {
|
|
|
- if(info->channel[i].addr>0) {
|
|
|
- t = g_switch_set_all_ctrl(&dm->_globalRelaySampManger, info->channel[i].type, info->channel[i].addr, flag);
|
|
|
- if(t) {
|
|
|
- LOGE("___ %d %s failed\n", info->channel[i].addr, (cas->cmd.cmd==CASCADE_CMD_OPEN)?"open":"close");
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- GlobalPowerManger *tmp=NULL;
|
|
|
- list_for_each_entry(tmp, &dm->_globalPowerManger.list, list)
|
|
|
- {
|
|
|
- if(tmp->product_ch_id==cas->cmd.chId) {
|
|
|
- t = g_switch_set_all_chn_ctrl(&dm->_globalRelaySampManger, tmp, tmp->product_saddr, tmp->product_ch_addr, flag, false);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
+ cmd_data_t *pcmd=malloc(sizeof(cmd_data_t));
|
|
|
+ if(pcmd) {
|
|
|
+ *pcmd = *cmd;
|
|
|
+ thread_start_simp(cmd_thread, pcmd, 4*MB);
|
|
|
}
|
|
|
-
|
|
|
- if(cas->cmd.cmd==CASCADE_CMD_OPEN) {
|
|
|
- sprintf(buff,"$开启$|$所有$|$通道$");
|
|
|
- }
|
|
|
- else {
|
|
|
- sprintf(buff,"$关闭$|$所有$|$通道$");
|
|
|
- }
|
|
|
- dev_insert_alarm_ctrl(dm->db, dm->_global_device_info->product_id,3,buff);
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
@@ -523,82 +543,72 @@ static int mb_receive(cascade_handle_t *cas)
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
- r = _mb_reply(cas, buff, r, cas->map2);
|
|
|
+ r = _mb_reply(cas, buff, rc, cas->map2);
|
|
|
}
|
|
|
- else {
|
|
|
- if(h.regcnt==1) {
|
|
|
- LOGD("____ CASCADE SCAN\n");
|
|
|
- r = _mb_reply(cas, buff, r, cas->map2);
|
|
|
- }
|
|
|
- else {
|
|
|
+ break;
|
|
|
+
|
|
|
+ case CASCADE_REG_READ:
|
|
|
+ {
|
|
|
+ cmd = &cas->cmd;
|
|
|
|
|
|
- LOGD("____ CASCADE_REG_READ %d\n", cas->cmd.cmd);
|
|
|
- switch(cas->cmd.cmd) {
|
|
|
+ //LOGD("____ CASCADE_REG_READ %d\n", cmd->cmd);
|
|
|
+ switch(cmd->cmd) {
|
|
|
|
|
|
- case CASCADE_CMD_GET_INFO:
|
|
|
- {
|
|
|
- LOGD("_____ slave CASCADE_CMD_GET_INFO\n");
|
|
|
- slave_get_info(cas, 0); //hardread will cost long time
|
|
|
- memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), (char*)&cas->info+sendlen, h.regcnt*2);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case CASCADE_CMD_QUERY_CH:
|
|
|
- {
|
|
|
- #if 0
|
|
|
- if(cas->cmd.obj==OBJ_OVERALL) {
|
|
|
- LOGD("___ slave CASCADE_CMD_QUERY_CH, overall\n");
|
|
|
-
|
|
|
- slave_get_all_data(cas);
|
|
|
- memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), ((char*)&cas->allInfo)+sendlen, h.regcnt*2);
|
|
|
- }
|
|
|
- else
|
|
|
- #endif
|
|
|
- {
|
|
|
- LOGD("___ slave CASCADE_CMD_QUERY_CH, channel\n");
|
|
|
-
|
|
|
- slave_get_ch_data(cas);
|
|
|
- memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), ((char*)&cas->chInfo)+sendlen, h.regcnt*2);
|
|
|
- }
|
|
|
- }
|
|
|
- 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_GET_INFO:
|
|
|
+ {
|
|
|
+ LOGD("_____ slave CASCADE_CMD_GET_INFO\n");
|
|
|
+ slave_get_info(cas, 0); //hardread will cost long time
|
|
|
+ memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), (char*)&cas->info+sendlen, h.regcnt*2);
|
|
|
}
|
|
|
+ break;
|
|
|
+
|
|
|
+ case CASCADE_CMD_QUERY_CH:
|
|
|
+ {
|
|
|
+ LOGD("___ slave CASCADE_CMD_QUERY_CH\n");
|
|
|
|
|
|
- r = _mb_reply(cas, buff, r, cas->map2);
|
|
|
- if(r>0) {
|
|
|
- sendlen += h.regcnt*2;
|
|
|
- //LOGD("____ slave sendlen: %d, h.dlen: %d, r: %d\n", sendlen, h.dlen, r);
|
|
|
+ slave_get_ch_data(cas);
|
|
|
+ memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), ((char*)&cas->chInfo)+sendlen, h.regcnt*2);
|
|
|
}
|
|
|
+ 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;
|
|
|
+ }
|
|
|
+
|
|
|
+ r = _mb_reply(cas, buff, rc, cas->map2);
|
|
|
+ if(r>0) {
|
|
|
+ sendlen += h.regcnt*2;
|
|
|
+ //LOGD("____ slave sendlen: %d, h.dlen: %d, r: %d\n", sendlen, h.dlen, r);
|
|
|
}
|
|
|
}
|
|
|
- }
|
|
|
- else {
|
|
|
- Modbus_Manger *mm=&get_dm()->_globalRelaySampManger;
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ {
|
|
|
+ Modbus_Manger *mm=&get_dm()->_globalRelaySampManger;
|
|
|
|
|
|
- LOGD("___ slave XXXXXXXXXXX\n");
|
|
|
+ LOGD("___ slave XXXXXXXXXXX\n");
|
|
|
|
|
|
- if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
|
|
|
- cascade_slave_read(cas, h.reg, h.regcnt);
|
|
|
- }
|
|
|
- else if(h.func==MODBUS_FC_WRITE_SINGLE_REGISTER) {
|
|
|
- cascade_slave_write(cas, h.reg, h.regcnt);
|
|
|
- }
|
|
|
+ if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
|
|
|
+ cascade_slave_read(cas, h.reg, h.regcnt);
|
|
|
+ }
|
|
|
+ else if(h.func==MODBUS_FC_WRITE_SINGLE_REGISTER) {
|
|
|
+ cascade_slave_write(cas, h.reg, h.regcnt);
|
|
|
+ }
|
|
|
|
|
|
- r = _mb_reply(cas, buff, r, cas->map);
|
|
|
+ r = _mb_reply(cas, buff, rc, cas->map);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
return r ;
|
|
|
}
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
-static int cascade_scan(cascade_handle_t *cas)
|
|
|
+static int master_scan(cascade_handle_t *cas)
|
|
|
{
|
|
|
int i,r=0 ;
|
|
|
uint16_t tmp[10];
|
|
|
@@ -608,7 +618,7 @@ static int cascade_scan(cascade_handle_t *cas)
|
|
|
}
|
|
|
|
|
|
if(!slave_find(cas, cas->scanAddr)) {
|
|
|
- r = _mb_read(cas, cas->scanAddr, CASCADE_REG_READ, tmp, 1);
|
|
|
+ r = _mb_scan(cas, cas->scanAddr);
|
|
|
if(r>0) {
|
|
|
LOGD("____ find a slave, addr: %d\n", cas->scanAddr);
|
|
|
slave_add(cas, cas->scanAddr);
|
|
|
@@ -674,7 +684,7 @@ static int power_add(cascade_handle_t *cas)
|
|
|
GlobalPowerManger* pm=NULL;
|
|
|
board_info_t *info=&cas->info;
|
|
|
|
|
|
- LOGD("__**___ master add channel to the list, cnt: %d\n", info->cnt);
|
|
|
+ LOGD("____ master add channel to the list, cnt: %d\n", info->cnt);
|
|
|
cascade_lock();
|
|
|
|
|
|
power_clear(cas);
|
|
|
@@ -732,8 +742,10 @@ static int power_ch_update(cascade_handle_t *cas)
|
|
|
power_info_t *power=cas->chInfo.power;
|
|
|
|
|
|
if(cas->chInfo.cnt==0 || list_empty(&dm2->_globalPowerManger.list)) {
|
|
|
+ LOGE("___ chInfo.cnt is 0\n");
|
|
|
return -1;
|
|
|
}
|
|
|
+ //LOGD("___ chInfo.info[0].status: %d\n", power[0].pwrinfo.status);
|
|
|
|
|
|
list_for_each_entry(tmp, &dm2->_globalPowerManger.list, list)
|
|
|
{
|
|
|
@@ -804,7 +816,7 @@ static int power_get(cascade_handle_t *cas, int addr, sensor_data_t *ss)
|
|
|
}
|
|
|
|
|
|
#define REGS(x) (((x)+(x)%2)/2)
|
|
|
-static int master_request(cascade_handle_t *cas, cmd_data_t *cmd)
|
|
|
+static int master_cmd(cascade_handle_t *cas, cmd_data_t *cmd)
|
|
|
{
|
|
|
int i,r;
|
|
|
GlobalPowerManger *tmp=NULL;
|
|
|
@@ -825,7 +837,7 @@ static int master_request(cascade_handle_t *cas, cmd_data_t *cmd)
|
|
|
{
|
|
|
LOGD("____ master CMD: %d\n", cmd->cmd);
|
|
|
|
|
|
- wdata.dlen = sizeof(*cmd);
|
|
|
+ wdata.dlen = sizeof(cmd_data_t);
|
|
|
wdata.data = (uint8_t*)cmd;
|
|
|
r = mb_write(cas, cur_dev_addr, &wdata);
|
|
|
}
|
|
|
@@ -833,25 +845,32 @@ static int master_request(cascade_handle_t *cas, cmd_data_t *cmd)
|
|
|
|
|
|
case CASCADE_CMD_GET_INFO:
|
|
|
{
|
|
|
- wdata.dlen = sizeof(*cmd);
|
|
|
+ wdata.dlen = sizeof(cmd_data_t);
|
|
|
wdata.data = (uint8_t*)cmd;
|
|
|
|
|
|
- rdata.dlen = sizeof(cas->info);
|
|
|
- rdata.data = (uint8_t*)&cas->info;
|
|
|
+ rdata.dlen = 1;
|
|
|
+ rdata.data = (uint8_t*)&cas->info.cnt;
|
|
|
|
|
|
LOGD("_____ master send CASCADE_CMD_GET_INFO\n");
|
|
|
r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
|
|
|
if(r==0) {
|
|
|
- power_add(cas);
|
|
|
+ LOGD("______cas->info.cnt: %d\n", cas->info.cnt);
|
|
|
+ rdata.dlen = sizeof(cas->info.cnt);
|
|
|
+ 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 request CASCADE_CMD_GET_INFO failed\n");
|
|
|
+ LOGE("_____ master CASCADE_CMD_GET_INFO failed\n");
|
|
|
}
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
- return -1;
|
|
|
+ cas->cmd = *cmd;
|
|
|
+ r = 0;
|
|
|
}
|
|
|
|
|
|
return r;
|
|
|
@@ -861,7 +880,7 @@ static int master_query(cascade_handle_t *cas)
|
|
|
int i,r;
|
|
|
GlobalPowerManger *tmp=NULL;
|
|
|
GlobalDeviceManager *dm2=get_dm2();
|
|
|
- GlobalDeviceInfo *dev=&dm2->_global_device_info;
|
|
|
+ GlobalDeviceInfo *dev=dm2->_global_device_info;
|
|
|
cmd_data_t *cmd=&cas->cmd;
|
|
|
data_t rdata,wdata;
|
|
|
|
|
|
@@ -876,28 +895,22 @@ static int master_query(cascade_handle_t *cas)
|
|
|
|
|
|
case CASCADE_CMD_QUERY_CH:
|
|
|
{
|
|
|
- //LOGD("____ master query CASCADE_CMD_QUERY_CH\n");
|
|
|
+ //LOGD("____ master query CASCADE_CMD_QUERY_CH, cnt: %d\n", cas->info.cnt);
|
|
|
if(cas->info.cnt==0) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
-#if 0
|
|
|
- if(cmd->obj==OBJ_OVERALL) {
|
|
|
- rdata.dlen = sizeof(PowerInfo);
|
|
|
- rdata.data = (uint8_t*)cas->allInfo.info;
|
|
|
- }
|
|
|
- else
|
|
|
-#endif
|
|
|
- {
|
|
|
- cas->chInfo.cnt = 0;
|
|
|
- rdata.dlen = sizeof(uint8_t)+sizeof(power_info_t)*cas->info.cnt;
|
|
|
- rdata.data = (uint8_t*)&cas->chInfo;
|
|
|
- }
|
|
|
+ cas->chInfo.cnt = 0;
|
|
|
+ rdata.dlen = sizeof(uint8_t)+sizeof(power_info_t)*cas->info.cnt;
|
|
|
+ rdata.data = (uint8_t*)&cas->chInfo;
|
|
|
|
|
|
r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
|
|
|
if(r==0) {
|
|
|
power_ch_update(cas);
|
|
|
}
|
|
|
+ else {
|
|
|
+ LOGE("____ master query CASCADE_CMD_QUERY_CH failed\n");
|
|
|
+ }
|
|
|
}
|
|
|
break;
|
|
|
|
|
|
@@ -1014,6 +1027,7 @@ static int master_query(cascade_handle_t *cas)
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
+ LOGD("____ master query cmd: %d\n", cmd->cmd);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
@@ -1054,13 +1068,70 @@ static void* scan_thread(void *arg)
|
|
|
|
|
|
while(h->quit==0) {
|
|
|
if(get_mb()->product_modbus_type==0) { //master
|
|
|
- r = cascade_scan(cas);
|
|
|
+ r = master_scan(cas);
|
|
|
}
|
|
|
sleep(1);
|
|
|
}
|
|
|
|
|
|
pthread_exit(NULL);
|
|
|
}
|
|
|
+static void* cmd_thread(void *arg)
|
|
|
+{
|
|
|
+ int i,t=0;
|
|
|
+ char temp[100];
|
|
|
+ cascade_handle_t *cas=&casHandle;
|
|
|
+ board_info_t *info=&cas->info;
|
|
|
+ GlobalDeviceManager *dm=get_dm();
|
|
|
+ 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) {
|
|
|
+ int sendAddr = 0;
|
|
|
+ for(i=0; i<info->cnt; i++) {
|
|
|
+ if(info->channel[i].addr>0) {
|
|
|
+ if(info->channel[i].addr==sendAddr) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ sendAddr = info->channel[i].addr;
|
|
|
+ }
|
|
|
+
|
|
|
+ t = g_switch_set_all_ctrl(&dm->_globalRelaySampManger, info->channel[i].type, info->channel[i].addr, flag);
|
|
|
+ if(t<0) {
|
|
|
+ LOGE("___ %d %s failed\n", info->channel[i].addr, (pcmd->cmd==CASCADE_CMD_OPEN)?"open":"close");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ GlobalPowerManger *tmp=NULL;
|
|
|
+ list_for_each_entry(tmp, &dm->_globalPowerManger.list, list)
|
|
|
+ {
|
|
|
+ if(tmp->product_ch_id==pcmd->chId) {
|
|
|
+ t = g_switch_set_all_chn_ctrl(&dm->_globalRelaySampManger, tmp, tmp->product_saddr, tmp->product_ch_addr, flag, false);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(pcmd->cmd==CASCADE_CMD_OPEN) {
|
|
|
+ sprintf(temp,"$开启$|$所有$|$通道$");
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ sprintf(temp,"$关闭$|$所有$|$通道$");
|
|
|
+ }
|
|
|
+ dev_insert_alarm_ctrl(dm->db, dm->_global_device_info->product_id,3,temp);
|
|
|
+ free(pcmd);
|
|
|
+
|
|
|
+ pthread_exit(NULL);
|
|
|
+}
|
|
|
static int set_modbus(cascade_handle_t *cas, ModbusInfo_t *info)
|
|
|
{
|
|
|
int r;
|
|
|
@@ -1095,7 +1166,6 @@ int cascade_init(void)
|
|
|
pthread_mutex_init(&cas->mutex, NULL);
|
|
|
|
|
|
cas->scanAddr = 1;
|
|
|
- //cas->map = modbus_mapping_new(0,0,MAX_READ_REGS,MAX_WRITE_REGS);
|
|
|
cas->map2 = modbus_mapping_new_start_address(0,0,0,0,
|
|
|
CASCADE_REG_READ, MAX_READ_REGS2,
|
|
|
CASCADE_REG_WRITE, MAX_WRITE_REGS2);
|
|
|
@@ -1103,13 +1173,6 @@ int cascade_init(void)
|
|
|
set_modbus(cas, get_mb());
|
|
|
slave_add(cas, 0);
|
|
|
|
|
|
-#if 0
|
|
|
- lc.log = 0;
|
|
|
- lc.max = 200;
|
|
|
- lc.mode = LIST_FULL_FIFO;
|
|
|
- cas->list = xlist_init(&lc);
|
|
|
-#endif
|
|
|
-
|
|
|
thread_start(THREAD_ID_CASCADE, cascade_thread, cas, 4*MB, 0);
|
|
|
thread_start(THREAD_ID_SCAN, scan_thread, cas, 4*MB, 0);
|
|
|
|
|
|
@@ -1120,7 +1183,7 @@ int cascade_init(void)
|
|
|
int cascade_set_modbus(ModbusInfo_t *info)
|
|
|
{
|
|
|
cascade_handle_t *cas=&casHandle;
|
|
|
- if(!info || info->product_modbus_type>1 || info->product_modbus_addr>CASCADE_MAX) {
|
|
|
+ if(!info || info->product_modbus_addr>CASCADE_MAX) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
@@ -1174,28 +1237,18 @@ int cascade_request(cmd_data_t *cmd)
|
|
|
|
|
|
if(cmd->cmd==CASCADE_CMD_QUERY_CH) {
|
|
|
cmd_data_t cmd2=*cmd;
|
|
|
-
|
|
|
cmd2.cmd = CASCADE_CMD_GET_INFO;
|
|
|
- r = master_request(cas, &cmd2);
|
|
|
+ r = master_cmd(cas, &cmd2);
|
|
|
}
|
|
|
|
|
|
if(r==0) {
|
|
|
- cas->cmd = *cmd;
|
|
|
- r = master_request(cas, cmd);
|
|
|
+ r = master_cmd(cas, cmd);
|
|
|
}
|
|
|
|
|
|
return r;
|
|
|
}
|
|
|
|
|
|
|
|
|
-int cascade_is_offline(int addr)
|
|
|
-{
|
|
|
- slave_t *sl=slave_get(&casHandle, addr);
|
|
|
-
|
|
|
- return (sl->addr>=ERR_MAX)?1:0;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
int cascade_lock(void)
|
|
|
{
|
|
|
cascade_handle_t *cas=&casHandle;
|
guohui