modbus TCP 一对多，向北modbus 传感器和干节点信息获取。

ip/modbus/modbus.c

@@ -1748,6 +1748,13 @@ void modbus_free(modbus_t *ctx)
 
     ctx->backend->free(ctx);
 }
+int mdbus_tcp_setfd(modbus_t *ctx,int fd)
+{
+    if (ctx == NULL)
+        return -1;
+    ctx->s = fd;
+    return 0;
+}
 
 int modbus_set_debug(modbus_t *ctx, int flag)
 {

ip/modbus/modbus.h

@@ -237,6 +237,7 @@ MODBUS_API int modbus_reply(modbus_t *ctx, const uint8_t *req,
                             int req_length, modbus_mapping_t *mb_mapping);
 MODBUS_API int modbus_reply_exception(modbus_t *ctx, const uint8_t *req,
                                       unsigned int exception_code);
+MODBUS_API int mdbus_tcp_setfd(modbus_t *ctx,int fd);
 
 /**
  * UTILS FUNCTIONS

ip/src/cascade.h

@@ -34,7 +34,7 @@
 // #define CASCADE_REG_BREAKER_WRITE       (CASCADE_REG_BREAKER+1)
 
 #define CASCADE_SLAVE_CONNECTION                5
-#define CASCADE_SLAVE_PORT                      6666
+#define CASCADE_SLAVE_PORT                      502
 
 enum {
     CASCADE_CMD_OPEN=0,

ip/src/cascade_slave.c

@@ -7,6 +7,8 @@
 #include "sys.h"
 #include "thread.h"
 #include "sensor_handle.h"
+#include "pthread.h"
+#include "modbus.h"
 
 #define DEV_CHN_REG                 (4000)  
 #define OUT_INFO_REG                (4001)     
@@ -905,7 +907,7 @@ Modbus_Manger_Tcp* tcp_modbus_init(const char* ip, uint16_t port,uint8_t addr,in
     }
     memset(tcp, 0, sizeof(Modbus_Manger_Tcp));
     
-    tcp->ctx = modbus_new_tcp(ip, port);
+    tcp->ctx = modbus_new_tcp(NULL, port);
     if(!tcp->ctx)
     {
         log_d("malloc modbus_tcp ctx faield!!!\n");
@@ -949,7 +951,50 @@ void  tcp_modbus_deinit(Modbus_Manger_Tcp **tcp)
 }
 
 
-
+static void *pthread_handle_tcp(void *arg)
+{
+    uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH] = {0};
+    int ret = 0;
+    //Modbus_Manger_Tcp *tcp = (Modbus_Manger_Tcp *)(arg);
+    int fd = *(int*)(arg);
+    Modbus_Manger_Tcp *mb =tcp_modbus_init("0.0.0.0",CASCADE_SLAVE_PORT,1,0);
+    struct timeval response_timeout;
+    response_timeout.tv_sec = 1;
+    response_timeout.tv_usec = 0;
+    modbus_set_response_timeout(mb->ctx, 0,800000);
+    modbus_set_byte_timeout(mb->ctx,0,50000);
+    modbus_set_error_recovery(mb->ctx,MODBUS_ERROR_RECOVERY_PROTOCOL);
+    //mb->ctx->s = fd;
+    mdbus_tcp_setfd(mb->ctx,fd);
+    int rc = 0;
+    mb_hdr_t h;
+    while(1)
+    {
+        rc = modbus_receive(mb->ctx,query);
+        log_d("recive modbus rc=%d\n",rc);
+        if(rc > 0)
+        {
+            _mb_hdr(&query[6],rc,&h);
+            if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
+                cascade_slave_read(h.reg, h.regcnt);
+                modbus_reply(mb->ctx,query,rc,cascade_slave_map());
+            }    
+            }else if(rc < 0)
+            {
+                log_d("thread out!!!!!\n");
+                break;
+            }else
+            {
+                continue;
+            }
+    }
+    modbus_close(mb->ctx);
+    modbus_free(mb->ctx);
+    mb->ctx = 0;
+    free(mb);
+    mb = NULL;
+    pthread_exit(NULL);
+}
 
 
 
@@ -960,24 +1005,30 @@ void* tcp_modbus_thread(void *arg)
     GlobalDeviceManager *mgr = get_dm();
     Modbus_Manger_Tcp *tcp = mgr->md_tcp;
     tcp->connection = modbus_tcp_listen(tcp->ctx,CASCADE_SLAVE_CONNECTION);
-    modbus_tcp_accept(tcp->ctx,&tcp->connection);
+    ;
     uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH] = {0};
-    mb_hdr_t h;
+    
     log_d("start tcp modbus thread!!!\n");
     int rc = 0;
+    pthread_t thread_id = 0;
+    int recive_fd = 0;
     while(1)
     {
         if(tcp->ctx){
-            rc = tcp_modbus_receive(tcp,query);
-            if(rc > 0)
+
+            struct sockaddr_in addr;
+            socklen_t addrlen;
+            addrlen = sizeof(addr);
+#ifdef HAVE_ACCEPT4
+                /* Inherit socket flags and use accept4 call */
+                recive_fd = accept4(tcp->connection, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC);
+#else
+                recive_fd = accept(tcp->connection, (struct sockaddr *)&addr, &addrlen);
+#endif
+            if(recive_fd > 0)
             {
-                _mb_hdr(&query[6],rc,&h);
-                if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
-                    cascade_slave_read(h.reg, h.regcnt);
-                    tcp_modbus_reply(tcp,query,rc,cascade_slave_map());
-                }
-                
-                //r = _mb_reply(cas, buff, rc,cascade_slave_map());
+                pthread_create(&thread_id,NULL,pthread_handle_tcp,(void*)(&recive_fd));
+                pthread_detach(thread_id);
             }
         }
     }

pro/src/app.c

@@ -1381,6 +1381,51 @@ static void* breaker_thread(void *arg)
     pthread_exit(NULL);
 }
 
+
+static void set_sensor_val_modbus(GlobalDeviceManager *_globalDeviceManager,GlobalSensorInfo *info,int saddr)
+{
+    if(saddr>4 || saddr<0)
+        return;
+    if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
+    _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)
+    {
+        if(_globalDeviceManager->single_mmap) {
+            _globalDeviceManager->single_mmap->cas_sensor[saddr-1].s_1 = info->val1 * 1000;
+            if(info->val2 == -1)
+                 _globalDeviceManager->single_mmap->cas_sensor[saddr-1].s_2 = 0xFFFFFFFF;
+            else
+                _globalDeviceManager->single_mmap->cas_sensor[saddr-1].s_2 = info->val2 * 1000;
+        }
+    }else{
+        if (_globalDeviceManager->triphasic_mmap)
+        {
+            _globalDeviceManager->triphasic_mmap->cas_sensor[saddr-1].s_1 = info->val1 * 1000;
+            if(info->val2 == -1)
+                 _globalDeviceManager->triphasic_mmap->cas_sensor[saddr-1].s_2 = 0xFFFFFFFF;
+            else
+                _globalDeviceManager->triphasic_mmap->cas_sensor[saddr-1].s_2 = info->val2 * 1000;
+        }
+    }
+}
+static void set_dry_val_modbus(GlobalDeviceManager *_globalDeviceManager,int val,int saddr)
+{
+    if(saddr>=4 || saddr<0)
+        return;
+    if(_globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_AC ||
+    _globalDeviceManager->_globalDevInfo.product.pwr_type == SmartPDU_DC)
+    {
+        if(_globalDeviceManager->single_mmap) {
+            _globalDeviceManager->single_mmap->d_node[saddr]= val;
+        }
+    }else{
+        if (_globalDeviceManager->triphasic_mmap)
+        {
+            _globalDeviceManager->triphasic_mmap->d_node[saddr]= val;
+        }
+    }
+}
+
+
 /// @brief 传感器采集线程
 /// @param arg 
 /// @return 
@@ -1498,6 +1543,7 @@ static void* sensor_thread(void* arg)
                 _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                 _globalDeviceManager->g_modebus_read.temprature=temperature*100;
                 _globalDeviceManager->g_modebus_read.humidity=humidity*100;
+                set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,_globalSensorMangerTemp->sensor_addr);
             }
             break;
             case SENSOR_TYPE_SMOKE: // 烟雾
@@ -1519,6 +1565,7 @@ static void* sensor_thread(void* arg)
                         _globalSensorMangerTemp->sensor_status = 0;
                     }
                     _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
+                    set_dry_val_modbus(_globalDeviceManager,_globalSensorMangerTemp->sensor_status,_globalSensorMangerTemp->sensor_addr);
                 }                
             }
             break;
@@ -1535,10 +1582,12 @@ static void* sensor_thread(void* arg)
                 else
                 {
                     _globalSensorMangerTemp->sensor_status = 0;
+
                 }
                 _globalSensorInfo.val1 = CO2;
                 _globalSensorInfo.val2 = 0;
                 _globalSensorMangerTemp->Cur_sensor_info = _globalSensorInfo;
+                set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,_globalSensorMangerTemp->sensor_addr);
             }
             break;
             case SENSOR_TYPE_AIR_PRESS: // 气流
@@ -1570,6 +1619,7 @@ static void* sensor_thread(void* arg)
                 _globalSensorInfo.val1 = sdat.val[0];
                 _globalSensorInfo.val2 = -1;
                 _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
+                set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,_globalSensorMangerTemp->sensor_addr);
             }
             break;
 
@@ -1587,6 +1637,7 @@ static void* sensor_thread(void* arg)
                 _globalSensorInfo.val1 = sdat.flag;
                 _globalSensorInfo.val2 = -1;
                 _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
+                set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,_globalSensorMangerTemp->sensor_addr);
             }
             break;
 
@@ -1615,6 +1666,7 @@ static void* sensor_thread(void* arg)
                 _globalSensorMangerTemp->Cur_sensor_info=_globalSensorInfo;
                 _globalDeviceManager->g_modebus_read.temprature=temperature*100;
                 _globalDeviceManager->g_modebus_read.temprature2=temperature2*100;
+                set_sensor_val_modbus(_globalDeviceManager,&_globalSensorInfo,_globalSensorMangerTemp->sensor_addr);
             }
             break;
             }

pro/src/cascade.c

@@ -1911,8 +1911,10 @@ int cascade_init(void)
     }
 
     dm->md_tcp = tcp_modbus_init("0.0.0.0",CASCADE_SLAVE_PORT,addr,dm->_globalDevInfo.product.pwr_type);
-    if(dm->md_tcp)
+    if(dm->md_tcp){
+        LOGD("___ TCP Modbus Init sucessful!!!!\n");
         thread_start(THREAD_ID_TCP, tcp_modbus_thread, NULL);
+    }
     else
         LOGE("___ TCP Modbus Init Failed!!!!\n");
     return 0;

pro/src/cascade_slave.c

@@ -14,6 +14,8 @@
 #define CHN_SWITCH_REG              (4779)
 #define CHN_OPEN_DLA_REG            (4843)
 #define CHN_CLOSE_DLA_REG           (4907)
+#define SENSOR_REG                  (4971)
+#define DRY_REG                     (4987)     
 #define CHN_SET_OPEN_DLA_REG        (5000)
 #define CHN_SET_CLOSE_DLA_REG       (5064)
 #define CHN_SET_SWITCH_STA_REG      (5128)
@@ -35,6 +37,8 @@ enum {
     DS_R_SWITCH_STA,
     DS_R_OPEN_DELAY,
     DS_R_CLOSE_DELAY,
+    DS_R_SENSOR,
+    DS_R_DRY,
     DS_W_OPEN_DELAY,
     DS_W_CLOSE_DELAY,
     DS_W_CHN_SWITCH_STA,
@@ -52,6 +56,10 @@ enum {
 #define TREE_CHN_SWITCH_STA_REG         (8587)
 #define TREE_CHN_OPEN_DLA_REG           (8651)
 #define TREE_CHN_CLOSE_DLA_REG          (8715)
+
+#define TREE_SENSOR_REG                 (8779)
+#define TREE_DRY_REG                    (8795) 
+
 #define TREE_CHN_SET_OPEN_DLA_REG       (9000)
 #define TREE_CHN_SET_CLOSE_DLA_REG      (9064)
 #define TREE_CHN_SET_SWITCH_STA_REG     (9128)
@@ -68,6 +76,8 @@ enum {
     TREE_R_SWITCH_STA,
     TREE_R_OPEN_DELAY,
     TREE_R_CLOSE_DELAY,
+    TREE_R_SENSOR,
+    TREE_R_DRY,
     TREE_W_OPEN_DELAY,
     TREE_W_CLOSE_DELAY,
     TREE_W_CHN_SWITCH_STA,
@@ -94,6 +104,8 @@ static mmap_modbus_t modbus_single[] = {
     [DS_R_SWITCH_STA    ]{.offset = CHN_SWITCH_REG          },
     [DS_R_OPEN_DELAY    ]{.offset = CHN_OPEN_DLA_REG        },
     [DS_R_CLOSE_DELAY   ]{.offset = CHN_CLOSE_DLA_REG       },
+    [DS_R_SENSOR        ]{.offset = SENSOR_REG              },
+    [DS_R_DRY           ]{.offset = DRY_REG                 },                
     [DS_W_OPEN_DELAY    ]{.offset = CHN_SET_OPEN_DLA_REG    },
     [DS_W_CLOSE_DELAY   ]{.offset = CHN_SET_CLOSE_DLA_REG   },
     [DS_W_CHN_SWITCH_STA]{.offset = CHN_SET_SWITCH_STA_REG  },
@@ -111,6 +123,8 @@ static mmap_modbus_t modbus_three[] = {
     [TREE_R_SWITCH_STA      ]{.offset = TREE_CHN_SWITCH_STA_REG},
     [TREE_R_OPEN_DELAY      ]{.offset = TREE_CHN_OPEN_DLA_REG  },
     [TREE_R_CLOSE_DELAY     ]{.offset = TREE_CHN_CLOSE_DLA_REG },
+    [TREE_R_SENSOR          ]{.offset = TREE_SENSOR_REG         },
+    [TREE_R_DRY             ]{.offset = TREE_DRY_REG             }, 
     [TREE_W_OPEN_DELAY      ]{.offset = TREE_CHN_SET_OPEN_DLA_REG},
     [TREE_W_CLOSE_DELAY     ]{.offset = TREE_CHN_SET_CLOSE_DLA_REG},
     [TREE_W_CHN_SWITCH_STA  ]{.offset = TREE_CHN_SET_SWITCH_STA_REG},
@@ -150,6 +164,8 @@ int cascade_slave_init(void)
         modbus_single[DS_R_SWITCH_STA       ].addr = &mgr->single_mmap->chn_status; 
         modbus_single[DS_R_OPEN_DELAY       ].addr = &mgr->single_mmap->open_delay;
         modbus_single[DS_R_CLOSE_DELAY      ].addr = &mgr->single_mmap->close_delay;
+        modbus_single[DS_R_SENSOR           ].addr = &mgr->single_mmap->cas_sensor;
+        modbus_single[DS_R_DRY              ].addr = &mgr->single_mmap->d_node;
         modbus_single[DS_W_OPEN_DELAY       ].addr = &mgr->single_mmap->set_chn_open_delay;
         modbus_single[DS_W_CLOSE_DELAY      ].addr = &mgr->single_mmap->set_chn_close_delay;
         modbus_single[DS_W_CHN_SWITCH_STA   ].addr = &mgr->single_mmap->set_chn_switch_status;
@@ -173,6 +189,9 @@ int cascade_slave_init(void)
         modbus_three[TREE_R_SWITCH_STA      ].addr = &mgr->triphasic_mmap->chn_status;
         modbus_three[TREE_R_OPEN_DELAY      ].addr = &mgr->triphasic_mmap->open_delay;
         modbus_three[TREE_R_CLOSE_DELAY     ].addr = &mgr->triphasic_mmap->close_delay;
+        modbus_single[TREE_R_SENSOR         ].addr = &mgr->triphasic_mmap->cas_sensor;
+        modbus_single[TREE_R_DRY            ].addr = &mgr->triphasic_mmap->d_node;
+
         modbus_three[TREE_W_OPEN_DELAY      ].addr = &mgr->triphasic_mmap->set_chn_open_delay;
         modbus_three[TREE_W_CLOSE_DELAY     ].addr = &mgr->triphasic_mmap->set_chn_close_delay;
         modbus_three[TREE_W_CHN_SWITCH_STA  ].addr = &mgr->triphasic_mmap->set_chn_switch_status;
@@ -269,6 +288,12 @@ void cascade_slave_read(uint32_t addr,uint32_t lenth)
         case 4907 ... 4970:
             slave_read(sh,addr,lenth,DS_R_CLOSE_DELAY,TYPE_U16);
         break;
+        case SENSOR_REG ... (DRY_REG-1):
+            slave_read(sh,addr,lenth,DS_R_SENSOR,TYPE_U32);
+        break;
+        case DRY_REG ... 4990:
+            slave_read(sh,addr,lenth,DS_R_DRY,TYPE_U16);
+        break;
         case 5000 ... 5063:
             slave_read(sh,addr,lenth,DS_W_OPEN_DELAY,TYPE_U16);
         break;
@@ -313,7 +338,12 @@ void cascade_slave_read(uint32_t addr,uint32_t lenth)
         case 8715 ... 8778:
             slave_read(sh,addr,lenth,TREE_R_CLOSE_DELAY,TYPE_U16);
         break;
-
+        case TREE_SENSOR_REG ... (TREE_DRY_REG-1):
+            slave_read(sh,addr,lenth,TREE_R_SENSOR,TYPE_U32);
+        break;
+        case TREE_DRY_REG ... 8798:
+            slave_read(sh,addr,lenth,TREE_R_DRY,TYPE_U16);
+        break;
         default:
         break;
     }

pro/src/cascade_slave_tcp.c

@@ -94,6 +94,54 @@ static inline GlobalDeviceManager* get_dm(void)
     return &__globalDeviceManage;
 }
 
+static void *pthread_handle_tcp(void *arg)
+{
+    uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH] = {0};
+    int ret = 0;
+    //Modbus_Manger_Tcp *tcp = (Modbus_Manger_Tcp *)(arg);
+    int fd = *(int*)(arg);
+    Modbus_Manger_Tcp *mb =tcp_modbus_init("0.0.0.0",CASCADE_SLAVE_PORT,1,0);
+    struct timeval response_timeout;
+    response_timeout.tv_sec = 1;
+    response_timeout.tv_usec = 0;
+    modbus_set_response_timeout(mb->ctx, 0,800000);
+    modbus_set_byte_timeout(mb->ctx,0,50000);
+    modbus_set_error_recovery(mb->ctx,MODBUS_ERROR_RECOVERY_PROTOCOL);
+    //mb->ctx->s = fd;
+    //mdbus_tcp_setfd(mb->ctx,fd);
+    mb->ctx->s = fd;
+    int rc = 0;
+    mb_hdr_t h;
+    while(1)
+    {
+        rc = modbus_receive(mb->ctx,query);
+        log_d("recive modbus rc=%d\n",rc);
+        if(rc > 0)
+        {
+            _mb_hdr(&query[6],rc,&h);
+            if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
+                cascade_slave_read(h.reg, h.regcnt);
+                modbus_reply(mb->ctx,query,rc,cascade_slave_map());
+            }    
+            }else if(rc < 0)
+            {
+                log_d("thread out!!!!!\n");
+                break;
+            }else
+            {
+                continue;
+            }
+    }
+    modbus_close(mb->ctx);
+    modbus_free(mb->ctx);
+    mb->ctx = 0;
+    free(mb);
+    mb = NULL;
+    pthread_exit(NULL);
+}
+
+
+
 void* tcp_modbus_thread(void *arg)
 {
     //GlobalDeviceManager *mgr = (GlobalDeviceManager *)(arg);
@@ -106,20 +154,27 @@ void* tcp_modbus_thread(void *arg)
     mb_hdr_t h;
     log_d("start tcp modbus thread!!!\n");
     int rc = 0;
+    pthread_t thread_id = 0;
+    int recive_fd = 0;
+
     while(1)
     {
-        rc = modbus_receive(tcp->ctx,query);
-        if(rc > 0)
-        {
-            _mb_hdr(&query[6],rc,&h);
-            if(h.func==MODBUS_FC_READ_HOLDING_REGISTERS) {
-                cascade_slave_read(h.reg, h.regcnt);
-            }
-            else if(h.func==MODBUS_FC_WRITE_SINGLE_REGISTER) {
-                cascade_slave_write(h.reg, h.regcnt);
+        if(tcp->ctx){
+
+            struct sockaddr_in addr;
+            socklen_t addrlen;
+            addrlen = sizeof(addr);
+#ifdef HAVE_ACCEPT4
+                /* Inherit socket flags and use accept4 call */
+                recive_fd = accept4(tcp->connection, (struct sockaddr *)&addr, &addrlen, SOCK_CLOEXEC);
+#else
+                recive_fd = accept(tcp->connection, (struct sockaddr *)&addr, &addrlen);
+#endif
+            if(recive_fd > 0)
+            {
+                pthread_create(&thread_id,NULL,pthread_handle_tcp,(void*)(&recive_fd));
+                pthread_detach(thread_id);
             }
-            modbus_reply(tcp->ctx,query,rc,cascade_slave_map());
-            //r = _mb_reply(cas, buff, rc,cascade_slave_map());
         }
     }
 

pro/src/cascade_slave_tcp.h

@@ -11,6 +11,7 @@
 #define CASCADE_SLAVE_PORT                      502
 
 
+#include "modbus-private.h"
 
 Modbus_Manger_Tcp* tcp_modbus_init(const char * ip, uint16_t port,uint8_t addr,int power_type);
 void  tcp_modbus_deinit(Modbus_Manger_Tcp **tcp);

pro/src/common.h

@@ -938,6 +938,14 @@ typedef struct temp_hum{
     uint16_t humidity;
 }temp_hum_t;
 
+typedef uint32_t  sensor_t;
+typedef uint16_t  dry_node_t;
+
+typedef struct cascade_sensor{
+    sensor_t s_1;
+    sensor_t s_2;
+}cascade_sensor_t;
+
 #pragma pack (1)
 typedef struct cascade_single_mmap{
     uint16_t dev_chn;
@@ -951,7 +959,10 @@ typedef struct cascade_single_mmap{
     uint16_t chn_status[64];
     uint16_t open_delay[64];
     uint16_t close_delay[64];
-    uint16_t reservers[29];
+    //uint16_t reservers[29];
+    cascade_sensor_t cas_sensor[4];
+    dry_node_t       d_node[4];
+    uint16_t reservers[9];
     uint16_t set_chn_open_delay[64];
     uint16_t set_chn_close_delay[64];
     uint16_t set_chn_switch_status[64];
@@ -1010,6 +1021,8 @@ typedef struct cascade_triphasic_mmap{
     uint16_t chn_status[MAX_CHN];
     uint16_t open_delay[MAX_CHN];
     uint16_t close_delay[MAX_CHN];
+    cascade_sensor_t cas_sensor[4];
+    dry_node_t       d_node[4];
     uint16_t set_chn_open_delay[MAX_CHN];
     uint16_t set_chn_close_delay[MAX_CHN];
     uint16_t set_chn_switch_status[MAX_CHN];