modbus传大数据ok

pro/src/cascade.c

@@ -21,7 +21,7 @@
 #define MB_MAX_LEN      250
 
 
-#define MB_MASTER       0
+#define MB_MASTER       1
 
 
 
@@ -150,20 +150,21 @@ static void print_data(uint8_t *data, int len)
 }
 static void print_req(char *s, mb_req_t *req)
 {
+    int i;
+
     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.cmd: %d\n",    s, req->cmd);
+    for(i=0; i<CH_MAX; i++) {
+        LOGD("__%s__ req.ch[%d].addr: %d\n",      s, i, req->ch[i].addr);
+        LOGD("__%s__ req.ch[%d].ch_type: %d\n",   s, i, req->ch[i].ch_type);
+    }
     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;
@@ -184,16 +185,16 @@ static void memcpy_swap(uint8_t *dst, uint8_t *src, int len)
         dst[i+1] = src[i];
     }
 }
-static int mb_hdr(uint8_t *data, mb_hdr_t *h)
+static int mb_hdr(uint8_t *data, int datalen, mb_hdr_t *h)
 {
     h->addr = data[0];
     h->func = data[1];
-    h->reg  = BYTE2(data,2);
-    h->regcnt = BYTE2(data,4);
+    h->reg  = data[2]<<8 | data[3];
+    h->regcnt = data[4]<<8 | data[5];
 
     h->dlen = 0;
     h->data = NULL;
-    if(h->reg==CASCADE_REG_WRITE) {
+    if(datalen>8) {
         h->dlen = data[6];
         h->data = data+7;
 
@@ -220,7 +221,7 @@ static int mb_read(cascade_handle_t *cas, int addr, data_t *d)
 
         r = _mb_read(cas, addr, CASCADE_REG_READ, buff, xlen/2);
         if(r<0) {
-            LOGE("___ _mb_read failed, %s\n", modbus_strerror(errno));
+            LOGE("___ _mb_read failed, %s, rlen: %d\n", modbus_strerror(errno), rlen);
             return -1;
         }
         if(rlen+r*2>=d->dlen) {
@@ -284,28 +285,149 @@ 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;
-    int16_t precmd=-1;
     mb_hdr_t h;
-    mb_req_t *req;
+    
+    _OverChnPwrAckInfo chInfo;
+    _OverAllPwrAckInfo allInfo;
     modbus_mapping_t *map=NULL;
     uint8_t buff[MODBUS_RTU_MAX_ADU_LENGTH];
+    static int precmd=-1;
+    static int sendlen=0;
     
     r = _mb_recv(cas, buff);
     if(r<0) {
         return -1;
     }
-    mb_hdr(buff, &h);
+    mb_hdr(buff, r, &h);
 
+    LOGD("_________ reg: %d\n",  h.reg);
     //如果是非自定义寄存器则跳出
-    if(h.data==NULL) {
-        return -1;
-    }
+    if(h.reg>=CASCADE_REG_SCAN && h.reg<=CASCADE_REG_WRITE) {
+        if(h.data) {
+            mb_req_t *req = (mb_req_t*)h.data;
+            cas->req = *req;
+            print_req("slave", req);
+
+            precmd  = req->cmd;
+            sendlen = 0;
+        }
 
-    req = (mb_req_t*)h.data;
-    print_req("slave", req);
-    cas->req = *req;
+        if(h.reg==CASCADE_REG_WRITE) {
+        
+            switch(cas->req.cmd) {
+                case CASCADE_CMD_OPEN:
+                {
+
+                }
+                break;
+
+                case CASCADE_CMD_CLOSE:
+                {
+
+                }
+                break;
+
+                case CASCADE_CMD_SAVE:
+                {
+
+                }
+                break;
+
+                case CASCADE_CMD_SAVE3:
+                {
+
+                }
+                break;
+            }
+
+            r = _mb_reply(cas, buff, r, cas->map);
+        }
+        else if(h.reg==CASCADE_REG_READ) {
+
+            switch(cas->req.cmd) {
+                case CASCADE_CMD_QUERY_CH:
+                {
+                    if(cas->req.obj==OBJ_CHANNEL) {
+                        //
+                    }
+                    else if(cas->req.obj==OBJ_OVERALL){
+                        allInfo._total_voltage.ydata[0] = 1.1f;
+                        allInfo._total_voltage.ydata[1] = 1.2f;
+                        allInfo._total_voltage.ydata[2] = 1.3f;
+                        allInfo._total_voltage.ydata[3] = 1.4f;
+
+                        allInfo._total_consumption.ydata[0] = 2.1f;
+                        allInfo._total_consumption.ydata[1] = 2.2f;
+                        allInfo._total_consumption.ydata[2] = 2.3f;
+                        allInfo._total_consumption.ydata[3] = 2.4f;
+
+                        memcpy(cas->map->tab_registers+h.reg, ((char*)&allInfo)+sendlen, h.regcnt*2);
+                    }
+                    else {
+                        return -1;
+                    }
+                }
+                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;
 
-    r = _mb_reply(cas, buff, r, cas->map);
+                case CASCADE_CMD_QUERY_TOTAL_PWR:
+                {
+
+                }
+                break;
+            }
+
+            r = _mb_reply(cas, buff, r, cas->map);
+            if(r>0) {
+                sendlen += h.regcnt*2;
+                LOGD("____  slave sendlen: %d, h.dlen: %d, r: %d\n", sendlen, h.dlen, r);
+            }
+        }
+        else {
+            r = _mb_reply(cas, buff, r, cas->map);
+        }
+    }
+    else {
+        Modbus_Manger *mm=&get_dm()->_globalRelaySampManger;
+        //g_switch_set_all_ctrl(mm,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,1);
+    }
+
+        
 
     return r ;
 }
@@ -481,20 +603,20 @@ static int master_request(cascade_handle_t *cas)
         return -1;
     }
 
-    switch(req->reg) {
-        case CASCADE_REG_OPEN:
-        case CASCADE_REG_CLOSE:
+    switch(req->cmd) {
+        case CASCADE_CMD_OPEN:
+        case CASCADE_CMD_CLOSE:
         {
             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);
+                    g_switch_set_all_ctrl(&cas->m, req->ch[i].ch_type, req->ch[i].addr, (req->cmd==CASCADE_CMD_OPEN)?1:0);
                 }
             }
         }
         break;
 
-        case CASCADE_REG_SAVE:
-        case CASCADE_REG_SAVE3:
+        case CASCADE_CMD_SAVE:
+        case CASCADE_CMD_SAVE3:
         {
             //mb_write(&cas->m, cur_dev_addr, req->reg, NULL, 0);
         }
@@ -523,112 +645,147 @@ static int master_query(cascade_handle_t *cas)
 
     //add for test
     req->obj = OBJ_OVERALL;
-    req->reg = CASCADE_REG_QUERY_CH;
-    req->chcnt = 33;
+    req->cmd = CASCADE_CMD_QUERY_CH;
+
+for(i=0; i<CH_MAX; i++) {
+    req->ch[i].addr = i+1;
+    req->ch[i].ch_type = 8;
+}
+
     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:
+
+    wdata.dlen = sizeof(*req);
+    wdata.data = (uint8_t*)req;
+
+    switch(req->cmd) {
+        case CASCADE_CMD_QUERY_CH:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //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;
+                rdata.dlen = sizeof(chInfo);
+                rdata.data = (uint8_t*)&chInfo;
             }
             else if(req->obj==OBJ_OVERALL) {
-                
-                //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);
+            }
+            else {
+                return -1;
             }
         }
         break;
 
-        case CASCADE_REG_QUERY_VOL:
+        case CASCADE_CMD_QUERY_VOL:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
+            }
+            else {
+                return -1;
             }
         }
         break;
 
-        case CASCADE_REG_QUERY_CUR:
+        case CASCADE_CMD_QUERY_CUR:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
+            }
+            else {
+                return -1;
             }
         }
         break;
 
-        case CASCADE_REG_QUERY_PWR:
+        case CASCADE_CMD_QUERY_PWR:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
+            }
+            else {
+                return -1;
             }
         }
         break;
 
-        case CASCADE_REG_QUERY_PWRQ:
+        case CASCADE_CMD_QUERY_PWRQ:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
+            }
+            else {
+                return -1;
             }
         }
         break;
 
-        case CASCADE_REG_QUERY_HIS:
+        case CASCADE_CMD_QUERY_HIS:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
+            }
+            else {
+                return -1;
             }
         }
         break;
 
-        case CASCADE_REG_QUERY_TOTAL:
+        case CASCADE_CMD_QUERY_TOTAL:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
+            }
+            else {
+                return -1;
             }
         }
         break;
 
-        case CASCADE_REG_QUERY_TOTAL_PWR:
+        case CASCADE_CMD_QUERY_TOTAL_PWR:
         {
             if(req->obj==OBJ_CHANNEL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
             }
             else if(req->obj==OBJ_OVERALL) {
-                //mb_read(cas, );
+                //rdata.dlen = sizeof(chInfo);
+                //rdata.data = (uint8_t*)&chInfo;
+            }
+            else {
+                return -1;
             }
         }
         break;
@@ -637,7 +794,9 @@ static int master_query(cascade_handle_t *cas)
         return -1;
     }
 
-    return 0;
+    r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
+
+    return r;
 }
 
 
@@ -772,18 +931,10 @@ int cascade_free_dlist(dev_list_t *dl)
  
 int cascade_request(mb_req_t *req)
 {
-    int r=-1;
     cascade_handle_t *cas=&casHandle;
     cas->req = *req;
 
-    if(req->reg) {
-        r = master_request(cas);
-    }
-    else {
-
-    }
-
-    return r;
+    return master_request(cas);
 }
 
 

pro/src/cascade.h

@@ -16,20 +16,21 @@
 #define CASCADE_REG_READ                (CASCADE_REG_OFFSET+0x01)
 #define CASCADE_REG_WRITE               (CASCADE_REG_OFFSET+0x02)
 
-
-#define CASCADE_REG_OPEN                (CASCADE_REG_OFFSET+0x05)
-#define CASCADE_REG_CLOSE               (CASCADE_REG_OFFSET+0x06)
-#define CASCADE_REG_SAVE                (CASCADE_REG_OFFSET+0x07)
-#define CASCADE_REG_SAVE3               (CASCADE_REG_OFFSET+0x08)
-
-#define CASCADE_REG_QUERY_CH            (CASCADE_REG_OFFSET+0x10)
-#define CASCADE_REG_QUERY_VOL           (CASCADE_REG_OFFSET+0x11)
-#define CASCADE_REG_QUERY_CUR           (CASCADE_REG_OFFSET+0x12)
-#define CASCADE_REG_QUERY_PWR           (CASCADE_REG_OFFSET+0x13)
-#define CASCADE_REG_QUERY_PWRQ          (CASCADE_REG_OFFSET+0x14)
-#define CASCADE_REG_QUERY_HIS           (CASCADE_REG_OFFSET+0x15)
-#define CASCADE_REG_QUERY_TOTAL         (CASCADE_REG_OFFSET+0x16)
-#define CASCADE_REG_QUERY_TOTAL_PWR     (CASCADE_REG_OFFSET+0x17)
+enum {
+    CASCADE_CMD_OPEN=0,
+    CASCADE_CMD_CLOSE,
+    CASCADE_CMD_SAVE,
+    CASCADE_CMD_SAVE3,
+
+    CASCADE_CMD_QUERY_CH,
+    CASCADE_CMD_QUERY_VOL,
+    CASCADE_CMD_QUERY_CUR,
+    CASCADE_CMD_QUERY_PWR,
+    CASCADE_CMD_QUERY_PWRQ,
+    CASCADE_CMD_QUERY_HIS,
+    CASCADE_CMD_QUERY_TOTAL,
+    CASCADE_CMD_QUERY_TOTAL_PWR,
+};
 
 #pragma pack (1)
 
@@ -93,19 +94,17 @@ typedef struct {
     uint8_t         ch_type;
     uint8_t         addr;
 }ch_data_t;
+
+#define CH_MAX   5//MAX_CHN_COUNT
 typedef struct {
     uint16_t        obj;
-    uint16_t        reg;
+    uint16_t        cmd;
 
-    uint16_t        chcnt;
-    ch_data_t       ch[MAX_CHN_COUNT];
+    ch_data_t       ch[CH_MAX];
     uint16_t        chId;
 
     char            time_s[24];   //start time
     char            time_e[24];   //end time
-
-    uint32_t        offset;
-    uint32_t        reqlen;
 }mb_req_t;
 
 typedef struct {

pro/src/common.h

@@ -25,8 +25,8 @@
 #include <sys/shm.h>
 //#define RS485_TYPE
 
-#define MAX_CHN_COUNT 16
-#define MAX_RELAY_CHN 100
+#define MAX_CHN_COUNT       1//16
+#define MAX_RELAY_CHN       100
 
 //是否在OS环境下运行
 #define OS_HANDWARE 1