修改级联

pro/src/cascade.c

@@ -7,7 +7,7 @@
 #include "switch_ctrl.h"
 #include "paras.h"
 
-#if 1
+#if 0
 #define LOGD            log_d
 #define LOGE            log_e
 #define LOGW            log_w
@@ -21,26 +21,29 @@
 #define MB_MAX_LEN      250
 
 
+#define MB_MASTER       0
+
+
+
 typedef struct {
     
     int                 inited;
     pthread_mutex_t     mutex;
     
     Modbus_Manger        m;
-    modbus_mapping_t    *map;
-    uint8_t             query[MODBUS_RTU_MAX_ADU_LENGTH];
-
     slave_t             slaves[CASCADE_MAX+1];
 
-    req_t               req;
+    modbus_mapping_t    *map;
+
+    mb_req_t            req;
     int                 scanAddr;
     uint16_t            scanReg;
 }cascade_handle_t;
 
-int cur_dev_addr=0;
+int cur_dev_addr=1;
 static cascade_handle_t casHandle={.inited=0};
 
-
+//////////////////////////////////////////////////
 static inline GlobalDeviceManager* get_dm(void)
 {
     return &__globalDeviceManage;
@@ -51,7 +54,18 @@ static inline GlobalDeviceManager* get_dm2(void)
 }
 static inline ModbusInfo_t *get_mb(void)
 {
-    return &get_dm()->_global_device_info->_gmodbus_info;
+    static ModbusInfo_t mbinfo={
+#if (MB_MASTER==1)
+        .product_modbus_type=0,
+#else
+        .product_modbus_type=1,
+#endif
+        .product_modbus_addr=1,
+        .product_modbus_baud=115200,
+    };
+
+    return &mbinfo;
+    //return &get_dm()->_global_device_info->_gmodbus_info;
 }
 static int slave_init(cascade_handle_t *cas)
 {
@@ -90,16 +104,17 @@ static int slave_find(cascade_handle_t *cas, int addr)
     }
     return 0;
 }
-
-
 static int mb_init(cascade_handle_t *cas, char *path, int type, int addr, uint32_t baud)
 {
     int r;
-    r = g_modbus_init(&cas->m, path, baud, type, addr, "", 0);
-    if(r==0 && type==0 && addr>0) {
+    r = g_modbus_init(&cas->m, path, baud, type, addr, type?"master":"slave", 0);
+    if(r==0 && addr>0) {
         g_modbus_set_slave(&cas->m, addr);
         cas->inited = 1;
     }
+    else {
+        LOGE("___ mb init failed, %s\n", modbus_strerror(errno));
+    }
 
     return 0;
 }
@@ -108,153 +123,192 @@ static int mb_deinit(cascade_handle_t *cas)
     g_modbus_deinit(&cas->m);
     return 0;
 }
-static int mb_read_regs(cascade_handle_t *cas, int addr, uint16_t reg, uint16_t *data, int cnt)
+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);
 }
-static int mb_write_regs(cascade_handle_t *cas, int addr, uint16_t reg, uint16_t *data, int cnt)
+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);
 }
-////////////////////////////////////////////
+static int _mb_recv(cascade_handle_t *cas, uint8_t *buf)
+{
+    return g_modbus_receive(&cas->m, buf);
+}
+static int _mb_reply(cascade_handle_t *cas, uint8_t *buff, int reqlen, modbus_mapping_t *map)
+{
+    return g_modbus_reply(&cas->m, buff, reqlen, map);
+}
+////////////////////////////////////////////////////////////
+static void print_data(uint8_t *data, int len)
+{
+    int i;
+    for(i=0; i<len; i++) {
+        LOGD("0x%02x, ", data[i]);
+    }
+    LOGD("\n");
+}
+static void print_req(char *s, mb_req_t *req)
+{
+    LOGD("__%s__ req.obj: %d\n",    s, req->obj);
+    LOGD("__%s__ req.reg: %d\n",    s, req->reg);
+    LOGD("__%s__ req.chcnt: %d\n",  s, req->chcnt);
+    LOGD("__%s__ req.chId: %d\n",   s, req->chId);
+    LOGD("__%s__ req.time_s: %s\n", s, req->time_s);
+    LOGD("__%s__ req.time_e: %s\n", s, req->time_e);
+    LOGD("__%s__ req.offset: %d\n", s, req->offset);
+    LOGD("__%s__ req.reqlen: %d\n", s, req->reqlen);
+
+    LOGD("\n");
+}
+#define BYTE(t,a)   (t[a])
+#define BYTE2(t,a)  (t[a]<<8 | t[a+1])
+#define BYTE4(t,a)  (BYTE2(t,a+2)<<16 | BYTE2(t,a))
+static void memswap(uint8_t *buf, int len)
+{
+    int i;
+    uint8_t tmp;
+
+    for(i=0; i<len; i+=2) {
+        tmp = buf[i];
+        buf[i] = buf[i+1];
+        buf[i+1] = tmp;
+    }
+}
+static void memcpy_swap(uint8_t *dst, uint8_t *src, int len)
+{
+    int i;
+
+    for(i=0; i<len; i+=2) {
+        dst[i] = src[i+1];
+        dst[i+1] = src[i];
+    }
+}
 static int mb_hdr(uint8_t *data, mb_hdr_t *h)
 {
     h->addr = data[0];
     h->func = data[1];
-    h->reg = (data[2]<<8) | data[3];
-    h->regcnt = (data[4]<<8) | data[5];
-    //h->dlen = data[6];
-    h->pkt = &data[7];
+    h->reg  = BYTE2(data,2);
+    h->regcnt = BYTE2(data,4);
+
+    h->dlen = 0;
+    h->data = NULL;
+    if(h->reg==CASCADE_REG_WRITE) {
+        h->dlen = data[6];
+        h->data = data+7;
+
+        memswap(h->data, h->dlen+h->dlen%2);
+    }
+
+    return 0;
 }
-static int my_read(cascade_handle_t *cas, int addr, mb_pkt_t *pkt)
+static int mb_read(cascade_handle_t *cas, int addr, data_t *d)
 {
-    int r=0,finish=0;
+    int r=0;
     int xlen,rlen=0,oncelen=MB_MAX_LEN;
+    uint8_t buff[MODBUS_RTU_MAX_ADU_LENGTH];
 
+    LOGD("___ mb_read dlen: %d\n", d->dlen);
     while(1) {
-        if(rlen+oncelen>pkt->dlen) {
-            xlen = pkt->dlen-rlen;
+        if(rlen+oncelen>d->dlen) {
+            xlen = d->dlen-rlen;
         }
         else {
             xlen = oncelen;
         }
         xlen += xlen%2;
 
-        r = mb_read_regs(&cas->m, addr, CASCADE_REG_READ, cas->query, xlen/2);
+        r = _mb_read(cas, addr, CASCADE_REG_READ, buff, xlen/2);
         if(r<0) {
+            LOGE("___ _mb_read failed, %s\n", modbus_strerror(errno));
             return -1;
         }
-        if(rlen+r*2>pkt->dlen) {
-            xlen = pkt->dlen-rlen;
-            finish = 1;
+        if(rlen+r*2>=d->dlen) {
+            break;
         }
         else {
             xlen = r*2;
         }
 
-        memcpy((char*)pkt->data+rlen, cas->query, xlen);
+        memcpy((char*)d->data+rlen, buff, xlen);
         rlen += xlen;
-
-        if(finish) {
-            break;
-        }
     }
     
     return 0;
 }
-static int my_write(cascade_handle_t *cas, int addr, mb_pkt_t *pkt)
+static int mb_write(cascade_handle_t *cas, int addr, data_t *d)
 {
-    int r=0,finish=0;
+    int r=0;
     int xlen,wlen=0,oncelen=MB_MAX_LEN;
+    uint8_t buff[MODBUS_RTU_MAX_ADU_LENGTH];
 
+    LOGD("___ mb_write dlen: %d\n", d->dlen);
     while(1) {
-        if(wlen+oncelen>pkt->dlen) {
-            xlen = pkt->dlen-wlen;
+        if(wlen+oncelen>d->dlen) {
+            xlen = d->dlen-wlen;
         }
         else {
             xlen = oncelen;
         }
         xlen += xlen%2;
 
-        memcpy(cas->query, pkt->data+wlen, xlen);
-        r = mb_write_regs(&cas->m, addr, CASCADE_REG_WRITE, cas->query, xlen/2);
+        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));
             return -1;
         }
-        if(wlen+r*2>pkt->dlen) {
-            xlen = pkt->dlen-wlen;
-            finish = 1;
+        if(wlen+r*2>=d->dlen) {
+            break;
         }
         else {
             xlen = r*2;
         }
         wlen += xlen;
-
-        if(finish) {
-            break;
-        }
     }
     
     return 0;
 }
-
-
-static int my_recv(cascade_handle_t *cas, mb_pkt_t *pkt)
-{
-    int r=0;
-
-    //r = mb_receive(h->mb, req);
-    return r ;
-}
-static int my_reply(cascade_handle_t *cas, mb_pkt_t *pkt)
+static int mb_write_read(cascade_handle_t *cas, int addr, data_t *wd, data_t *rd)
 {
     int r=0;
-
-    //r = modbus_reply(h->mb, req, reqlen, map);
-    return r ;
-}
-/////////////////////////////////////////////////////////////
-static int mb_read(cascade_handle_t *cas, int addr, mb_pkt_t *pkt)
-{
-    int r=0;
-
-    //_write(h, );
+    
+    r = mb_write(cas, addr, wd);
+    if(r==0) {
+        r = mb_read(cas, addr, rd);
+    }
 
     return r;
 }
-static int mb_write(cascade_handle_t *cas, int addr, mb_pkt_t *pkt)
+static int mb_receive(cascade_handle_t *cas)
 {
-    int r=0;
+    int r=0,rlen=0;
+    int16_t precmd=-1;
+    mb_hdr_t h;
+    mb_req_t *req;
+    modbus_mapping_t *map=NULL;
+    uint8_t buff[MODBUS_RTU_MAX_ADU_LENGTH];
+    
+    r = _mb_recv(cas, buff);
+    if(r<0) {
+        return -1;
+    }
+    mb_hdr(buff, &h);
 
+    //如果是非自定义寄存器则跳出
+    if(h.data==NULL) {
+        return -1;
+    }
 
+    req = (mb_req_t*)h.data;
+    print_req("slave", req);
+    cas->req = *req;
 
-    return r ;
-}
-static int mb_recv(cascade_handle_t *cas, mb_hdr_t *h)
-{
-    int r=0;
+    r = _mb_reply(cas, buff, r, cas->map);
 
-    
     return r ;
 }
-
-
-static int mb_receive(cascade_handle_t *cas)
-{
-    return g_modbus_receive(&cas->m, cas->query);
-}
-static int mb_reply(cascade_handle_t *cas, int reqlen)
-{
-    return g_modbus_reply(&cas->m, cas->query, reqlen, cas->map);
-}
-static void print_data(uint8_t *data, int len)
-{
-    int i;
-    for(i=0; i<len; i++) {
-        LOGD("0x%02x, ", data[i]);
-    }
-    LOGD("\n");
-}
 /////////////////////////////////////////////////////////////////////////
 static int cascade_scan(cascade_handle_t *cas)
 {
@@ -266,7 +320,7 @@ static int cascade_scan(cascade_handle_t *cas)
     }
 
     if(!slave_find(cas, cas->scanAddr)) {
-         r = mb_read_regs(cas, cas->scanAddr, cas->scanReg, tmp, 1);
+         r = _mb_read(cas, cas->scanAddr, cas->scanReg, tmp, 1);
         if(r>0) {
             LOGD("____ find slave %d\n", cas->scanAddr);
             slave_add(cas, cas->scanAddr);
@@ -387,7 +441,7 @@ static int power_get(cascade_handle_t *cas, int addr, sensor_data_t *ss)
     uint16_t temp[100];
     int r,cnt = sizeof(sensor_ori_t)/2;
     
-    r = mb_read_regs(cas, addr, offset, temp, cnt);
+    r = _mb_read(cas, addr, offset, temp, cnt);
     if(r!=cnt) {
         LOGE("___mbus_read slave %d failed, %s\n", addr, modbus_strerror(errno));
         return -1;
@@ -414,14 +468,14 @@ static int power_get(cascade_handle_t *cas, int addr, sensor_data_t *ss)
     return 0;
 }
 
-#define REGS_OF(x)    (((x)+(x)%2)/2)
+#define REGS(x)    (((x)+(x)%2)/2)
 static int master_request(cascade_handle_t *cas)
 {
     int i,r;
     GlobalPowerManger *tmp=NULL;
     GlobalDeviceManager *dm2=get_dm2();
     GlobalDeviceInfo    *dev=&dm2->_global_device_info;
-    req_t *req=&cas->req;
+    mb_req_t *req=&cas->req;
 
     if(cur_dev_addr==0) {
         return -1;
@@ -431,9 +485,10 @@ static int master_request(cascade_handle_t *cas)
         case CASCADE_REG_OPEN:
         case CASCADE_REG_CLOSE:
         {
-            for(i=0; i<req->cnt; i++) {
-                ch_data_t *ch=&req->ch[i];
-                g_switch_set_all_ctrl(&cas->m, ch->ch_type, ch->addr, (req->reg==CASCADE_REG_OPEN)?1:0);
+            for(i=0; i<MAX_CHN_COUNT; i++) {
+                if(req->ch[i].addr>0) {
+                    g_switch_set_all_ctrl(&cas->m, req->ch[i].ch_type, req->ch[i].addr, (req->reg==CASCADE_REG_OPEN)?1:0);
+                }
             }
         }
         break;
@@ -459,23 +514,44 @@ static int master_query(cascade_handle_t *cas)
     GlobalDeviceInfo    *dev=&dm2->_global_device_info;
     _OverChnPwrAckInfo chInfo;
     _OverAllPwrAckInfo allInfo;
-    req_t *req=&cas->req;
+    mb_req_t *req=&cas->req;
+    data_t rdata,wdata;
 
     if(cur_dev_addr==0) {
         return -1;
     }
 
+    //add for test
+    req->obj = OBJ_OVERALL;
+    req->reg = CASCADE_REG_QUERY_CH;
+    req->chcnt = 33;
+    req->chId  = 44;
+    strcpy(req->time_s, "123456789 ABCDEFGH");
+    strcpy(req->time_e, "2222/22/22 11:11:11");
+    req->offset = 112;
+    req->reqlen = 789;
+
+    print_req("master", req);
     switch(req->reg) {
         case CASCADE_REG_QUERY_CH:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(&cas->m, cur_dev_addr, req->reg, &chInfo, REGS_OF(sizeof(chInfo)));
+                //mb_read(cas, cur_dev_addr, req->reg, &chInfo, REGS_OF(sizeof(chInfo)));
                 //chInfo.product_name = dev->product_name;
                 //chInfo.product_number = dev->product_name;
                 //chInfo.product_id = dev->product_id;
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(&cas->m, cur_dev_addr, req->reg, &allInfo, REGS_OF(sizeof(allInfo)));
+                
+                //mb_read(cas, cur_dev_addr, req->reg, &allInfo, REGS_OF(sizeof(allInfo)));
+                wdata.dlen = sizeof(*req);
+                wdata.data = (uint8_t*)req;
+
+                rdata.dlen = sizeof(allInfo);
+                rdata.data = (uint8_t*)&allInfo;
+
+                //LOGD("____ mb_write_read %d\n", cur_dev_addr);
+                r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
             }
         }
         break;
@@ -483,10 +559,10 @@ static int master_query(cascade_handle_t *cas)
         case CASCADE_REG_QUERY_VOL:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
         }
         break;
@@ -494,10 +570,10 @@ static int master_query(cascade_handle_t *cas)
         case CASCADE_REG_QUERY_CUR:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
         }
         break;
@@ -505,10 +581,10 @@ static int master_query(cascade_handle_t *cas)
         case CASCADE_REG_QUERY_PWR:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
         }
         break;
@@ -516,10 +592,10 @@ static int master_query(cascade_handle_t *cas)
         case CASCADE_REG_QUERY_PWRQ:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
         }
         break;
@@ -527,10 +603,10 @@ static int master_query(cascade_handle_t *cas)
         case CASCADE_REG_QUERY_HIS:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
         }
         break;
@@ -538,10 +614,10 @@ static int master_query(cascade_handle_t *cas)
         case CASCADE_REG_QUERY_TOTAL:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
         }
         break;
@@ -549,10 +625,10 @@ static int master_query(cascade_handle_t *cas)
         case CASCADE_REG_QUERY_TOTAL_PWR:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(&cas->m, );
+                //mb_read(cas, );
             }
         }
         break;
@@ -561,25 +637,13 @@ static int master_query(cascade_handle_t *cas)
         return -1;
     }
 
-
     return 0;
 }
 
 
 static int slave_receive(cascade_handle_t *cas)
 {
-    int i,r=0,rc;
-    uint8_t *query=cas->query;
-    modbus_mapping_t *map=cas->map;
-    ModbusInfo_t *info=get_mb();
-
-    //rc = mb_receive(cas, &h);
-    if (rc>0) {
-        //mb_reply();
-        
-    }
-
-    return r;
+    return mb_receive(cas);
 }
 
 static void* cascade_thread(void *arg)
@@ -592,14 +656,13 @@ static void* cascade_thread(void *arg)
     LOGD("__ cascade %s\n", info->product_modbus_type?"slave":"master");
     while(h->quit==0) {
         if(info->product_modbus_type==0) {      //主模
-            r = master_request(cas);
-            sleep(1);
+            r = master_query(cas);
+            sleep(5);
         }
         else {                                  //从模式，等待主设备发起数据请�?
-            //r = slave_rceive(cas);
+            r = slave_receive(cas);
         }  
     }
-    modbus_mapping_free(cas->map);
     
     pthread_exit(NULL);
 }
@@ -649,18 +712,13 @@ int cascade_init(void)
     
     cas->scanAddr = 1;
     cas->scanReg  = CASCADE_REG_SCAN;
-    cas->map = modbus_mapping_new(
-        MODBUS_MAX_READ_BITS,
-        MODBUS_MAX_WRITE_BITS,
-        MAX_READ_REGS, 
-        MAX_WRITE_REGS
-    );
-    set_modbus(cas, get_mb());
+    cas->map = modbus_mapping_new(0,0,MAX_READ_REGS,MAX_WRITE_REGS);
 
+    set_modbus(cas, get_mb());
     slave_add(cas, 0);
 
     sys_start_thread(THREAD_ID_CASCADE, cascade_thread, cas);
-    sys_start_thread(THREAD_ID_SCAN, scan_thread, cas);
+    //sys_start_thread(THREAD_ID_SCAN, scan_thread, cas);
         
     return 0;
 }
@@ -712,7 +770,7 @@ int cascade_free_dlist(dev_list_t *dl)
     return 0;
 }
  
-int cascade_request(req_t *req)
+int cascade_request(mb_req_t *req)
 {
     int r=-1;
     cascade_handle_t *cas=&casHandle;

pro/src/cascade.h

@@ -7,10 +7,10 @@
 
 #define ERR_MAX                         5
 
-#define MAX_READ_REGS                   100
-#define MAX_WRITE_REGS                  100
+#define MAX_READ_REGS                   20000
+#define MAX_WRITE_REGS                  10000
 
-#define CASCADE_REG_OFFSET              0
+#define CASCADE_REG_OFFSET              0x10
 
 #define CASCADE_REG_SCAN                (CASCADE_REG_OFFSET+0x00)
 #define CASCADE_REG_READ                (CASCADE_REG_OFFSET+0x01)
@@ -31,7 +31,7 @@
 #define CASCADE_REG_QUERY_TOTAL         (CASCADE_REG_OFFSET+0x16)
 #define CASCADE_REG_QUERY_TOTAL_PWR     (CASCADE_REG_OFFSET+0x17)
 
-
+#pragma pack (1)
 
 typedef struct {
     int       addr;
@@ -43,7 +43,6 @@ typedef struct {
     int       cnt;
 }dev_list_t;
 
-#pragma pack (1)
 typedef struct {
     uint16_t deveice_type;          //设备类型
     uint16_t slave_addr;            //设备地址
@@ -62,7 +61,6 @@ typedef struct {
     //uint32_t Warinfo;
     //uint16_t sersor_type;
 }sensor_ori_t;
-#pragma pack ()
 
 typedef struct {
     int   type;                  //设备类型
@@ -77,6 +75,13 @@ typedef struct {
     int   sensor_status;         //传感器状态
 }sensor_data_t;
 
+
+enum {
+    TYPE_REQ=0,
+    TYPE_FILE,
+};
+
+
 enum {
     OBJ_OVERALL=0,
     OBJ_CHANNEL,
@@ -88,30 +93,29 @@ typedef struct {
     uint8_t         ch_type;
     uint8_t         addr;
 }ch_data_t;
-
 typedef struct {
-    uint8_t         cnt;
+    uint16_t        obj;
+    uint16_t        reg;
+
+    uint16_t        chcnt;
     ch_data_t       ch[MAX_CHN_COUNT];
-}query_data_t;
+    uint16_t        chId;
 
-typedef struct {
-    int             obj;
-    int             reg;
-    ch_data_t       *ch;
-    int             cnt;
-    int             chId;
     char            time_s[24];   //start time
     char            time_e[24];   //end time
-}req_t;
+
+    uint32_t        offset;
+    uint32_t        reqlen;
+}mb_req_t;
 
 typedef struct {
     int             dlen;
-    char            *data;           
+    uint8_t         *data;           
 }data_t;
 typedef struct {
-    uint32_t        tp;
-    uint32_t        pid;
-    uint32_t        dlen;
+    int16_t         cmd;
+    int16_t         pid;
+    uint16_t        dlen;
     char            *data;
 }mb_pkt_t;
 
@@ -120,14 +124,17 @@ typedef struct {
     uint8_t         func;
     uint16_t        reg;
     uint16_t        regcnt;
-    mb_pkt_t        *pkt;
+    uint8_t         dlen;
+    uint8_t         *data;
 }mb_hdr_t;
 
+#pragma pack ()
+
 extern int cur_dev_addr;
 
 int cascade_init(void);
 int cascade_reinit(void);
-int cascade_request(req_t *req);
+int cascade_request(mb_req_t *req);
 
 int cascade_get_dlist(dev_list_t *dl);
 int cascade_free_dlist(dev_list_t *dl);

pro/src/common.h

@@ -52,11 +52,11 @@
 #define INTERL_SENSOR_MODBUS_BAUD 9600
 
 //表头级联接口
-#define CASCADE_MODBUS_PORT     "/dev/ttyAS5"
+#define CASCADE_MODBUS_PORT     "/dev/ttyAS4"
 #define CASCADE_MODBUS_BAUD     115200
 
 //485级联选择串口
-#define INTERL_485_CASCADE_PORT "/dev/ttyS5"
+#define INTERL_485_CASCADE_PORT "/dev/ttyAS4"
 #define INTERL_485_CASCADE_BAUD 115200
 
 #define AC_SINGLE_S_CUR_CHN_NUM 8