解决测试bug

pro/src/appweb_handle.c

@@ -968,14 +968,12 @@ static void channelStatusMonitoring(void* conn)
         cur_dev_addr = _over_chn_pwr_request.product_id;
         if(cur_dev_addr>0) {
             cmd.cmd = CASCADE_CMD_QUERY_CH;
-            cmd.obj = OBJ_OVERALL;
+            cmd.obj = OBJ_CHANNEL;
             cmd.chId = _over_chn_pwr_request.productChId;
             cascade_request(&cmd);
 
             ack_str = ctrl_sts_ack_to_json();
-            http_reply(conn, 200, ack_str);
-            cJSON_free(ack_str);
-            return;
+            goto quit;
         }
 
         if(_over_chn_pwr_request.productChId==NULL)

pro/src/cascade.c

@@ -21,7 +21,7 @@
 #define MB_MAX_LEN      250
 
 
-#define MB_MASTER       1
+#define MB_MASTER       0
 
 
 
@@ -150,7 +150,49 @@ static int slave_get_all_data(cascade_handle_t *cas)
     return 0;
 }
 
+static int get_pwr_info(board_info_t *info, int chId, GlobalPowerManger *power)
+{
+    int i;
+    GlobalPowerManger *tmp=NULL;
+    GlobalDeviceManager *dm=get_dm();
+
+    list_for_each_entry(tmp, &dm->_globalPowerManger.list, list)
+    {
+        if(tmp->product_ch_id==chId) {
+            power->product_id = dm->_global_device_info->product_id;
+            power->product_ch_id = tmp->product_ch_id;
+            strcpy(power->product_ch_name, tmp->product_ch_name);
+            power->product_ch_type = tmp->product_ch_type;
+            power->product_ch_status = tmp->product_ch_status;
+            power->product_ch_start_delay = tmp->product_ch_start_delay;
+            power->product_ch_stop_delay = tmp->product_ch_stop_delay;
+
+            return 0;
+        }
+    }
+
+    return -1;
+}
+static int slave_save(cascade_handle_t *cas)
+{
+    int r;
+    GlobalPowerManger power;
+    GlobalDeviceManager *dm=get_dm();
+
+    if(cas->cmd.obj!=OBJ_CHANNEL) {
+        return -1;
+    }
+    
+    r = get_pwr_info(cas, cas->cmd.chId, &power);
+    if(r) {
+        LOGE("____ get_pwr_info failed\n");
+        return -1;
+    }
+    r = dev_update_power_manage_genera_info(dm->db, dm->_global_device_info->product_id, cas->cmd.chId, &power);
 
+    return r;
+}
+/////////////////////////////////////////////////////////////////////////////////////////
 
 static int mb_init(cascade_handle_t *cas, char *path, int type, int addr, uint32_t baud)
 {
@@ -159,8 +201,10 @@ static int mb_init(cascade_handle_t *cas, char *path, int type, int addr, uint32
     if(r==0 && type>0) {
         if(type>0) {
             LOGD("___ set slave addr: %d\n", addr);
-            g_modbus_set_slave(&cas->m, addr);
+
             cas->addr = addr;
+            g_modbus_set_slave(&cas->m, addr);
+            slave_get_info(cas);
         }
         else {
             cas->addr = -1;
@@ -209,14 +253,9 @@ static void print_cmd(char *s, cmd_data_t *cmd)
 
     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__ 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("__%s__ cmd.time_s: %s\n", s, cmd->time_s);
+    //LOGD("__%s__ cmd.time_e: %s\n", s, cmd->time_e);
 
     LOGD("\n");
 }
@@ -265,7 +304,12 @@ static int mb_read(cascade_handle_t *cas, int addr, data_t *d)
     int xlen,rlen=0,oncelen=MB_MAX_LEN;
     uint8_t buff[MODBUS_RTU_MAX_ADU_LENGTH];
 
+    if(d->dlen<=0) {
+        //LOGE("___ mb_read dlen %d is wrong!\n", d->dlen);
+        return -1;
+    }
     LOGD("___ mb_read dlen: %d\n", d->dlen);
+
     while(1) {
         if(rlen+oncelen>d->dlen) {
             xlen = d->dlen-rlen;
@@ -299,6 +343,12 @@ 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];
 
+    if(d->dlen<=0) {
+        //LOGE("___ mb_write dlen %d is wrong!\n", d->dlen);
+        return -1;
+    }
+    LOGD("___ mb_write dlen: %d\n", d->dlen);
+
     while(1) {
         if(wlen+oncelen>d->dlen) {
             xlen = d->dlen-wlen;
@@ -359,9 +409,10 @@ static int mb_receive(cascade_handle_t *cas)
         return -1;
     }
 #endif
+    //LOGD("____ slave recv, reg: %d\n", h.reg);
 
     //如果是非自定义寄存器则跳出
-    if(h.reg>=CASCADE_REG_SCAN && h.reg<=CASCADE_REG_WRITE) {
+    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;
@@ -403,59 +454,64 @@ static int mb_receive(cascade_handle_t *cas)
                 case CASCADE_CMD_SAVE:
                 case CASCADE_CMD_SAVE3:
                 {
-                    if(cas->cmd.obj==OBJ_CHANNEL) {
-                        //dev_update_power_manage_genera_info(get_dm()->db, get_dm()->_global_device_info->product_id, _globalPowerMangerTemp->product_ch_id, _globalPowerMangerTemp);
-                    }
+                    //slave_save(cas);
                 }
                 break;
 
                 case CASCADE_CMD_GET_INFO:
                 {
                     LOGD("_____ slave recv CASCADE_CMD_GET_INFO\n");
-                    memcpy(cas->map->tab_registers+h.reg, ((char*)&cas->info)+sendlen, h.regcnt*2);
+                    memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), ((char*)&cas->info)+sendlen, h.regcnt*2);
                 }
                 break;
             }
 
-            r = _mb_reply(cas, buff, r, cas->map);
+            r = _mb_reply(cas, buff, r, cas->map2);
         }
         else if(h.reg==CASCADE_REG_READ) {
-
-            switch(cas->cmd.cmd) {
-                case CASCADE_CMD_QUERY_CH:
-                {
-                    if(cas->cmd.obj==OBJ_OVERALL){
-                        slave_get_all_data(cas);
-                        memcpy(cas->map->tab_registers+h.reg, ((char*)&cas->pwrInfo.info)+sendlen, h.regcnt*2);
-                    }
-                    else {
-                        return -1;
+            if(h.regcnt==1) {
+                r = _mb_reply(cas, buff, r, cas->map2);
+            }
+            else {
+                switch(cas->cmd.cmd) {
+                    case CASCADE_CMD_QUERY_CH:
+                    {
+                        LOGD("___ slave CASCADE_CMD_QUERY_CH\n");
+                        if(cas->cmd.obj==OBJ_OVERALL){
+                            slave_get_all_data(cas);
+                            memcpy(cas->map2->tab_registers+(h.reg-CASCADE_REG_OFFSET), ((char*)&cas->pwrInfo.info)+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;
+                    case CASCADE_CMD_QUERY_TOTAL_PWR:break;
                 }
-                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, r, cas->map);
-            if(r>0) {
-                sendlen += h.regcnt*2;
-                //LOGD("____  slave sendlen: %d, h.dlen: %d, r: %d\n", sendlen, h.dlen, r);
+                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);
+                }
             }
         }
         else {
-            r = _mb_reply(cas, buff, r, cas->map);
+            r = _mb_reply(cas, buff, r, cas->map2);
         }
     }
     else {
         Modbus_Manger *mm=&get_dm()->_globalRelaySampManger;
         //g_switch_set_all_ctrl(mm,_globalPowerMangerTemp->product_ch_type,_globalPowerMangerTemp->product_saddr,1);
+
+        r = _mb_reply(cas, buff, r, cas->map);
     }
 
     return r ;
@@ -471,13 +527,13 @@ static int cascade_scan(cascade_handle_t *cas)
     }
 
     if(!slave_find(cas, cas->scanAddr)) {
-         r = _mb_read(cas, cas->scanAddr, CASCADE_REG_SCAN, tmp, 1);
+         r = _mb_read(cas, cas->scanAddr, CASCADE_REG_READ, tmp, 1);
         if(r>0) {
             LOGD("____ find a slave, addr: %d\n", cas->scanAddr);
             slave_add(cas, cas->scanAddr);
         }
         else {
-            //LOGW("____ scan %d fail, %s\n", cas->scanAddr, modbus_strerror(errno));
+            LOGW("____ scan %d fail, %s\n", cas->scanAddr, modbus_strerror(errno));
         }
     }
     cas->scanAddr++;
@@ -532,6 +588,7 @@ static int power_add(cascade_handle_t *cas)
 
     power_clear(cas);
 
+    LOGD("_____ master add channel to the list, cnt: %d\n", info->cnt);
     for(i=0; i<info->cnt; i++) {
         for (j=0; j<info->board[i].maxChn; j++) {
             pm = (GlobalPowerManger*)calloc(1, sizeof(GlobalPowerManger));
@@ -557,56 +614,55 @@ static int power_add(cascade_handle_t *cas)
 
     return 0;
 }
-static int power_ch_update(cascade_handle_t *cas, int chId)
+
+static int power_overall_update(cascade_handle_t *cas)
 {
     GlobalPowerManger *tmp=NULL;
     GlobalDeviceManager *dm2=get_dm2();
-    _OverChnPwrAckInfo *info=&cas->chInfo;
+    _OverAllPwrAckInfo *info=&cas->allInfo;
 
-    list_for_each_entry(tmp, &dm2->_globalPowerManger.list, list)
+    if (dm2->_global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree || 
+        dm2->_global_device_info->product_pwr_type == SmartPDU_Tree_AC_One)
     {
-        if(tmp->product_ch_id==chId) {
-            tmp->_PowerInfo.voltage = info->voltage;
-            tmp->_PowerInfo.current = info->current;
-            tmp->_PowerInfo.power = info->power;
-            tmp->_PowerInfo.status = info->status;
-            tmp->_PowerInfo.factor = info->factor;
-            tmp->_PowerInfo.consumption = info->consumption;
-            tmp->_PowerInfo.freq = info->freq;
-
-            return 0;
-        }
+        dev_search_latest_t_ac_power_statistic_info(0, 0, info);
+        dev_search_latest_t_ac_power_statistic_info(0, 1, info);
+        dev_search_latest_t_ac_power_statistic_info(0, 2, info);
     }
-    return -1;
+    else
+    {
+        GlobalPowerInfo pwrInfo;
+        dev_search_latest_power_info(dm2->db, dm2->_global_device_info->product_id, 0, &pwrInfo);
+        info->voltage = pwrInfo._power_info.voltage ; 
+        info->current = pwrInfo._power_info.current ;
+        info->power =  pwrInfo._power_info.power ;
+        info->freq =  pwrInfo._power_info.freq ;
+        info->consumption =  pwrInfo._power_info.consumption ;
+        info->factor = pwrInfo._power_info.factor ;
+    }
+    
+    return 0;
 }
-static int power_all_update(cascade_handle_t *cas)
+
+static int power_ch_update(cascade_handle_t *cas)
 {
+    int cnt=0;
     GlobalPowerManger *tmp=NULL;
     GlobalDeviceManager *dm2=get_dm2();
-    _OverAllPwrAckInfo *info=&cas->allInfo;
+    PowerInfo *info=cas->pwrInfo.info;
 
-    if (dm2->_global_device_info->product_pwr_type == SmartPDU_Tree_AC_Tree || 
-        dm2->_global_device_info->product_pwr_type == SmartPDU_Tree_AC_One)
-        {
-            dev_search_latest_t_ac_power_statistic_info(0, 0, info);
-            dev_search_latest_t_ac_power_statistic_info(0, 1, info);
-            dev_search_latest_t_ac_power_statistic_info(0, 2, info);
-        }
-        else
-        {
-            GlobalPowerInfo pwrInfo;
-            dev_search_latest_power_info(dm2->db, dm2->_global_device_info->product_id, 0, &pwrInfo);
-            info->voltage = pwrInfo._power_info.voltage ; 
-            info->current = pwrInfo._power_info.current ;
-            info->power =  pwrInfo._power_info.power ;
-            info->freq =  pwrInfo._power_info.freq ;
-            info->consumption =  pwrInfo._power_info.consumption ;
-            info->factor = pwrInfo._power_info.factor ;
+    list_for_each_entry(tmp, &dm2->_globalPowerManger.list, list)
+    {
+        if(cnt>cas->pwrInfo.cnt) {
+            break;
         }
+        tmp->_PowerInfo = info[cnt];
+        cnt++;
+    }
     
     return 0;
 }
 
+
 static void print_sensor(char *s, sensor_data_t *ss)
 {
     LOGD("__%s__ ss.type: %d\n", s, ss->type);
@@ -668,14 +724,13 @@ static int power_query()
 {
     
 }
-static int master_request(cascade_handle_t *cas)
+static int master_request(cascade_handle_t *cas, cmd_data_t *cmd)
 {
     int i,r;
     GlobalPowerManger *tmp=NULL;
     GlobalDeviceManager *dm=get_dm();
     GlobalDeviceManager *dm2=get_dm2();
     GlobalDeviceInfo    *dev=&dm2->_global_device_info;
-    cmd_data_t *cmd=&cas->cmd;
     data_t rdata,wdata;
 
     if(cur_dev_addr==0) {
@@ -701,12 +756,11 @@ static int master_request(cascade_handle_t *cas)
 
             rdata.dlen = sizeof(cas->info);
             rdata.data = (uint8_t*)&cas->info;
+
+            LOGD("_____ master send CASCADE_CMD_GET_INFO\n");
             r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
             if(r==0) {
-                //power_clear();
-                for(i=0; i<cas->info.cnt; i++) {
-                    power_add(cas);
-                }
+                power_add(cas);
             }
             else {
                 LOGE("_____ master request CASCADE_CMD_GET_INFO failed\n");
@@ -759,9 +813,14 @@ static int master_query(cascade_handle_t *cas)
 
         case CASCADE_CMD_QUERY_CH:
         {
-            if(cmd->obj==OBJ_OVERALL) {
+            LOGD("____ master query CASCADE_CMD_QUERY_CH\n");
+            if(cmd->obj==OBJ_OVERALL || cmd->obj==OBJ_CHANNEL) {
                 rdata.dlen = sizeof(PowerInfo)*cas->info.cnt;
                 rdata.data = (uint8_t*)&cas->pwrInfo.info;
+                r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
+                if(r==0) {
+                    power_ch_update(cas);
+                }
             }
             else {
                 return -1;
@@ -885,8 +944,6 @@ static int master_query(cascade_handle_t *cas)
         return -1;
     }
 
-    r = mb_write_read(cas, cur_dev_addr, &wdata, &rdata);
-
     return r;
 }
 
@@ -957,12 +1014,17 @@ int cascade_init(void)
     int r=0;
     cascade_handle_t *cas=&casHandle;
     
+    memset(cas, 0, sizeof(casHandle));
+
     power_init();
     slave_init(cas);
     
     cas->scanAddr = 1;
     cas->pwrInfo.info = malloc(128*sizeof(PowerInfo));
-    cas->map = modbus_mapping_new(0,0,MAX_READ_REGS,MAX_WRITE_REGS);
+    //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);
 
     set_modbus(cas, get_mb());
     slave_add(cas, 0);
@@ -1022,14 +1084,26 @@ int cascade_free_dlist(dev_list_t *dl)
  
 int cascade_request(cmd_data_t *cmd)
 {
+    int r=0;
     cascade_handle_t *cas=&casHandle;
 
     if(!cmd) {
         return -1;
     }
+    
+    if(cmd->cmd==CASCADE_CMD_QUERY_CH) {
+        cmd_data_t cmd2=*cmd;
 
-    cas->cmd = *cmd;
-    return master_request(cas);
+        cmd2.cmd = CASCADE_CMD_GET_INFO;
+        r = master_request(cas, &cmd2);
+    }
+
+    if(r==0) {
+        cas->cmd = *cmd;
+        r = master_request(cas, cmd);
+    }
+
+    return r;
 }
 
 

pro/src/cascade.h

@@ -7,14 +7,16 @@
 
 #define ERR_MAX                         5
 
-#define MAX_READ_REGS                   20000
-#define MAX_WRITE_REGS                  10000
+#define MAX_READ_REGS                   1000
+#define MAX_WRITE_REGS                  1000
+
+#define MAX_READ_REGS2                  50000
+#define MAX_WRITE_REGS2                 50000
 
-#define CASCADE_REG_OFFSET              0x10
 
-#define CASCADE_REG_SCAN                (CASCADE_REG_OFFSET+0x00)
-#define CASCADE_REG_READ                (CASCADE_REG_OFFSET+0x01)
-#define CASCADE_REG_WRITE               (CASCADE_REG_OFFSET+0x02)
+#define CASCADE_REG_OFFSET              0x10
+#define CASCADE_REG_READ                (CASCADE_REG_OFFSET+0x00)
+#define CASCADE_REG_WRITE               (CASCADE_REG_OFFSET+0x01)
 
 enum {
     CASCADE_CMD_OPEN=0,
@@ -31,6 +33,8 @@ enum {
     CASCADE_CMD_QUERY_HIS,
     CASCADE_CMD_QUERY_TOTAL,
     CASCADE_CMD_QUERY_TOTAL_PWR,
+
+    CASCADE_CMD_MAX,
 };
 
 #pragma pack (1)
@@ -115,7 +119,6 @@ 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
 }cmd_data_t;