梳理数据

pro/src/cascade.c

@@ -35,7 +35,7 @@ typedef struct {
 
     modbus_mapping_t    *map;
 
-    mb_req_t            req;
+    cmd_data_t          cmd;
     int                 scanAddr;
     uint16_t            scanReg;
 }cascade_handle_t;
@@ -104,6 +104,28 @@ static int slave_find(cascade_handle_t *cas, int addr)
     }
     return 0;
 }
+
+static int get_info(int addr, board_info_t *info)
+{
+    int i,r;
+    uint8_t type,maxChn;
+    GlobalDeviceManager *dm=get_dm();
+
+    memset(info, 0, sizeof(board_info_t));
+    for(i=1; i<MAX_CHN_COUNT; i++) {
+        r = g_switch_get_type(&dm->_globalRelaySampManger, addr, &type, &maxChn,
+                               dm->_global_device_info->product_pwr_type);
+        if(r==0) {
+            info->board[info->cnt].addr   = i;
+            info->board[info->cnt].type   = type;
+            info->board[info->cnt].maxChn = maxChn;
+            info->cnt++;
+        }
+    }
+
+    return 0;
+}
+
 static int mb_init(cascade_handle_t *cas, char *path, int type, int addr, uint32_t baud)
 {
     int r;
@@ -148,19 +170,20 @@ static void print_data(uint8_t *data, int len)
     }
     LOGD("\n");
 }
-static void print_req(char *s, mb_req_t *req)
+static void print_cmd(char *s, cmd_data_t *cmd)
 {
     int i;
 
-    LOGD("__%s__ req.obj: %d\n",    s, req->obj);
-    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__ cmd.obj: %d\n",    s, cmd->obj);
+    LOGD("__%s__ cmd.cmd: %d\n",    s, cmd->cmd);
+    for(i=0; i<cmd->info.cnt; i++) {
+        LOGD("__%s__ cmd.info.board[%d].addr: %d\n",   s, i, cmd->info.board[i].addr);
+        LOGD("__%s__ cmd.info.board[%d].type: %d\n",   s, i, cmd->info.board[i].type);
+        LOGD("__%s__ cmd.info.board[%d].maxChn: %d\n", s, i, cmd->info.board[i].maxChn);
     }
-    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__ cmd.chId: %d\n",   s, cmd->chId);
+    LOGD("__%s__ cmd.time_s: %s\n", s, cmd->time_s);
+    LOGD("__%s__ cmd.time_e: %s\n", s, cmd->time_e);
 
     LOGD("\n");
 }
@@ -243,7 +266,6 @@ static int mb_write(cascade_handle_t *cas, int addr, data_t *d)
     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>d->dlen) {
             xlen = d->dlen-wlen;
@@ -256,7 +278,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, 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;
         }
@@ -286,7 +308,7 @@ static int mb_receive(cascade_handle_t *cas)
 {
     int r=0,rlen=0;
     mb_hdr_t h;
-    
+    board_info_t        info;
     _OverChnPwrAckInfo chInfo;
     _OverAllPwrAckInfo allInfo;
     modbus_mapping_t *map=NULL;
@@ -304,17 +326,17 @@ static int mb_receive(cascade_handle_t *cas)
     //如果是非自定义寄存器则跳出
     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);
+            cmd_data_t *cmd = (cmd_data_t*)h.data;
+            cas->cmd = *cmd;
+            print_cmd("slave", cmd);
 
-            precmd  = req->cmd;
+            precmd  = cmd->cmd;
             sendlen = 0;
         }
 
         if(h.reg==CASCADE_REG_WRITE) {
         
-            switch(cas->req.cmd) {
+            switch(cas->cmd.cmd) {
                 case CASCADE_CMD_OPEN:
                 {
 
@@ -338,19 +360,26 @@ static int mb_receive(cascade_handle_t *cas)
 
                 }
                 break;
+
+                case CASCADE_CMD_INFO:
+                {
+                    get_info(cur_dev_addr, &info);
+                    memcpy(cas->map->tab_registers+h.reg, ((char*)&info)+sendlen, h.regcnt*2);
+                }
+                break;
             }
 
             r = _mb_reply(cas, buff, r, cas->map);
         }
         else if(h.reg==CASCADE_REG_READ) {
 
-            switch(cas->req.cmd) {
+            switch(cas->cmd.cmd) {
                 case CASCADE_CMD_QUERY_CH:
                 {
-                    if(cas->req.obj==OBJ_CHANNEL) {
+                    if(cas->cmd.obj==OBJ_CHANNEL) {
                         //
                     }
-                    else if(cas->req.obj==OBJ_OVERALL){
+                    else if(cas->cmd.obj==OBJ_OVERALL){
                         allInfo._total_voltage.ydata[0] = 1.1f;
                         allInfo._total_voltage.ydata[1] = 1.2f;
                         allInfo._total_voltage.ydata[2] = 1.3f;
@@ -427,8 +456,6 @@ static int mb_receive(cascade_handle_t *cas)
         //g_switch_set_all_ctrl(mm,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,1);
     }
 
-        
-
     return r ;
 }
 /////////////////////////////////////////////////////////////////////////
@@ -591,25 +618,33 @@ static int power_get(cascade_handle_t *cas, int addr, sensor_data_t *ss)
 }
 
 #define REGS(x)    (((x)+(x)%2)/2)
+static int power_query()
+{
+    
+}
 static int master_request(cascade_handle_t *cas)
 {
     int i,r;
     GlobalPowerManger *tmp=NULL;
+    GlobalDeviceManager *dm=get_dm();
     GlobalDeviceManager *dm2=get_dm2();
     GlobalDeviceInfo    *dev=&dm2->_global_device_info;
-    mb_req_t *req=&cas->req;
+    cmd_data_t *cmd=&cas->cmd;
+    data_t rdata,wdata;
+    
 
     if(cur_dev_addr==0) {
         return -1;
     }
 
-    switch(req->cmd) {
+
+    switch(cmd->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->cmd==CASCADE_CMD_OPEN)?1:0);
+            for(i=0; i<cmd->info.cnt; i++) {
+                if(cmd->info.board[i].addr>0) {
+                    g_switch_set_all_ctrl(&cas->m, cmd->info.board[i].type, cmd->info.board[i].addr, (cmd->cmd==CASCADE_CMD_OPEN)?1:0);
                 }
             }
         }
@@ -618,7 +653,16 @@ static int master_request(cascade_handle_t *cas)
         case CASCADE_CMD_SAVE:
         case CASCADE_CMD_SAVE3:
         {
-            //mb_write(&cas->m, cur_dev_addr, req->reg, NULL, 0);
+            //mb_write(&cas->m, cur_dev_addr, cmd->reg, NULL, 0);
+        }
+        break;
+
+        case CASCADE_CMD_INFO:
+        {
+            wdata.dlen = sizeof(*cmd);
+            wdata.data = (uint8_t*)cmd;
+
+            r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
         }
         break;
 
@@ -636,39 +680,42 @@ static int master_query(cascade_handle_t *cas)
     GlobalDeviceInfo    *dev=&dm2->_global_device_info;
     _OverChnPwrAckInfo chInfo;
     _OverAllPwrAckInfo allInfo;
-    mb_req_t *req=&cas->req;
+    cmd_data_t *cmd=&cas->cmd;
     data_t rdata,wdata;
 
     if(cur_dev_addr==0) {
         return -1;
     }
 
+#if 0
     //add for test
-    req->obj = OBJ_OVERALL;
-    req->cmd = CASCADE_CMD_QUERY_CH;
+    cmd->obj = OBJ_OVERALL;
+    cmd->cmd = CASCADE_CMD_QUERY_CH;
 
-for(i=0; i<CH_MAX; i++) {
-    req->ch[i].addr = i+1;
-    req->ch[i].ch_type = 8;
-}
+    for(i=0; i<CH_MAX; i++) {
+        cmd->ch[i].addr = i+1;
+        cmd->ch[i].ch_type = 8;
+    }
 
-    req->chId  = 44;
-    strcpy(req->time_s, "123456789 ABCDEFGH");
-    strcpy(req->time_e, "2222/22/22 11:11:11");
+    cmd->chId  = 44;
+    strcpy(cmd->time_s, "123456789 ABCDEFGH");
+    strcpy(cmd->time_e, "2222/22/22 11:11:11");
 
-    print_req("master", req);
+    print_cmd("master", cmd);
+#endif
+
+    wdata.dlen = sizeof(*cmd);
+    wdata.data = (uint8_t*)cmd;
 
-    wdata.dlen = sizeof(*req);
-    wdata.data = (uint8_t*)req;
+    switch(cmd->cmd) {
 
-    switch(req->cmd) {
         case CASCADE_CMD_QUERY_CH:
         {
-            if(req->obj==OBJ_CHANNEL) {
+            if(cmd->obj==OBJ_CHANNEL) {
                 rdata.dlen = sizeof(chInfo);
                 rdata.data = (uint8_t*)&chInfo;
             }
-            else if(req->obj==OBJ_OVERALL) {
+            else if(cmd->obj==OBJ_OVERALL) {
                 rdata.dlen = sizeof(allInfo);
                 rdata.data = (uint8_t*)&allInfo;
             }
@@ -680,11 +727,11 @@ for(i=0; i<CH_MAX; i++) {
 
         case CASCADE_CMD_QUERY_VOL:
         {
-            if(req->obj==OBJ_CHANNEL) {
+            if(cmd->obj==OBJ_CHANNEL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
-            else if(req->obj==OBJ_OVERALL) {
+            else if(cmd->obj==OBJ_OVERALL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
@@ -696,11 +743,11 @@ for(i=0; i<CH_MAX; i++) {
 
         case CASCADE_CMD_QUERY_CUR:
         {
-            if(req->obj==OBJ_CHANNEL) {
+            if(cmd->obj==OBJ_CHANNEL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
-            else if(req->obj==OBJ_OVERALL) {
+            else if(cmd->obj==OBJ_OVERALL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
@@ -712,11 +759,11 @@ for(i=0; i<CH_MAX; i++) {
 
         case CASCADE_CMD_QUERY_PWR:
         {
-            if(req->obj==OBJ_CHANNEL) {
+            if(cmd->obj==OBJ_CHANNEL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
-            else if(req->obj==OBJ_OVERALL) {
+            else if(cmd->obj==OBJ_OVERALL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
@@ -728,11 +775,11 @@ for(i=0; i<CH_MAX; i++) {
 
         case CASCADE_CMD_QUERY_PWRQ:
         {
-            if(req->obj==OBJ_CHANNEL) {
+            if(cmd->obj==OBJ_CHANNEL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
-            else if(req->obj==OBJ_OVERALL) {
+            else if(cmd->obj==OBJ_OVERALL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
@@ -744,11 +791,11 @@ for(i=0; i<CH_MAX; i++) {
 
         case CASCADE_CMD_QUERY_HIS:
         {
-            if(req->obj==OBJ_CHANNEL) {
+            if(cmd->obj==OBJ_CHANNEL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
-            else if(req->obj==OBJ_OVERALL) {
+            else if(cmd->obj==OBJ_OVERALL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
@@ -760,11 +807,11 @@ for(i=0; i<CH_MAX; i++) {
 
         case CASCADE_CMD_QUERY_TOTAL:
         {
-            if(req->obj==OBJ_CHANNEL) {
+            if(cmd->obj==OBJ_CHANNEL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
-            else if(req->obj==OBJ_OVERALL) {
+            else if(cmd->obj==OBJ_OVERALL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
@@ -776,11 +823,11 @@ for(i=0; i<CH_MAX; i++) {
 
         case CASCADE_CMD_QUERY_TOTAL_PWR:
         {
-            if(req->obj==OBJ_CHANNEL) {
+            if(cmd->obj==OBJ_CHANNEL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
-            else if(req->obj==OBJ_OVERALL) {
+            else if(cmd->obj==OBJ_OVERALL) {
                 //rdata.dlen = sizeof(chInfo);
                 //rdata.data = (uint8_t*)&chInfo;
             }
@@ -929,11 +976,15 @@ int cascade_free_dlist(dev_list_t *dl)
     return 0;
 }
  
-int cascade_request(mb_req_t *req)
+int cascade_request(cmd_data_t *cmd)
 {
     cascade_handle_t *cas=&casHandle;
-    cas->req = *req;
 
+    if(!cmd) {
+        return -1;
+    }
+
+    cas->cmd = *cmd;
     return master_request(cas);
 }
 

pro/src/cascade.h

@@ -21,6 +21,7 @@ enum {
     CASCADE_CMD_CLOSE,
     CASCADE_CMD_SAVE,
     CASCADE_CMD_SAVE3,
+    CASCADE_CMD_INFO,
 
     CASCADE_CMD_QUERY_CH,
     CASCADE_CMD_QUERY_VOL,
@@ -78,11 +79,10 @@ typedef struct {
 
 
 enum {
-    TYPE_REQ=0,
+    TYPE_CMD=0,
     TYPE_FILE,
 };
 
-
 enum {
     OBJ_OVERALL=0,
     OBJ_CHANNEL,
@@ -91,31 +91,39 @@ enum {
 };
 
 typedef struct {
-    uint8_t         ch_type;
-    uint8_t         addr;
-}ch_data_t;
+    int             dlen;
+    uint8_t         *data;           
+}data_t;
 
-#define CH_MAX   5//MAX_CHN_COUNT
 typedef struct {
-    uint16_t        obj;
-    uint16_t        cmd;
+    struct {
+        uint8_t     addr;
+        uint8_t     type;
+        uint8_t     maxChn;
+    }board[MAX_CHN_COUNT];
+    uint8_t         cnt;
+}board_info_t;
 
-    ch_data_t       ch[CH_MAX];
-    uint16_t        chId;
+typedef struct {
+    uint8_t         cmd;
+    uint8_t         obj;
+    uint8_t         chId;
 
+    board_info_t    info;
     char            time_s[24];   //start time
     char            time_e[24];   //end time
-}mb_req_t;
+}cmd_data_t;
 
 typedef struct {
-    int             dlen;
-    uint8_t         *data;           
-}data_t;
-typedef struct {
-    int16_t         cmd;
-    int16_t         pid;
+    uint8_t         tp;
+    uint16_t        pid;
     uint16_t        dlen;
-    char            *data;
+    uint8_t         *data;
+}file_data_t;
+
+typedef struct {
+    int8_t          type;
+    uint8_t         data[0];
 }mb_pkt_t;
 
 typedef struct {
@@ -133,7 +141,7 @@ extern int cur_dev_addr;
 
 int cascade_init(void);
 int cascade_reinit(void);
-int cascade_request(mb_req_t *req);
+int cascade_request(cmd_data_t *cmd);
 
 int cascade_get_dlist(dev_list_t *dl);
 int cascade_free_dlist(dev_list_t *dl);