错误代码

error_code/error_code.h

@@ -166,6 +166,10 @@ enum Error_code
     HARDWARE_LIMIT_CENTER_Y_BOTTOM,
     HARDWARE_LIMIT_HEIGHT_OUT_RANGE,
     HARDWARE_LIMIT_ANGLE_OUT_RANGE,
+    //termonal_limit from 0x05010200-0x050102ff
+    HARDWARE_LIMIT_TERMINAL_LEFT_ERROR,
+    HARDWARE_LIMIT_TERMINAL_RIGHT_ERROR,
+    HARDWARE_LIMIT_TERMINAL_LR_ERROR,
 
 
     //wj_lidar error from 0x06010000-0x0601FFFF

system_manager/System_Manager.cpp

@@ -159,6 +159,7 @@ Error_manager System_Manager::init()
     }
     //创建limit模块
     mp_verify_result_tool=new Verify_result(hardware_parameter);
+    LOG(WARNING)<<"0 verify addr : "<<mp_verify_result_tool;
     //创建万集雷达
     mp_wj_controller=new Fence_controller(mp_verify_result_tool);
     code=mp_wj_controller->initialize(wj_parameter);

terminor/terminal_command_executor.cpp

@@ -516,15 +516,17 @@ Error_manager Terminor_Command_Executor::scanning_measuring()
         cv::RotatedRect rotated_rect;
         rotated_rect.center = cv::Point2f(m_measure_information.locate_x, m_measure_information.locate_y);
         rotated_rect.angle = m_measure_information.locate_theta;
+        float ext_length=720;
+        float robot_width=2650.0;
         if (m_measure_information.locate_theta > 0 && m_measure_information.locate_theta <= 90) {
-            rotated_rect.size.height = m_measure_information.locate_length;
-            rotated_rect.size.width = m_measure_information.locate_width;
+            rotated_rect.size.height = m_measure_information.locate_length+ext_length*2.0;
+            rotated_rect.size.width = robot_width;
         }
         else {
-            rotated_rect.size.height = m_measure_information.locate_width;
-            rotated_rect.size.width = m_measure_information.locate_length;
+            rotated_rect.size.height = robot_width;
+            rotated_rect.size.width = m_measure_information.locate_length+ext_length*2.0;
         }
-        code = mp_verify_tool->verify(rotated_rect, false);
+        code = mp_verify_tool->verify(rotated_rect,m_measure_information.locate_hight, false);
         m_measure_information.locate_correct = (code == SUCCESS);
         return code;
 

verify/Terminal_region_limit.cpp

@@ -0,0 +1,46 @@
+//
+// Created by zx on 2020/1/16.
+//
+
+#include "Terminal_region_limit.h"
+
+Terminal_region_limit::Terminal_region_limit(Railing* left_railing,Railing* right_railing)
+{
+    mp_left_railing=left_railing;
+    mp_right_railing=right_railing;
+}
+Error_manager Terminal_region_limit::verify(cv::RotatedRect rect)
+{
+    if(mp_right_railing==NULL || mp_left_railing==NULL)
+    {
+        return Error_manager(PARAMETER_ERROR,NORMAL,"terminal left or right railing is null");
+    }
+    Error_manager code;
+    bool tb_left_error=false;
+    bool tb_right_error=false;
+    code=mp_left_railing->verify(rect);
+    if(code!=SUCCESS)
+    {
+        //左边栏杆碰撞
+        tb_left_error=true;
+    }
+    code=mp_right_railing->verify(rect);
+    if(code!=SUCCESS)
+    {
+        //右边栏杆碰撞
+        tb_right_error=true;
+    }
+    if(tb_left_error && tb_right_error)
+    {
+        return Error_manager(HARDWARE_LIMIT_TERMINAL_LR_ERROR,NORMAL,"terminal left and right railing error");
+    }
+    if(tb_left_error)
+    {
+        return Error_manager(HARDWARE_LIMIT_TERMINAL_LEFT_ERROR,NORMAL,"terminal left railing error");
+    }
+    if(tb_right_error)
+    {
+        return Error_manager(HARDWARE_LIMIT_TERMINAL_RIGHT_ERROR,NORMAL,"terminal right railing error");
+    }
+    return SUCCESS;
+}

verify/Terminal_region_limit.h

@@ -0,0 +1,25 @@
+//
+// Created by zx on 2020/1/16.
+//
+
+#ifndef TERMINAL_REGION_LIMIT_H
+#define TERMINAL_REGION_LIMIT_H
+#include "Railing.h"
+
+class Terminal_region_limit
+{
+    Terminal_region_limit(Railing* left_railing,Railing* right_railing);
+    /*
+     * 检验是否碰撞左右栏杆,
+     * 返回结果:左边碰撞,右边碰撞,左右都碰撞,正确
+     */
+    Error_manager verify(cv::RotatedRect rect);
+protected:
+    //左边栏杆
+    Railing*                     mp_left_railing;
+    //右边栏杆
+    Railing*                     mp_right_railing;
+};
+
+
+#endif //TERMINAL_REGION_LIMIT_H

verify/Verify_result.cpp

@@ -3,7 +3,7 @@
 //
 
 #include "Verify_result.h"
-
+#include <glog/logging.h>
 
 /*
      * 构造函数
@@ -101,4 +101,70 @@ Error_manager Verify_result::verify(cv::RotatedRect rotate_rect,float height,boo
         }
     }
     return SUCCESS;
+}
+
+/*
+     * 检验硬件限制
+     * rotate_rect:待检验的旋转矩形
+     * height:输入高度
+     * terminal_id:终端编号,终端对应的左右栏杆号为: id,id+1
+     */
+Error_manager Verify_result::verify(cv::RotatedRect rotate_rect,int terminal_id,int& code)
+{
+    cv::Point2f points[4];
+    rotate_rect.points(points);
+    char buf[255]={0};
+    for(int i=0;i<4;++i)
+    {
+        sprintf(buf+strlen(buf),"(%.1f %.1f)  ",points[i].x,points[i].y);
+    }
+    LOG(WARNING)<<"-----------------------------  :"<<buf;
+//    LOG(INFO)<<"verify   input  : "<<this;
+    code=0x000000;
+    //第一步,检验边界
+    float minx=m_hardware_parameter.min_x();
+    float maxx=m_hardware_parameter.max_x();
+    float miny=m_hardware_parameter.min_y();
+    float maxy=m_hardware_parameter.max_y();
+    float center_x=rotate_rect.center.x;
+    float center_y=rotate_rect.center.y;
+
+    //前超界
+    if(center_y<miny)
+    {
+        code|=LIMIT_FRONT_ERROR;
+    }
+    //后超界
+    if(center_y>maxy)
+    {
+        code|=LIMIT_BACK_ERROR;
+    }
+    ////第二步,根据id,检验左右栏杆
+    int left_id=terminal_id;
+    int right_id=terminal_id+1;
+    if(left_id<m_hardware_parameter.railing_parameter_size()&&left_id>=0
+    &&right_id<m_hardware_parameter.railing_parameter_size()&&right_id>=0)
+    {
+        Hardware_limit::Railing railing_left_parameter=m_hardware_parameter.railing_parameter(left_id);
+        Railing* tp_left_railing=new Railing(railing_left_parameter.pa(),railing_left_parameter.pb(),railing_left_parameter.pc(),
+                                             railing_left_parameter.railing_width());
+        Hardware_limit::Railing railing_right_parameter=m_hardware_parameter.railing_parameter(left_id);
+        Railing* tp_right_railing=new Railing(railing_right_parameter.pa(),railing_right_parameter.pb(),railing_right_parameter.pc(),
+                                              railing_right_parameter.railing_width());
+
+        if(tp_left_railing->verify(rotate_rect)!=SUCCESS)
+        {
+            code|=LIMIT_LEFT_ERROR;
+        }
+        if(tp_right_railing->verify(rotate_rect)!=SUCCESS)
+        {
+            code|=LIMIT_RIGHT_ERROR;
+        }
+        delete tp_left_railing;
+        delete tp_right_railing;
+    }
+//    LOG(INFO)<<"verify   end";
+    if(code!=0x00000000)
+        return ERROR;
+    return SUCCESS;
 }

verify/Verify_result.h

@@ -7,12 +7,18 @@
 #include "hardware_limit.pb.h"
 #include "Railing.h"
 
+
 /*
  * 硬件限制检验
  * 包括旋转矩形是否会碰撞栏杆,旋转矩形中心是否在plc运动范围内
  */
 class Verify_result
 {
+public:
+#define LIMIT_FRONT_ERROR   0x000001
+#define LIMIT_BACK_ERROR    0x000002
+#define LIMIT_LEFT_ERROR    0x000004
+#define LIMIT_RIGHT_ERROR   0x000008
 public:
     /*
      * 构造函数
@@ -27,6 +33,16 @@ public:
      */
     Error_manager verify(cv::RotatedRect rotate_rect,float height,bool verify_vertex=true);
 
+    /*
+     * 检验硬件限制
+     * rotate_rect:待检验的旋转矩形
+     * height:输入高度
+     * terminal_id:终端编号,终端对应的左右栏杆号为: id,id+1
+     * code:返回超界状态(前后左右,按位或运算)
+     * 主要用于电子围栏,检验栏杆及前后
+     */
+    Error_manager verify(cv::RotatedRect rotate_rect,int terminal_id,int& code);
+
 private:
     Hardware_limit::Hardware_parameter          m_hardware_parameter;
 };

wj_lidar/fence_controller.cpp

@@ -81,7 +81,7 @@ Error_manager Fence_controller::initialize(wj::wjManagerParams params)
     // init region_detector instances
     for (int j = 0; j < m_wj_manager_param.regions_size(); ++j)
     {
-        m_region_workers_vector.push_back(new Region_worker(j, m_wj_manager_param.regions(j)));
+        m_region_workers_vector.push_back(new Region_worker(j, m_wj_manager_param.regions(j), mp_verify_result_tool));
     }
     LOG(INFO) << "created wj lidars and region workers";
 
@@ -191,11 +191,10 @@ Error_manager Fence_controller::get_cloud(pcl::PointCloud<pcl::PointXYZ>::Ptr &c
     // LOG(INFO) << "try to get cloud";
     if (!mb_initialized)
         return Error_manager(Error_code::WJ_MANAGER_UNINITIALIZED);
-    
-    m_cloud_mutex.lock();
+
+    std::lock_guard<std::mutex> t_lck(m_cloud_mutex);
     // LOG(INFO) << "get cloud check cloud size";
     if (mp_merged_cloud->size() <= 0){
-        m_cloud_mutex.unlock();
         return Error_manager(Error_code::WJ_MANAGER_EMPTY_CLOUD);
     }
     
@@ -203,7 +202,6 @@ Error_manager Fence_controller::get_cloud(pcl::PointCloud<pcl::PointXYZ>::Ptr &c
     cloud_out->clear();
     cloud_out->operator+=(*mp_merged_cloud);
     LOG(INFO) << "cloud size: " << mp_merged_cloud->size() << ", " << cloud_out->size();
-    m_cloud_mutex.unlock();
     return Error_manager(Error_code::SUCCESS);
 }
 
@@ -395,7 +393,8 @@ void Fence_controller::cloud_merge_update(Fence_controller *fc)
     {
         // LOG(INFO) << "------- trying to update cloud ";
         // 加锁，依次获取最新点云并依次更新各区域状态
-        fc->m_cloud_mutex.lock();
+//        fc->m_cloud_mutex.lock();
+        std::lock_guard<std::mutex> t_lck(fc->m_cloud_mutex);
         fc->mp_merged_cloud->clear();
         for (int i = 0; i < fc->m_lidars_vector.size(); ++i)
         {
@@ -434,7 +433,7 @@ void Fence_controller::cloud_merge_update(Fence_controller *fc)
                 fc->m_region_workers_vector[i]->update_cloud(fc->mp_merged_cloud);
             }
         }
-        fc->m_cloud_mutex.unlock();
+//        fc->m_cloud_mutex.unlock();
     }
 }
 
@@ -533,7 +532,7 @@ void Fence_controller::wheel_msg_handling_thread(Fence_controller *fc)
                             LOG(INFO) << "--------callback find terminal------" << terminal_id;
                             double x = 0, y = 0, c = 0, wheelbase = 0, width = 0;
                             // 获取最新点云并保存到total_cloud中
-                            fc->m_cloud_mutex.lock();
+//                            fc->m_cloud_mutex.lock();
                             pcl::PointCloud<pcl::PointXYZ>::Ptr total_cloud(new pcl::PointCloud<pcl::PointXYZ>);
                             for (int i = 0; i < fc->m_lidars_vector.size(); ++i)
                             {
@@ -543,7 +542,7 @@ void Fence_controller::wheel_msg_handling_thread(Fence_controller *fc)
                                     total_cloud->operator+=(*cloud);
                                 }
                             }
-                            fc->m_cloud_mutex.unlock();
+//                            fc->m_cloud_mutex.unlock();
                             LOG(INFO) << "--------callback get cloud, size: " << total_cloud->size();
 
                             char cloud_txt_filename[255];

wj_lidar/plc_data.cpp

@@ -73,40 +73,13 @@ Plc_data *Plc_data::get_instance(std::string ip)
 /**
  * 更新区域状态
  * */
-void Plc_data::update_data(stateCode code, int id)
+void Plc_data::update_data(int state_code, int id)
 {
-    // LOG(INFO) << "plc data 更新数据";
+//     LOG(INFO) << "plc data 更新数据 id: "<<id<<", code: "<<state_code;
     const int length = 1;
     int offset = id * length;
     short data = 0;
-    switch (code)
-    {
-    case stateCode::eOk:
-        data = (short)1;
-        break;
-    case stateCode::eOutOfFrontBoundary:
-        data = (short)2;
-        break;
-    case stateCode::eOutOfBackBoundary:
-        data = (short)3;
-        break;
-    case stateCode::eOutOfLeftBoundary:
-        data = (short)4;
-        break;
-    case stateCode::eOutOfRightBoundary:
-        data = (short)5;
-        break;
-    case stateCode::eVerifyFailed:
-        data = (short)6;
-        break;
-    case stateCode::eClusterSizeError:
-        data = (short)7;
-        break;
-    case stateCode::eNoCar:
-    default:
-        data = (short)0;
-        break;
-    }
+    data = (short)state_code;
     std::lock_guard<std::mutex> lock(g_lock);
     ////判断越界, 更新数据
     if (offset >= 0 && offset + length <= MAX_REGIONS)

wj_lidar/plc_data.h

@@ -34,7 +34,7 @@ public:
     static Plc_data *get_instance(std::string ip = "");
     // static void Release();
     // 更新区域状态数据
-    void update_data(stateCode code, int id);
+    void update_data(int state_code, int id);
     // plc更新线程
     static void plc_update_thread(Plc_data *p);
     // 获取plc实时状态

wj_lidar/region_detect.cpp

@@ -307,8 +307,13 @@ Error_manager Region_detector::clustering(pcl::PointCloud<pcl::PointXYZ>::Ptr cl
 
         float center_x = sumX / float(seg_clouds[i]->size());
         float center_y = sumY / float(seg_clouds[i]->size());
-        corner_points.push_back(cv::Point2f(center_x, center_y));
+        corner_points.push_back(cv::Point2f(center_x*1000.0, center_y*1000.0));
     }
+    char buf[255]={0};
+    for (int k = 0; k < corner_points.size(); ++k) {
+        sprintf(buf+strlen(buf), "point %d: (%.2f, %.2f)__", k, corner_points[k].x, corner_points[k].y);
+    }
+    LOG(WARNING) << buf;
     return isRect(corner_points, print);
 }
 /**
@@ -334,7 +339,7 @@ Error_manager Region_detector::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_
 /**
  * 输出中心点、角度、轮距与宽度的四轮点云检测函数
  * */
-Error_manager Region_detector::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr &cloud_in, double &x, double &y, double &c, double &wheelbase, double &width)
+Error_manager Region_detector::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr &cloud_in, double &x, double &y, double &c, double &wheelbase, double &width, bool print)
 {
     Error_manager result = Error_manager(Error_code::SUCCESS);
     pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(pcl::PointCloud<pcl::PointXYZ>::Ptr(new pcl::PointCloud<pcl::PointXYZ>));
@@ -346,7 +351,7 @@ Error_manager Region_detector::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr &cloud
     // 2.聚类计算角点
     std::vector<cv::Point2f> corner_points;
     std::vector<pcl::PointCloud<pcl::PointXYZ>::Ptr> seg_clouds;
-    result = clustering(cloud_filtered, corner_points, seg_clouds, true);
+    result = clustering(cloud_filtered, corner_points, seg_clouds, print);
     if (result != SUCCESS)
         return result;
     // 修改原始点云为预处理后点云，并加入角点供查验
@@ -444,8 +449,7 @@ Error_manager Region_detector::detect(pcl::PointCloud<pcl::PointXYZ>::Ptr &cloud
         y_values1 /= count1;
         wheelbase = fabs(y_values1 - y_values0);
         width = fabs(min_x - max_x);
-        // std::cout << "--------detector find x min "<<min_x<<" max "<<max_x<<", y means: [" << y_values0 << ", " << y_values1 << "] -----" << std::endl;
-        LOG(INFO) << "--------detector find width, wheelbase: " << width << ", " << wheelbase << ", y means: [" << y_values0 << ", " << y_values1 << "] -----";
+//        LOG(INFO) << "--------detector find width, wheelbase: " << width << ", " << wheelbase << ", y means: [" << y_values0 << ", " << y_values1 << "] -----";
         cloud_in->points.push_back(pcl::PointXYZ(min_x, y, 0.0));
         cloud_in->points.push_back(pcl::PointXYZ(max_x, y, 0.0));
         cloud_in->points.push_back(pcl::PointXYZ(x, y_values0, 0.0));

wj_lidar/region_detect.h

@@ -55,7 +55,7 @@ public:
     // 检测传入点云是否为合法四轮
     Error_manager detect(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_in);
     // 检测传入点云，识别为四类返回中心点、角度、轮距与宽度
-    Error_manager detect(pcl::PointCloud<pcl::PointXYZ>::Ptr &cloud_in, double &x, double &y, double &c, double &wheelbase, double &width);
+    Error_manager detect(pcl::PointCloud<pcl::PointXYZ>::Ptr &cloud_in, double &x, double &y, double &c, double &wheelbase, double &width, bool print=true);
     // 获得区域id
     int get_region_id();
 

wj_lidar/region_worker.cpp

@@ -7,10 +7,15 @@
 /**
  * 有参构造
  * */
-Region_worker::Region_worker(int id, wj::Region region):
+Region_worker::Region_worker(int id, wj::Region region, Verify_result* verify_handle):
 m_read_code_count(0),
-mb_cloud_updated(0)
+mb_cloud_updated(0),
+mp_verify_handle(0)
 {
+    if(verify_handle!= nullptr)
+    {
+        mp_verify_handle = verify_handle;
+    }
     m_update_plc_time = std::chrono::steady_clock::now();
     m_cloud = pcl::PointCloud<pcl::PointXYZ>::Ptr(new pcl::PointCloud<pcl::PointXYZ>);
     m_detector = new Region_detector(id, region);
@@ -45,7 +50,6 @@ Region_worker::~Region_worker()
  * */
 int Region_worker::get_id()
 {
-    std::lock_guard<std::mutex> lck(m_mutex);
     if (m_detector)
     {
         return m_detector->get_region_id();
@@ -108,31 +112,54 @@ void Region_worker::detect_loop(Region_worker *worker)
     // 2.检测与更新循环
     while (!worker->m_cond_exit.WaitFor(200))
     {
-        // LOG(INFO) << "worker detect loop";
-        stateCode code = stateCode::eNoCar;
-        std::lock_guard<std::mutex> lck(worker->m_mutex);
+//        LOG(INFO) << "worker detect loop";
         // 检查当前状态
         if (worker->mb_cloud_updated)
         {
+            std::lock_guard<std::mutex> lck(worker->m_mutex);
+            int code = REGION_WORKER_VERIFY_OK;
             worker->mb_cloud_updated = false;
-            // LOG(INFO) << "worker detect loop detect";
-            Error_manager result = worker->m_detector->detect(worker->m_cloud);
-            // LOG(INFO) << "worker detect loop end detect";
+            double x,y,angle,wheelbase,width;
+            Error_manager result = worker->m_detector->detect(worker->m_cloud, x, y, angle, wheelbase, width, true);
+            if(worker->mp_verify_handle == nullptr)
+            {
+                code = REGION_WORKER_NULL_POINTER;
+                LOG(WARNING) << "verify handle null pointer";
+                continue;
+            }
+//            LOG(INFO) << "worker detect loop end detect";
             if (result == WJ_REGION_EMPTY_CLOUD)
             {
-                code = stateCode::eNoCar;
+                code = REGION_WORKER_EMPTY_SPACE;
             }
             else if (result == SUCCESS)
             {
-                code = stateCode::eOk;
+                cv::RotatedRect car_border;
+                car_border.center = cv::Point2f(1000.0*x,1000.0*y);
+                car_border.angle = angle;
+                const int default_car_width = 2650;
+                const int ext_length = 700;
+                car_border.size.width = default_car_width;
+                car_border.size.height = wheelbase+ext_length*2;
+                int verify_return_code = 0;
+                int terminal_id=worker->get_id();
+                Error_manager verify_error_code = worker->mp_verify_handle->verify(car_border, terminal_id, verify_return_code);
+//                Error_manager verify_error_code = SUCCESS;
+                if(verify_error_code == SUCCESS) {
+                    code = REGION_WORKER_VERIFY_OK;
+                    LOG(INFO) << "region worker verify ok";
+                }else{
+                    code |= verify_return_code;
+                    LOG(WARNING) << "region worker verify result: " << code;
+                }
             }
             else if (result == WJ_REGION_CLUSTER_SIZE_ERROR)
             {
-                code = stateCode::eClusterSizeError;
+                code = REGION_WORKER_CLUSTER_SIZE_ERROR;
             }
             else
             {
-                code = stateCode ::eVerifyFailed;
+                code = REGION_WORKER_OTHER_ERROR;
             }
             // LOG(INFO) << "worker detect loop 000";
             // 判断与上次读取是否相同，并计数
@@ -143,14 +170,16 @@ void Region_worker::detect_loop(Region_worker *worker)
             worker->m_last_read_code = code;
             worker->m_read_code_count += 1;
 
+            if(worker->get_id() == 4) {
+                LOG(WARNING) << "worker id: " << worker->get_id()<<" code: "<<code;
+            }
             // 写入plc，加入写入频率限制
             int duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - worker->m_update_plc_time).count();
-            // LOG(INFO) << "worker detect loop 111";
             Plc_data *p = Plc_data::get_instance();
-            // LOG(INFO) << "worker detect loop 222";
             // 写入间隔必须超过500ms，当前状态不同于上次写入状态，且该状态已连续读到三次
             if (p!=0 && duration > 500 && worker->m_last_sent_code != worker->m_last_read_code && worker->m_read_code_count > 3)
             {
+                worker->m_last_sent_code = worker->m_last_read_code;
                 p->update_data(code, worker->m_detector->get_region_id());
                 worker->m_update_plc_time = std::chrono::steady_clock::now();
             }

wj_lidar/region_worker.h

@@ -12,17 +12,23 @@
 #include <iostream>
 #include <atomic>
 #include <chrono>
-#include "define.h"
 #include "../error_code/error_code.h"
+#include "../verify/Verify_result.h"
 
 /**
  * 区域功能类，负责自动检测区域状态并更新到plc
  * */
 class Region_worker
 {
+public:
+#define REGION_WORKER_VERIFY_OK 0x0000
+#define REGION_WORKER_EMPTY_SPACE 0x0010
+#define REGION_WORKER_CLUSTER_SIZE_ERROR 0x0020
+#define REGION_WORKER_OTHER_ERROR 0x0040
+#define REGION_WORKER_NULL_POINTER 0x0080
 public:
     // 有参构造
-    Region_worker(int id, wj::Region region);
+    Region_worker(int id, wj::Region region, Verify_result* verify_handle);
     // 析构函数
     ~Region_worker();
     // 外部调用传入新点云
@@ -39,13 +45,15 @@ private:
     pcl::PointCloud<pcl::PointXYZ>::Ptr m_cloud;             // 自动区域检测用点云
     std::atomic<bool> mb_cloud_updated;                      // 点云更新指标
     std::chrono::steady_clock::time_point m_update_plc_time; // 更新plc状态时刻
-    stateCode m_last_sent_code;                              // 上次写入plc的状态值
-    stateCode m_last_read_code;                              // 上次检查获得的状态值
+    int m_last_sent_code;                              // 上次写入plc的状态值
+    int m_last_read_code;                              // 上次检查获得的状态值
     std::atomic<int> m_read_code_count;                      // 检查后重复获取相同状态值次数
 
     StdCondition m_cond_exit;     // 系统退出标志
     std::thread *m_detect_thread; // 实时检测线程
     std::mutex m_mutex;           // 点云互斥锁
+
+    Verify_result* mp_verify_handle; // 边缘检测
 };
 
 #endif //REGION_WORKER_H