更新error_code代码，解决 operator=崩溃

error_code/error_code.cpp

@@ -15,45 +15,38 @@ Error_manager::Error_manager()
 {
     m_error_code = SUCCESS;
     m_error_level = NORMAL;
-    pm_error_description = 0;
-    m_description_length = 0;
-    return ;
 }
 //拷贝构造
 Error_manager::Error_manager(const Error_manager & error_manager)
 {
     this->m_error_code = error_manager.m_error_code;
     this->m_error_level = error_manager.m_error_level;
-    pm_error_description = NULL;
-    m_description_length = 0;
-    reallocate_memory_and_copy_string(error_manager.pm_error_description, error_manager.m_description_length);
+	this->m_error_description=error_manager.m_error_description;
     return ;
 }
 //赋值构造
 Error_manager::Error_manager(Error_code error_code, Error_level error_level,
-    const char* p_error_description, int description_length)
+    const char* p_error_description)
 {
     m_error_code = error_code;
     m_error_level = error_level;
-    pm_error_description = NULL;
-    m_description_length = 0;
-    reallocate_memory_and_copy_string(p_error_description, description_length);
-    return ;
+    if(p_error_description!= nullptr)
+	{
+		m_error_description=std::string(p_error_description);
+	}
+	return ;
 }
 //赋值构造
 Error_manager::Error_manager(Error_code error_code, Error_level error_level , std::string & error_aggregate_string)
 {
     m_error_code = error_code;
     m_error_level = error_level;
-    pm_error_description = NULL;
-    m_description_length = 0;
-    reallocate_memory_and_copy_string(error_aggregate_string);
-    return ;
+    m_error_description=error_aggregate_string;
+	return ;
 }
 //析构函数
 Error_manager::~Error_manager()
 {
-    free_description();
 }
 
 //初始化
@@ -62,44 +55,49 @@ void Error_manager::error_manager_init()
     error_manager_clear_all();
     return;
 }
-//初始化
-void Error_manager::error_manager_init(Error_code error_code, Error_level error_level, const char* p_error_description, int description_length)
+void Error_manager::error_manager_init(Error_code error_code, Error_level error_level, const char* p_error_description)
 {
     m_error_code = error_code;
     m_error_level = error_level;
-    reallocate_memory_and_copy_string(p_error_description, description_length);
-    return ;
+	if(p_error_description!= nullptr)
+	{
+		m_error_description=std::string(p_error_description);
+	}
+	return ;
 }
 //初始化
 void Error_manager::error_manager_init(Error_code error_code, Error_level error_level , std::string & error_aggregate_string)
 {
     m_error_code = error_code;
     m_error_level = error_level;
-    reallocate_memory_and_copy_string(error_aggregate_string);
+    m_error_description=error_aggregate_string;
     return ;
 }
 //重置
-void Error_manager::error_manager_reset(Error_code error_code, Error_level error_level, const char* p_error_description, int description_length)
+void Error_manager::error_manager_reset(Error_code error_code, Error_level error_level, const char* p_error_description)
 {
     m_error_code = error_code;
     m_error_level = error_level;
-    reallocate_memory_and_copy_string(p_error_description, description_length);
-    return ;
+	if(p_error_description!= nullptr)
+	{
+		m_error_description=std::string(p_error_description);
+	}
+	return ;
 }
 //重置
 void Error_manager::error_manager_reset(Error_code error_code, Error_level error_level , std::string & error_aggregate_string)
 {
     m_error_code = error_code;
     m_error_level = error_level;
-    reallocate_memory_and_copy_string(error_aggregate_string);
-    return ;
+    m_error_description=error_aggregate_string;
+	return;
 }
 //重置
 void Error_manager::error_manager_reset(const Error_manager & error_manager)
 {
     this->m_error_code = error_manager.m_error_code;
     this->m_error_level = error_manager.m_error_level;
-    reallocate_memory_and_copy_string(error_manager.pm_error_description, error_manager.m_description_length);
+	this->m_error_description=error_manager.m_error_description;
     return ;
 }
 //清除所有内容
@@ -107,24 +105,27 @@ void Error_manager::error_manager_clear_all()
 {
     m_error_code = SUCCESS;
     m_error_level = NORMAL;
-    free_description();
+	m_error_description.clear();
+	return;
 }
 
 //重载=
 Error_manager& Error_manager::operator=(const Error_manager & error_manager)
 {
     error_manager_reset(error_manager);
+	return *this;
 }
 //重载=，支持Error_manager和Error_code的直接转化，会清空错误等级和描述
 Error_manager& Error_manager::operator=(Error_code error_code)
 {
     error_manager_clear_all();
     set_error_code(error_code);
+	return *this;
 }
 //重载==
 bool Error_manager::operator==(const Error_manager & error_manager)
 {
-    is_equal_error_manager(error_manager);
+	return is_equal_error_manager(error_manager);
 }
 //重载==，支持Error_manager和Error_code的直接比较
 bool Error_manager::operator==(Error_code error_code)
@@ -142,7 +143,7 @@ bool Error_manager::operator==(Error_code error_code)
 //重载!=
 bool Error_manager::operator!=(const Error_manager & error_manager)
 {
-    ! is_equal_error_manager(error_manager);
+	return (! is_equal_error_manager(error_manager));
 }
 //重载!=，支持Error_manager和Error_code的直接比较
 bool Error_manager::operator!=(Error_code error_code)
@@ -174,48 +175,28 @@ Error_level Error_manager::get_error_level()
     return m_error_level;
 }
 //获取错误描述的指针，（浅拷贝）
-char* Error_manager::get_error_description()
+std::string Error_manager::get_error_description()
 {
-    if(pm_error_description== nullptr)
-        return "";
-    return pm_error_description;
+    return m_error_description;
 }
 
 //复制错误描述，（深拷贝）
 //output：p_error_description     错误描述的字符串指针，不可以为NULL，必须要有实际的内存
 //output:description_length      错误描述的字符串长度，不可以为0，长度最好足够大，一般256即可。
-void Error_manager::copy_error_description(const char* p_error_description, int description_length)
+void Error_manager::copy_error_description(const char* p_error_description)
 {
-    if(p_error_description != NULL && pm_error_description != NULL)
+    if(p_error_description != NULL)
     {
-        char *pt_source = (char *)p_error_description;
-        char* pt_destination = pm_error_description;
-
-        int t_length_min = m_description_length;
-        if(m_description_length > description_length)
-        {
-            t_length_min = description_length;
-        }
-
-        for(int i=0;i<t_length_min; i++)
-        {
-            *pt_destination = *pt_source;
-            pt_destination++;
-            pt_source++;
-        }
+        m_error_description=std::string(p_error_description);
     }
-
-    return;
+	return;
 }
 //复制错误描述，（深拷贝）
 //output：error_description_string     错误描述的string
 void Error_manager::copy_error_description(std::string & error_description_string)
 {
-    if( (!error_description_string.empty() ) && pm_error_description != NULL)
-    {
-        error_description_string = pm_error_description;
-    }
-    return;
+    m_error_description=error_description_string;
+	return;
 }
 
 //设置错误码
@@ -249,64 +230,33 @@ void Error_manager::set_error_level_location(Error_level error_level)
     return;
 }
 //设置错误描述
-void Error_manager::set_error_description(const char* p_error_description, int description_length)
+void Error_manager::set_error_description(const char* p_error_description)
 {
-    reallocate_memory_and_copy_string(p_error_description, description_length);
-    return ;
+	if(p_error_description != NULL)
+	{
+		m_error_description=std::string(p_error_description);
+	}
+	return;
 }
 //设置错误描述
 void Error_manager::set_error_description(std::string & error_description_string)
 {
-    reallocate_memory_and_copy_string(error_description_string);
-    return ;
+	m_error_description = error_description_string;
+	return ;
 }
 
 //尾部追加错误描述
-void Error_manager::add_error_description(const char* p_error_description, int description_length)
+void Error_manager::add_error_description(const char* p_error_description)
 {
     if(p_error_description !=NULL)
     {
-        char* pt_description_front = pm_error_description;
-        int t_description_front_length = m_description_length;
-        char* pt_description_back = (char *)p_error_description;
-        int t_description_back_length = 0;
-
-        if(description_length == 0)
-        {
-            t_description_back_length = 0;
-            while (*pt_description_back != '\0')
-            {
-                t_description_back_length++;
-                pt_description_back++;
-            }
-            t_description_back_length++;
-            pt_description_back = (char *)p_error_description;
-        }
-        else
-        {
-            t_description_back_length = description_length;
-        }
-
-        int t_description_new_length = t_description_front_length + 5 + t_description_back_length - 1;
-        char* pt_description_new =  (char*) malloc(t_description_new_length );
-
-        sprintf(pt_description_new, "%s ### %s", pt_description_front, pt_description_back);
-        free_description();
-        pm_error_description = pt_description_new;
-        m_description_length = t_description_new_length;
+        m_error_description+=std::string(p_error_description);
     }
-    return ;
 }
 //尾部追加错误描述
 void Error_manager::add_error_description(std::string & error_description_string)
 {
-    if( ! error_description_string.empty() )
-    {
-        std::string t_description_string = pm_error_description ;
-        t_description_string += (" ### "+ error_description_string);
-
-        reallocate_memory_and_copy_string(t_description_string);
-    }
+    m_error_description+=error_description_string;
 }
 
 //比较错误是否相同，
@@ -338,26 +288,20 @@ void Error_manager::compare_and_cover_error(const Error_manager & error_manager)
     else
     {
         Error_manager t_error_manager_new;
-        char* pt_string_inside = NULL;
-        int t_string_inside_length = 0;
+        std::string pt_string_inside ;
         if(this->m_error_level < error_manager.m_error_level)
         {
-            t_string_inside_length = ERROR_NAMAGER_TO_STRING_FRONT_LENGTH + this->m_description_length;
-            pt_string_inside = (char*)malloc(t_string_inside_length);
-            translate_error_to_string(pt_string_inside, t_string_inside_length);
-
+            translate_error_to_string(pt_string_inside);
             error_manager_reset(error_manager);
-            add_error_description(pt_string_inside,t_string_inside_length);
+            add_error_description(pt_string_inside);
         }
         else
         {
-            t_string_inside_length = ERROR_NAMAGER_TO_STRING_FRONT_LENGTH + error_manager.m_description_length;
-            pt_string_inside = (char*)malloc(t_string_inside_length);
-			((Error_manager & )error_manager).translate_error_to_string(pt_string_inside, t_string_inside_length);
-
-            add_error_description(pt_string_inside,t_string_inside_length);
+			((Error_manager&)error_manager).translate_error_to_string(pt_string_inside);
+            add_error_description(pt_string_inside);
         }
     }
+	return;
 }
 //比较并覆盖错误，讲低级错误转为字符串存放于描述中，
 //如果错误相同，则保留this的，将输入参数转入描述。
@@ -369,90 +313,48 @@ void Error_manager::compare_and_cover_error( Error_manager * p_error_manager)
 	}
 	else if (p_error_manager->m_error_code == SUCCESS)
 	{
-		//
+		return;
 	}
 	else
 	{
 		Error_manager t_error_manager_new;
-		char* pt_string_inside = NULL;
-		int t_string_inside_length = 0;
+		std::string pt_string_inside;
 		if(this->m_error_level < p_error_manager->m_error_level)
 		{
-			t_string_inside_length = ERROR_NAMAGER_TO_STRING_FRONT_LENGTH + this->m_description_length;
-			pt_string_inside = (char*)malloc(t_string_inside_length);
-			translate_error_to_string(pt_string_inside, t_string_inside_length);
-
+			translate_error_to_string(pt_string_inside);
 			error_manager_reset(*p_error_manager);
-			add_error_description(pt_string_inside,t_string_inside_length);
+			add_error_description(pt_string_inside);
 		}
 		else
 		{
-			t_string_inside_length = ERROR_NAMAGER_TO_STRING_FRONT_LENGTH + p_error_manager->m_description_length;
-			pt_string_inside = (char*)malloc(t_string_inside_length);
-			p_error_manager->translate_error_to_string(pt_string_inside, t_string_inside_length);
-
-			add_error_description(pt_string_inside,t_string_inside_length);
+			p_error_manager->translate_error_to_string(pt_string_inside);
+			add_error_description(pt_string_inside);
 		}
 	}
 }
 
-//将所有的错误信息，格式化为字符串，用作日志打印。
-//output：p_error_description     错误汇总的字符串指针，不可以为NULL，必须要有实际的内存
-//output:description_length      错误汇总的字符串长度，不可以为0，长度最好足够大，一般256即可。
-void Error_manager::translate_error_to_string(char* p_error_aggregate, int aggregate_length )
-{
-    char t_string_array[ERROR_NAMAGER_TO_STRING_FRONT_LENGTH] = {0};
-    char* pt_index_front = t_string_array;
-    char* pt_index_back = pm_error_description;
-    char* pt_index = p_error_aggregate;
 
-    sprintf(t_string_array, "error_code:0x%08x, error_level:%02d, error_description:", m_error_code , m_error_level );
-
-    int t_length_min = m_description_length + ERROR_NAMAGER_TO_STRING_FRONT_LENGTH -1;
-    if(t_length_min > aggregate_length)
-    {
-        t_length_min = aggregate_length;
-    }
-
-    for(int i=0;i<t_length_min; i++)
-    {
-        if(i < ERROR_NAMAGER_TO_STRING_FRONT_LENGTH -1)
-        {
-            *pt_index = *pt_index_front;
-            pt_index++;
-            pt_index_front++;
-        }
-        else
-        {
-            *pt_index = *pt_index_back;
-            pt_index++;
-            pt_index_back++;
-        }
-    }
-}
 //output：error_description_string     错误汇总的string
 void Error_manager::translate_error_to_string(std::string & error_aggregate_string)
 {
-    char t_string_array[ERROR_NAMAGER_TO_STRING_FRONT_LENGTH] = {0};
-    sprintf(t_string_array, "error_code:0x%08x, error_level:%02d, error_description:", m_error_code , m_error_level );
+    char t_string_array[255] = {0};
+    sprintf(t_string_array, "error_code:0x%08x, error_level:%02d, error_description:",
+            m_error_code , m_error_level);
 
     error_aggregate_string = t_string_array ;
-    if(pm_error_description != NULL)
-    {
-        error_aggregate_string += pm_error_description;
-    }
-    else
-    {
-        //error_aggregate_string += "NULL";
-    }
+	error_aggregate_string+= m_error_description;
+	return;
 }
 //错误码转字符串的简易版，可支持cout<<
 //return     错误汇总的string
 std::string Error_manager::to_string()
 {
-    std::string t_string;
-    translate_error_to_string(t_string);
-    return t_string;
+	char t_string_array[255] = {0};
+	sprintf(t_string_array, "error_code:0x%08x, error_level:%02d, error_description:",
+            m_error_code , m_error_level);
+    std::string error_aggregate_string = t_string_array ;
+	error_aggregate_string+= m_error_description;
+	return error_aggregate_string;
 }
 
 
@@ -461,12 +363,6 @@ std::string Error_manager::to_string()
 //释放错误描述的内存，
 void Error_manager::free_description()
 {
-    if(pm_error_description != NULL)
-    {
-        free (pm_error_description);
-        pm_error_description = NULL;
-    }
-    m_description_length = 0;
 }
 
 //重新分配错误描述的内存，并从外部拷贝新的（深拷贝）
@@ -474,40 +370,6 @@ void Error_manager::free_description()
 //input:description_length      错误描述的字符串长度，如果为0，则从p_error_description里面获取有效的长度
 void Error_manager::reallocate_memory_and_copy_string(const char* p_error_description, int description_length)
 {
-    free_description();
-
-    if(p_error_description != NULL)
-    {
-        char* pt_source = (char *)p_error_description;
-        char* pt_destination = NULL;
-
-        if(description_length == 0)
-        {
-            m_description_length = 0;
-            while (*pt_source != '\0')
-            {
-                m_description_length++;
-                pt_source++;
-            }
-            m_description_length++;
-            pt_source = (char *)p_error_description;
-        }
-        else
-        {
-            m_description_length = description_length;
-        }
-
-        pm_error_description =  (char*) malloc(m_description_length );
-        pt_destination = pm_error_description;
-
-        for(int i=0;i<m_description_length; i++)
-        {
-            *pt_destination = *pt_source;
-            pt_destination++;
-            pt_source++;
-        }
-    }
-
     return;
 }
 
@@ -516,16 +378,7 @@ void Error_manager::reallocate_memory_and_copy_string(const char* p_error_descri
 //input：error_aggregate_string     错误描述的string
 void Error_manager::reallocate_memory_and_copy_string(std::string & error_aggregate_string)
 {
-    free_description();
-
-    if( ! error_aggregate_string.empty())
-    {
-        m_description_length = error_aggregate_string.length()+1;
-
-        pm_error_description =  (char*) malloc( m_description_length );
-
-        strcpy(pm_error_description ,   error_aggregate_string.c_str()  );
-    }
+    return;
 }
 
 

error_code/error_code.h

@@ -1,4 +1,15 @@
 
+//20211125
+
+#define MAIN_TEST 1
+//#define PROCESS_TEST 1
+//#define TIME_TEST 1
+
+#define PLC_S7_COMMUNICATION 1	//是否开启plc的通信
+#define WAIT_PLC_RESPONSE 1		//是否等待plc的答复
+//#define MEASURE_TO_PLC_CORRECTION 1		//修正感测数据
+
+
 //Error_code是错误码的底层通用模块，
 //功能：用作故障分析和处理。
 
@@ -48,21 +59,24 @@ enum Error_code
 
 
     //基本错误码，
-    FAILED                          = 0x00000001,//失败
-    ERROR                           = 0x00000002,//错误
-    WARNING                         = 0x00000003,//警告
+    ERROR                           = 0x00000001,//错误
     PARTIAL_SUCCESS                 = 0x00000002,//部分成功
+    WARNING                         = 0x00000003,//警告
+    FAILED                          = 0x00000004,//失败
 
-
-    NO_DATA                         = 0x00000010,//没有数据，传入参数容器内部没有数据时，
+    NODATA                          = 0x00000010,//没有数据，传入参数容器内部没有数据时，
 	INVALID_MESSAGE					= 0x00000011, //无效的消息,
-    RESPONSE_TIMEOUT                = 0x00000012,
+	PARSE_FAILED					= 0x00000012,//解析失败
+
     PAUSE                           = 0x00000013,   //急停
     TASK_CANCEL                     = 0x00000014,   //任务取消
 
     DISCONNECT                      = 0x00000020,   //通讯中断/断开连接
     UNKNOW_STATU                    = 0x00000021,   //未知状态
 
+    TASK_TIMEOVER					= 0x00000020,//任务超时
+	RESPONSE_TIMEOUT                = 0x00000021,//答复超时
+
     POINTER_IS_NULL                 = 0x00000101,//空指针
     PARAMETER_ERROR                 = 0x00000102,//参数错误，传入参数不符合规范时，
     POINTER_MALLOC_FAIL             = 0x00000103,//手动分配内存失败
@@ -71,6 +85,9 @@ enum Error_code
 
 	CONTAINER_IS_TERMINATE			= 0x00000301,//容器被终止
 
+
+
+
 //    错误码的规范，
 //    错误码是int型，32位，十六进制。
 //    例如0x12345678
@@ -81,6 +98,142 @@ enum Error_code
 //    注：错误码的制定从1开始，不要从0开始，
 //        0用作错误码的基数，用来位运算，来判断错误码的范围。
 
+
+
+
+
+
+
+//    laser扫描模块
+    LASER_ERROR_BASE                = 0x01000000,
+
+//    laser_base基类
+	LASER_BASE_ERROR_BASE			= 0x01010000,
+    LASER_TASK_PARAMETER_ERROR      = 0x01010001,   //雷达基类模块, 任务输入参数错误
+    LASER_CONNECT_FAILED,							//雷达基类模块, 连接失败
+	LASER_START_FAILED,								//雷达基类模块, 开始扫描失败
+	LASER_CHECK_FAILED,								//雷达基类模块, 检查失败
+	LASER_STATUS_BUSY,								//雷达基类模块, 状态正忙
+	LASER_STATUS_ERROR,								//雷达基类模块, 状态错误
+	LASER_TASK_OVER_TIME,							//雷达基类模块, 任务超时
+	LASER_QUEUE_ERROR,								//雷达基类模块, 数据缓存错误
+
+
+//   livox  大疆雷达
+    LIVOX_ERROR_BASE                = 0x01020000,
+    LIVOX_START_FAILE,								//livox模块，开始扫描失败
+	LIVOX_TASK_TYPE_ERROR,							//livox模块，任务类型错误
+	lIVOX_CANNOT_PUSH_DATA,							//livox模块，不能添加扫描的数据
+	lIVOX_CHECK_FAILED,								//livox模块，检查失败
+	lIVOX_STATUS_BUSY,								//livox模块，状态正忙
+	lIVOX_STATUS_ERROR,								//livox模块，状态错误
+
+	//laser_manager 雷达管理模块
+	LASER_MANAGER_ERROR_BASE						= 0x01030000,
+	LASER_MANAGER_READ_PROTOBUF_ERROR,				//雷达管理模块，读取参数错误
+	LASER_MANAGER_STATUS_BUSY,						//雷达管理模块，状态正忙
+	LASER_MANAGER_STATUS_ERROR,						//雷达管理模块，状态错误
+	LASER_MANAGER_TASK_TYPE_ERROR,					//雷达管理模块，任务类型错误
+	LASER_MANAGER_IS_NOT_READY,						//雷达管理模块，不在准备状态
+	LASER_MANAGER_TASK_OVER_TIME,					//雷达管理模块，任务超时
+	LASER_MANAGER_LASER_INDEX_ERRPR,				//雷达管理模块，雷达索引错误，编号错误。
+	LASER_MANAGER_LASER_INDEX_REPEAT,				//雷达管理模块，需要扫描的雷达索引重复,可忽略的错误,提示作用
+
+//livox_driver 雷达livox驱动模块
+	LIVOX_DRIVER_ERROR_BASE							= 0x01040000,
+	LIVOX_DRIVER_SN_REPEAT,							//livox驱动模块, 雷达广播码重复
+	LIVOX_DRIVER_SN_ERROR,							//livox驱动模块, 雷达广播码错误
+	LIVOX_SKD_INIT_FAILED,							//livox驱动模块, livox_sdk初始化失败
+	LIVOX_DRIVER_NOT_READY,							//livox驱动模块, livox没有准备好.
+
+
+
+
+     //PLC error code  ...
+    PLC_ERROR_BASE                  				= 0x02010000,
+    PLC_UNKNOWN_ERROR,								//plc未知错误
+    PLC_EMPTY_TASK,									//plc任务为空
+    PLC_IP_PORT_ERROR,								//plc的ip端口错误
+    PLC_SLAVE_ID_ERROR,								//plc的身份id错误
+    PLC_CONNECTION_FAILED,							//PLC连接失败
+    PLC_READ_FAILED,								//plc读取失败
+    PLC_WRITE_FAILED,								//plc写入失败
+    PLC_NOT_ENOUGH_DATA_ERROR,						//PLC没有足够的数据错误
+
+
+
+    //locate 定位模块,
+	LOCATER_ERROR_BASE                				= 0x03000000,
+	//LASER_MANAGER 定位管理模块
+	LOCATER_MANAGER_ERROR_BASE                		= 0x03010000,
+	LOCATER_MANAGER_READ_PROTOBUF_ERROR,				//定位管理模块，读取参数错误
+	LOCATER_MANAGER_STATUS_BUSY,						//定位管理模块，状态正忙
+	LOCATER_MANAGER_STATUS_ERROR,						//定位管理模块，状态错误
+	LOCATER_MANAGER_TASK_TYPE_ERROR,					//定位管理模块，任务类型错误
+	LOCATER_MANAGER_IS_NOT_READY,						//定位管理模块，不在准备状态
+	LOCATER_MANAGER_CLOUD_MAP_ERROR,					//定位管理模块，任务输入点云map的error
+	LOCATER_MANAGER_TASK_OVER_TIME,						//定位管理模块，任务超时
+
+
+	//Locater  算法模块	
+	LOCATER_ALGORITHM_ERROR_BASE					= 0x03020000,
+	LOCATER_TASK_INIT_CLOUD_EMPTY,						//定位任务初始化点云为空
+	LOCATER_TASK_ERROR,									//定位任务错误
+	LOCATER_TASK_INPUT_CLOUD_UNINIT,					//定位任务输入点云为空
+	LOCATER_INPUT_CLOUD_EMPTY,							//定位输入点云为空
+	LOCATER_YOLO_UNINIT,								//定位yolo未初始化
+	LOCATER_POINTSIFT_UNINIT,							//定位POINTSIFT未初始化
+	LOCATER_3DCNN_UNINIT,								//定位3DCNN未初始化
+	LOCATER_INPUT_YOLO_CLOUD_EMPTY,						//定位输入yolo点云为空
+	LOCATER_Y_OUT_RANGE_BY_PLC,							//定位超出plc的限制范围
+	LOCATER_MEASURE_HEIGHT_CLOUD_UNINIT,				//定位测量高点云未初始化
+	LOCATER_MEASURE_HEIGHT_CLOUD_EMPTY,					//定位测量高点云为空
+	LOCATER_INPUT_CLOUD_UNINIT,							//定位输入点云未初始化
+
+
+    //point sift from 0x03010100-0x030101FF
+	LOCATER_SIFT_ERROR_BASE							=0x03020100,
+   	LOCATER_SIFT_INIT_FAILED,							//定位过滤模块，初始化失败
+    LOCATER_SIFT_INPUT_CLOUD_UNINIT,					//定位过滤模块，输入点云未初始化
+	LOCATER_SIFT_INPUT_CLOUD_EMPTY,						//定位过滤模块，输入点云为空
+	LOCATER_SIFT_GRID_ERROR,							//定位过滤模块，筛选网格错误
+	LOCATER_SIFT_SELECT_ERROR,							//定位过滤模块，筛选选择错误
+	LOCATER_SIFT_CLOUD_VERY_LITTLE,						//定位过滤模块，筛选点云很少
+	LOCATER_SIFT_CREATE_INPUT_DATA_FAILED,				//定位过滤模块，筛选创建输入数据失败
+	LOCATER_SIFT_PREDICT_FAILED,						//定位过滤模块，预测失败
+	LOCATER_SIFT_PREDICT_TIMEOUT,						//定位过滤模块，预测超时
+	LOCATER_SIFT_PREDICT_NO_WHEEL_POINT,				//定位过滤模块，预测结果没有车轮点云
+	LOCATER_SIFT_PREDICT_NO_CAR_POINT,					//定位过滤模块，预测结果没有车身点云
+
+    LOCATER_SIFT_FILTE_OBS_FAILED,						//定位过滤模块，过滤OBS失败
+    LOCATER_SIFT_INPUT_BOX_PARAMETER_FAILED,			//定位过滤模块，输入范围参数错误
+
+//    //yolo 
+//    LOCATER_YOLO_ERROR_BASE						=0x03020200,
+//    LOCATER_YOLO_DETECT_FAILED,
+//    LOCATER_YOLO_DETECT_NO_TARGET,
+//    LOCATER_YOLO_PARAMETER_INVALID,
+//    LOCATER_YOLO_INPUT_CLOUD_UNINIT,
+
+    //3dcnn from 0x03010300-0x030103FF
+    LOCATER_3DCNN_ERROR_BASE						=0x03020300,
+    LOCATER_3DCNN_INIT_FAILED,							//定位3DCNN模块，初始化失败
+    LOCATER_3DCNN_INPUT_CLOUD_UNINIT,					//定位3DCNN模块，输入点云未初始化
+	LOCATER_3DCNN_INPUT_CLOUD_EMPTY,					//定位3DCNN模块，输入点云为空
+	LOCATER_3DCNN_INPUT_CLOUD_MAP_ERROR,				//定位3DCNN模块，输入点云的map错误
+	LOCATER_3DCNN_PCA_OUT_ERROR,						//定位3DCNN模块，pca错误
+	LOCATER_3DCNN_EXTRACT_RECT_ERROR,					//定位3DCNN模块，提取矩形错误
+	LOCATER_3DCNN_RECT_SIZE_ERROR,						//定位3DCNN模块，矩形范围错误
+
+    LOCATER_3DCNN_PREDICT_FAILED,						//定位3DCNN模块，预测失败
+    LOCATER_3DCNN_VERIFY_RECT_FAILED_3,					//定位3DCNN模块，验证矩形失败3
+    LOCATER_3DCNN_VERIFY_RECT_FAILED_4,					//定位3DCNN模块，验证矩形失败4
+    LOCATER_3DCNN_KMEANS_FAILED,						//定位3DCNN模块，k均值失败
+    LOCATER_3DCNN_IIU_FAILED,							//定位3DCNN模块，IIU失败
+    LOCATER_3DCNN_PCA_OUT_CLOUD_EMPTY,					//定位3DCNN模块，pca输出点云为空
+
+	//感测和主控通信
+	LOCATER_MSG_TABLE_NOT_EXIST  				= 0x03030100,
     LOCATER_MSG_RESPONSE_TYPE_ERROR,                                //测量反馈消息类型错误(致命)
     LOCATER_MSG_RESPONSE_INFO_ERROR,
     LOCATER_MSG_REQUEST_CANCELED,
@@ -88,10 +241,316 @@ enum Error_code
     LOCATER_MSG_RESPONSE_HAS_NO_REQUEST,
     LOCATER_MSG_REQUEST_REPEATED,
 
-   /*
-    * parkspace error code
-    */
-    PARKSPACE_REQUEST_MSG_TYPE_ERROR                = 0x04010000,
+    //System_manager error from 0x04010000-0x0401FFFF
+    SYSTEM_READ_PARAMETER_ERROR						=0x04010100,
+    SYSTEM_PARAMETER_ERROR,
+    SYSTEM_INPUT_TERMINOR_NO_LASERS,
+
+    //terminor_command_executor.cpp from 0x04010200-0x040102FF
+    TERMINOR_NOT_READY								=0x04010200,
+    TERMINOR_INPUT_LASER_NULL,
+    TERMINOR_NOT_CONTAINS_LASER,
+    TERMINOR_INPUT_PLC_NULL,
+    TERMINOR_INPUT_LOCATER_NULL,
+    TERMINOR_CREATE_WORKING_THREAD_FAILED,
+    TERMINOR_FORCE_QUIT,
+    TERMINOR_LASER_TIMEOUT,
+    TERMINOR_POST_PLC_TIMEOUT,
+    TERMINOR_CHECK_RESULTS_ERROR,
+
+    ////Hardware limit from 0x05010000 - 0x0501ffff
+    ///railing.cpp from 0x05010100-0x050101ff
+    HARDWARE_LIMIT_LEFT_RAILING						=0x05010100,         //左栏杆限制
+    HARDWARE_LIMIT_RAILING_PARAMETER_ERROR,
+    HARDWARE_LIMIT_RAILING_ERROR,
+    HARDWARE_LIMIT_CENTER_X_LEFT,
+    HARDWARE_LIMIT_CENTER_X_RIGHT,
+    HARDWARE_LIMIT_CENTER_Y_TOP,
+    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,
+
+
+//万集设备模块，
+    WANJI_LIDAR_DEVICE_ERROR_BASE								=0x06080000,//万集设备模块，错误基类
+	WANJI_LIDAR_DEVICE_STATUS_BUSY,									//万集设备模块，状态正忙
+	WANJI_LIDAR_DEVICE_STATUS_ERROR,								//万集设备模块，状态错误
+	WANJI_LIDAR_DEVICE_TASK_TYPE_ERROR,								//万集设备模块，任务类型错误
+	WANJI_LIDAR_DEVICE_TASK_OVER_TIME,								//万集设备模块，任务超时
+	WANJI_LIDAR_DEVICE_NO_CLOUD,									//万集设备模块，没有点云
+    // velodyne设备模块
+    VELODYNE_LIDAR_DEVICE_ERROR_BASE,								//velodyne设备模块，错误基类
+    VELODYNE_LIDAR_DEVICE_STATUS_BUSY,									//velodyne设备模块，状态正忙
+	VELODYNE_LIDAR_DEVICE_STATUS_ERROR,								//velodyne设备模块，状态错误
+	VELODYNE_LIDAR_DEVICE_TASK_TYPE_ERROR,								//velodyne设备模块，任务类型错误
+	VELODYNE_LIDAR_DEVICE_TASK_OVER_TIME,								//velodyne设备模块，任务超时
+	VELODYNE_LIDAR_DEVICE_NO_CLOUD,									//velodyne设备模块，没有点云
+
+
+	//万集通信wj_lidar error from 0x06010000-0x0601FFFF
+	WJ_LIDAR_COMMUNICATION_ERROR_BASE				=0x06010000,
+	WJ_LIDAR_COMMUNICATION_UNINITIALIZED,							//万集通信,未初始化
+	WJ_LIDAR_COMMUNICATION_DISCONNECT,								//万集通信,断连
+	WJ_LIDAR_COMMUNICATION_FAULT,									//万集通信,故障
+	WJ_LIDAR_CONNECT_FAILED,										//万集通信,连接失败
+    WJ_LIDAR_UNINITIALIZED,											//万集通信,未初始化
+    WJ_LIDAR_READ_FAILED,											//万集通信,读取失败
+    WJ_LIDAR_WRITE_FAILED,											//万集通信,写入失败
+    WJ_LIDAR_GET_CLOUD_TIMEOUT,										//万集通信,获取点云超时
+    // velodyne通信
+    VELODYNE_LIDAR_COMMUNICATION_UNINITIALIZED,							//velodyne通信,未初始化
+	VELODYNE_LIDAR_COMMUNICATION_DISCONNECT,								//velodyne通信,断连
+	VELODYNE_LIDAR_COMMUNICATION_FAULT,									//velodyne通信,故障
+	VELODYNE_LIDAR_CONNECT_FAILED,										//velodyne通信,连接失败
+    VELODYNE_LIDAR_UNINITIALIZED,											//velodyne通信,未初始化
+    VELODYNE_LIDAR_READ_FAILED,											//velodyne通信,读取失败
+    VELODYNE_LIDAR_WRITE_FAILED,											//velodyne通信,写入失败
+    VELODYNE_LIDAR_GET_CLOUD_TIMEOUT,										//velodyne通信,获取点云超时
+
+    //万集解析 wj lidar protocol error from 0x06020000-0x0602FFFF
+        WJ_PROTOCOL_ERROR_BASE						=0x06020000,
+	WJ_PROTOCOL_STATUS_BUSY,										//万集解析, 状态正忙
+	WJ_PROTOCOL_STATUS_ERROR,										//万集解析, 状态错误
+    WJ_PROTOCOL_INTEGRITY_ERROR,									//万集解析, 完整性错误								
+    WJ_PROTOCOL_PARSE_FAILED,										//万集解析, 解析失败
+    WJ_PROTOCOL_EMPTY_PACKAGE,										//万集解析, 空包
+    WJ_PROTOCOL_EXCEED_MAX_SIZE,									//万集解析, 超出最大范围
+
+    //万集测量范围 wj region detect error from 0x06030000-0x0603FFFF
+	WJ_REGION_ERROR_BASE							= 0x06030000,
+	WJ_REGION_EMPTY_CLOUD,											//万集测量，空点云	
+	WJ_REGION_EMPTY_NO_WHEEL_INFORMATION,							//万集测量，没有车轮信息
+    WJ_REGION_RECTANGLE_ANGLE_ERROR,								//万集测量，矩形旋转角错误
+    WJ_REGION_RECTANGLE_SIZE_ERROR,									//万集测量，矩形大小错误
+    WJ_REGION_RECTANGLE_SYMMETRY_ERROR,								//万集测量，矩形对称错误
+    WJ_REGION_CLUSTER_SIZE_ERROR,									//万集测量，簇大小错误
+    WJ_REGION_CERES_SOLVE_ERROR,                                    //万集测量，优化失败
+    //velodyne测量范围
+	VELODYNE_REGION_ERROR_BASE,
+	VELODYNE_REGION_EMPTY_CLOUD,											//velodyne测量，空点云	
+	VELODYNE_REGION_EMPTY_NO_WHEEL_INFORMATION,							//velodyne测量，没有车轮信息
+    VELODYNE_REGION_RECTANGLE_ANGLE_ERROR,								//velodyne测量，矩形旋转角错误
+    VELODYNE_REGION_RECTANGLE_SIZE_ERROR,									//velodyne测量，矩形大小错误
+    VELODYNE_REGION_RECTANGLE_SYMMETRY_ERROR,								//velodyne测量，矩形对称错误
+    VELODYNE_REGION_CLUSTER_SIZE_ERROR,									//velodyne测量，簇大小错误
+    VELODYNE_REGION_CERES_SOLVE_ERROR,                                    //velodyne测量，优化失败
+
+    //万集管理模块 wj manager error from 0x06040000-0x0604FFFF
+	WJ_MANAGER_ERROR_BASE										= 0x06040000,
+    WJ_MANAGER_UNINITIALIZED,									//万集管理模块，未初始化
+    WJ_MANAGER_LIDAR_DISCONNECTED,								//万集管理模块，雷达断链
+    WJ_MANAGER_PLC_DISCONNECTED,								//万集管理模块，plc断链
+    WJ_MANAGER_EMPTY_CLOUD,										//万集管理模块，空点云
+	WJ_MANAGER_READ_PROTOBUF_ERROR,								//万集管理模块，读取参数错误
+	WJ_MANAGER_INIT_ERROR,										//万集管理模块，初始化error
+	WJ_MANAGER_TASK_TYPE_ERROR,									//万集管理模块，任务类型错误
+	WJ_MANAGER_STATUS_BUSY,										//万集管理模块，状态正忙
+	WJ_MANAGER_STATUS_ERROR,									//万集管理模块，状态错误
+	WJ_MANAGER_LASER_INDEX_ERRPR,								//万集管理模块，雷达索引错误，编号错误。
+	WJ_MANAGER_LASER_INDEX_REPEAT,								//万集管理模块，需要扫描的雷达索引重复,可忽略的错误,提示作用
+	WJ_MANAGER_TASK_OVER_TIME,									//万集管理模块，任务超时
+    VELODYNE_MANAGER_ERROR_BASE,										
+    VELODYNE_MANAGER_UNINITIALIZED,									//velodyne管理模块，未初始化
+    VELODYNE_MANAGER_LIDAR_DISCONNECTED,								//velodyne管理模块，雷达断链
+    VELODYNE_MANAGER_EMPTY_CLOUD,										//velodyne管理模块，空点云
+	VELODYNE_MANAGER_READ_PROTOBUF_ERROR,								//velodyne管理模块，读取参数错误
+	VELODYNE_MANAGER_INIT_ERROR,										//velodyne管理模块，初始化error
+	VELODYNE_MANAGER_TASK_TYPE_ERROR,									//velodyne管理模块，任务类型错误
+	VELODYNE_MANAGER_STATUS_BUSY,										//velodyne管理模块，状态正忙
+	VELODYNE_MANAGER_STATUS_ERROR,									//velodyne管理模块，状态错误
+	VELODYNE_MANAGER_LASER_INDEX_ERRPR,								//velodyne管理模块，雷达索引错误，编号错误。
+	VELODYNE_MANAGER_LASER_INDEX_REPEAT,								//velodyne管理模块，需要扫描的雷达索引重复,可忽略的错误,提示作用
+	VELODYNE_MANAGER_TASK_OVER_TIME,									//velodyne管理模块，任务超时
+
+//万集任务模块
+	WJ_LIDAR_TASK_ERROR_BASE									=0x06050000,
+	WJ_LIDAR_TASK_EMPTY_RESULT,									//万集任务模块，空结果
+    WJ_LIDAR_TASK_EMPTY_TASK,									//万集任务模块，空任务
+    WJ_LIDAR_TASK_WRONG_TYPE,									//万集任务模块，错误类型
+    WJ_LIDAR_TASK_INVALID_TASK,									//万集任务模块，无效任务
+    WJ_LIDAR_TASK_MEASURE_FAILED,								//万集任务模块，测量失败
+
+    // 万集滤波
+    WJ_FILTER_ERROR_BASE                                        =0x06060000,
+    WJ_FILTER_LACK_OF_RESULT,                                   //万集滤波,结果不足以进行滤波
+    WJ_FILTER_FLUCTUATING,                                      //万集滤波,结果波动过大
+
+    //task module, 任务模块  error from 0x10010000-0x1001FFFF
+	TASK_MODULE_ERROR_BASE 							= 0x10010000,
+	TASK_TYPE_IS_UNKNOW,
+	TASK_NO_RECEIVER,
+
+
+	//Communication module, 通信模块
+	COMMUNICATION_BASE_ERROR_BASE					= 0x11010000,
+	COMMUNICATION_READ_PROTOBUF_ERROR,				//模块，读取参数错误
+	COMMUNICATION_BIND_ERROR,
+	COMMUNICATION_CONNECT_ERROR,
+	COMMUNICATION_ANALYSIS_TIME_OUT,									//解析超时,
+	COMMUNICATION_EXCUTER_IS_BUSY,										//处理器正忙, 请稍等
+
+
+
+
+	//system module, 系统模块
+	SYSTEM_EXECUTOR_ERROR_BASE						= 0x12010000,		//系统执行模块,
+	SYSTEM_EXECUTOR_PARSE_ERROR,										//系统执行模块, 解析消息错误
+	SYSTEM_EXECUTOR_STATUS_BUSY,										//系统执行模块, 状态正忙
+	SYSTEM_EXECUTOR_STATUS_ERROR,										//系统执行模块, 状态错误
+	SYSTEM_EXECUTOR_CHECK_ERROR,										//系统执行模块, 检查错误
+
+
+
+	//Dispatch 调度 模块 错误码
+	DISPATCH_ERROR_BASE								= 0x13000000,
+
+	//Dispatch_manager 调度管理模块 错误码
+	DISPATCH_MANAGER_ERROR_BASE						= 0x13010000,
+	DISPATCH_MANAGER_READ_PROTOBUF_ERROR,				//调度管理模块，读取参数错误
+	DISPATCH_MANAGER_STATUS_BUSY,						//调度管理模块，状态正忙
+	DISPATCH_MANAGER_STATUS_ERROR,						//调度管理模块，状态错误
+	DISPATCH_MANAGER_TASK_TYPE_ERROR,					//调度管理模块，任务类型错误
+	DISPATCH_MANAGER_IS_NOT_READY,						//调度管理模块，不在准备状态
+	DISPATCH_MANAGER_SPACE_LOCK_ERROR,					//调度管理模块，空间锁错误
+
+
+	DISPATCH_PROCESS_ERROR_BASE								= 0x13020000,
+	DISPATCH_PROCESS_IS_NOT_READY,						//调度流程, 不在准备状态
+	DISPATCH_PROCESS_DEVICE_TYPE_ERROR,					//调度流程, 设备类型错误
+	DISPATCH_PROCESS_DEVICE_STATUS_ERROR,				//调度流程, 设备状态错误
+	DISPATCH_PROCESS_TASK_STATUS_ERROR,					//调度流程, 任务类型错误
+	DISPATCH_PROCESS_COMMAND_KEY_REPEAT,				//调度流程, 唯一码错误
+	DISPATCH_PROCESS_INIT_ERROR,						//调度流程, 初始化错误
+
+
+	DISPATCH_DEVICE_ERROR_BASE								= 0x13030000,
+	DISPATCH_DEVICE_READ_PROTOBUF_ERROR,				//调度设备模块，读取参数错误
+	DISPATCH_DEVICE_STATUS_BUSY,						//调度设备模块，状态正忙
+	DISPATCH_DEVICE_STATUS_ERROR,						//调度设备模块，状态错误
+	DISPATCH_DEVICE_STATUS_DISCONNECT,					//调度设备模块，状态断连
+	DISPATCH_DEVICE_TASK_TYPE_ERROR,					//调度设备模块，任务类型错误
+	DISPATCH_DEVICE_TASK_OVER_TIME,						//调度设备模块，任务超时
+	DISPATCH_DEVICE_TASK_REPEAT,						//调度设备模块，任务重复, 任务已经存在
+	DISPATCH_DEVICE_IS_NOT_READY,						//调度设备模块，不在准备状态
+	DISPATCH_DEVICE_RESPONS_ERROR,						//调度设备模块，指令的执行失败
+	DISPATCH_DEVICE_TASK_NOTHINGNESS,					//调度设备模块，任务不存在
+	DISPATCH_DEVICE_TASK_LEVEL_ERROR,					//调度设备模块，任务等级错误
+
+
+	CARRIER_ERROR_BASE								= 0x13040000,
+	CARRIER_READ_PROTOBUF_ERROR,				//搬运器模块，读取参数错误
+	CARRIER_STATUS_BUSY,						//搬运器模块，状态正忙
+	CARRIER_STATUS_ERROR,						//搬运器模块，状态错误
+	CARRIER_STATUS_DISCONNECT,					//搬运器模块，状态断连
+	CARRIER_TASK_TYPE_ERROR,					//搬运器模块，任务类型错误
+	CARRIER_TASK_OVER_TIME,						//搬运器模块，任务超时
+	CARRIER_IS_NOT_READY,						//搬运器模块，不在准备状态
+	CARRIER_RESPONS_ERROR,						//搬运器模块，指令的执行失败
+	CARRIER_TASK_NOTHINGNESS,					//搬运器模块，任务不存在
+	CARRIER_POSE_ERROR,							//搬运器模块，姿态错误
+	CARRIER_CONRTOL_PARAMETER_ERROR,			//搬运器模块，控制参数错误
+
+	CATCHER_ERROR_BASE								= 0x13050000,
+	CATCHER_READ_PROTOBUF_ERROR,				//抓取器模块，读取参数错误
+	CATCHER_STATUS_BUSY,						//抓取器模块，状态正忙
+	CATCHER_STATUS_ERROR,						//抓取器模块，状态错误
+	CATCHER_STATUS_DISCONNECT,					//抓取器模块，状态断连
+	CATCHER_TASK_TYPE_ERROR,					//抓取器模块，任务类型错误
+	CATCHER_TASK_OVER_TIME,						//抓取器模块，任务超时
+	CATCHER_IS_NOT_READY,						//抓取器模块，不在准备状态
+	CATCHER_RESPONS_ERROR,						//抓取器模块，指令的执行失败
+	CATCHER_TASK_NOTHINGNESS,					//抓取器模块，任务不存在
+	CATCHER_POSE_ERROR,							//抓取器模块，姿态错误
+	CATCHER_CONRTOL_PARAMETER_ERROR,			//抓取器模块，控制参数错误
+
+	PASSAGEWAY_ERROR_BASE								= 0x13060000,
+	PASSAGEWAY_READ_PROTOBUF_ERROR,				//通道口模块，读取参数错误
+	PASSAGEWAY_STATUS_BUSY,						//通道口模块，状态正忙
+	PASSAGEWAY_STATUS_ERROR,						//通道口模块，状态错误
+	PASSAGEWAY_STATUS_DISCONNECT,					//通道口模块，状态断连
+	PASSAGEWAY_TASK_TYPE_ERROR,					//通道口模块，任务类型错误
+	PASSAGEWAY_TASK_OVER_TIME,						//通道口模块，任务超时
+	PASSAGEWAY_IS_NOT_READY,						//通道口模块，不在准备状态
+	PASSAGEWAY_RESPONS_ERROR,						//通道口模块，指令的执行失败
+	PASSAGEWAY_TASK_NOTHINGNESS,					//通道口模块，任务不存在
+
+
+	//DISPATCH_COORDINATES module, 通信模块
+	DISPATCH_COORDINATES_ERROR_BASE					= 0x13060000,
+	DISPATCH_COORDINATES_READ_PROTOBUF_ERROR,				//调度坐标模块，读取参数错误
+	DISPATCH_COORDINATES_ID_ERROR,							//调度坐标模块，坐标id错误
+	DISPATCH_COORDINATES_PATH_ERROR,						//调度坐标模块，路径方向错误
+	DISPATCH_COORDINATES_CAN_NOT_LOCK,						//调度坐标模块，不能加锁
+
+	//Dispatch_plc 调度plc模块
+	DISPATCH_PLC_ERROR_BASE							= 0x13070000,
+	DISPATCH_PLC_REQUEST_ERROR,								//调度plc模块，请求错误
+	DISPATCH_PLC_RESPONS_ERROR,								//调度plc模块，指令的执行失败
+	DISPATCH_PLC_STATUS_ERROR,								//调度plc模块，状态错误
+	DISPATCH_PLC_TIME_OUT,									//调度plc模块，超时
+	DISPATCH_PLC_DIRECTION_ERROR,							//调度plc模块，方向错误
+
+
+
+	//snap7 通信模块 错误码
+	SNAP7_ERROR_BASE								= 0x1401000,
+	SNAP7_READ_PROTOBUF_ERROR,							//snap7通信模块，读取参数错误
+	SNAP7_CONNECT_ERROR,								//snap7通信模块，连接错误
+	SNAP7_DISCONNECT_ERROR,								//snap7通信模块，断连错误
+	SNAP7_READ_ERROR,									//snap7通信模块，读取错误
+	SNAP7_WRITE_ERROR,									//snap7通信模块，写入错误
+	SNAP7_ANALYSIS_TIME_OUT,									//解析超时,
+	SNAP7_EXCUTER_IS_BUSY,										//处理器正忙, 请稍等
+	
+
+	
+	
+    
+    //parkspace allocator，车位分配模块
+    PARKSPACE_ALLOCATOR_ERROR_BASE                  = 0x20010000,     
+    PARKSPACE_ALLOCATOR_MSG_REQUEST_TYPE_ERROR,    //反馈车位消息类型错误 
+    PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR,    //反馈车位消息类型错误
+    PARKSPACE_ALLOCATOR_MSG_PARSE_ERROR,            //请求消息解析错误
+    PARKSPACE_ALLOCATOR_SPACE_EMPTY,                //空车位异常，车库无车位。或许由模块初始化异常产生
+    PARKSPACE_ALLOCATOR_ALLOCATE_FAILED,            //无合适车位，分配失败
+    PARKSPACE_ALLOCATOR_SEARCH_FAILED,              //未找到车辆对应车位
+    PARKSPACE_ALLOCATOR_RELEASE_FAILED,             //未找到匹配的车位，车位未释放
+    PARKSPACE_ALLOCATOR_FORCE_UPDATE_FAILED,        //手动更新失败，未找到匹配车位
+    PARKSPACE_ALLOCATOR_PARAM_ERROR,                //传入参数错误
+    PARKSPACE_ALLOCATOR_CONFIRM_ALLOC_ERROR,        //确认分配车位错误
+    PARKSPACE_ALLOCATOR_CAR_ALREADY_EXIST,          //车辆已存在
+
+    // 数据库操作
+    DB_ERROR_BASE                                   = 0x20020000,
+    DB_INIT_FAILED,									//数据库初始化失败
+    DB_CONNECT_FAILED,                              //数据库连接失败
+    DB_STATUS_ERROR,								//数据库状态错误
+	DB_MANAGER_STATUS_ERROR,						//数据库管理状态错误
+    DB_INSERT_FAILED,                               //数据库插入失败
+    DB_DELETE_FAILED,                               //数据库删除失败
+    DB_UPDATE_FAILED,                               //数据库更新失败
+    DB_QUERY_FAILED,                                //数据库查询失败
+    DB_UNINITIALIZED,                               //数据库外层未初始化
+    DB_DISCONNECTED,                                //数据库外层连接失去
+    DB_RESULT_SET_EMPTY,                            //数据库外层查询返回结果空指针
+    DB_RESULT_SET_PARSE_ERROR,                      //数据库外层查询结果解析失败
+    DB_CONNECT_CHANNEL_NOT_FOUND,					//数据库连接通道未找到
+    DB_CONNECT_CHANNEL_NUMBER_ERROR,				//数据库连接通道数量错误
+    DB_QUERY_DATA_REPEAT,							//数据库查询数据重复
+    DB_QUERY_NOT_DATA,								//数据库未查询到数据
+	DB_QUERY_DATA_FAILED,							//数据库查询数据错误
+	DB_NOT_QUERY_EMPTY_PARKSPACE,					//数据库未查询到空车位
+	DB_PROTOBUF_ERROR,								//数据库配置参数读取错误
+
+
+
+
+    //parkspace error code
+    PARKSPACE_REQUEST_MSG_TYPE_ERROR            	= 0x20030000,
     PARKSPACE_ALLOCMSG_RESPONSE_HAS_NO_REQUEST,
     PARKSPACE_SEARCHMSG_RESPONSE_HAS_NO_REQUEST,
     PARKSPACE_RELEASEMSG_RESPONSE_HAS_NO_REQUEST,
@@ -116,175 +575,6 @@ enum Error_code
     PARKSPACE_RELEASE_REQUEST_CANCELED,
 
 
-	//Communication module, 通信模块
-	COMMUNICATION_BASE_ERROR_BASE					= 0x11010000,
-	COMMUNICATION_READ_PROTOBUF_ERROR,				//模块，读取参数错误
-	COMMUNICATION_BIND_ERROR,
-	COMMUNICATION_CONNECT_ERROR,
-	COMMUNICATION_ANALYSIS_TIME_OUT,									//解析超时,
-	COMMUNICATION_EXCUTER_IS_BUSY,										//处理器正忙, 请稍等
-
-
-
-
-    DISPATCH_ERROR_BASE=	0x13000000,
-    DISPATCH_MANAGER_ERROR_BASE	=0x13010000,
-    DISPATCH_MANAGER_READ_PROTOBUF_ERROR,		//调度管理模块，读取参数错误
-    DISPATCH_MANAGER_STATUS_BUSY,		//调度管理模块，状态正忙
-    DISPATCH_MANAGER_STATUS_ERROR,		//调度管理模块，状态错误
-    DISPATCH_MANAGER_TASK_TYPE_ERROR,		//调度管理模块，任务类型错误
-    DISPATCH_MANAGER_IS_NOT_READY,		//调度管理模块，不在准备状态
-    CARRIER_ERROR_BASE	=0x13020000,
-    CARRIER_READ_PROTOBUF_ERROR	,	//搬运器模块，读取参数错误
-    CARRIER_STATUS_BUSY	,	//搬运器模块，状态正忙
-    CARRIER_STATUS_ERROR,		//搬运器模块，状态错误
-    CARRIER_STATUS_DISCONNECT,		//搬运器模块，状态断连
-    CARRIER_TASK_TYPE_ERROR	,	//搬运器模块，任务类型错误
-    CARRIER_TASK_OVER_TIME	,	//搬运器模块，任务超时
-    CARRIER_IS_NOT_READY	,	//搬运器模块，不在准备状态
-    CARRIER_RESPONS_ERROR	,	//搬运器模块，指令的执行失败
-    CARRIER_TASK_NOTHINGNESS,		//搬运器模块，任务不存在
-    SNAP7_ERROR_BASE	= 0x1401000,
-    SNAP7_READ_PROTOBUF_ERROR	,	//snap7通信模块，读取参数错误
-    SNAP7_CONNECT_ERROR	,	//snap7通信模块，连接错误
-    SNAP7_DISCONNECT_ERROR	,	//snap7通信模块，断连错误
-    SNAP7_READ_ERROR	,	//snap7通信模块，读取错误
-    SNAP7_WRITE_ERROR	,	//snap7通信模块，写入错误
-    SNAP7_ANALYSIS_TIME_OUT	,	//解析超时
-    SNAP7_EXCUTER_IS_BUSY	,	//处理器正忙 请稍等
-
-
-    LASER_ERROR_BASE	=0x01000000,
-    LASER_BASE_ERROR_BASE	=0x01010000,
-    LASER_TASK_PARAMETER_ERROR	=0x01010001,	//雷达基类模块,任务输入参数错误
-    LASER_CONNECT_FAILED,		//雷达基类模块,连接失败
-    LASER_START_FAILED,		//雷达基类模块,开始扫描失败
-    LASER_CHECK_FAILED,		//雷达基类模块,检查失败
-    LASER_STATUS_BUSY,		//雷达基类模块,状态正忙
-    LASER_STATUS_ERROR,		//雷达基类模块,状态错误
-    LASER_TASK_OVER_TIME,		//雷达基类模块,任务超时
-    LASER_QUEUE_ERROR,		//雷达基类模块,数据缓存错误
-    LIVOX_ERROR_BASE	=0x01020000,
-    LIVOX_START_FAILE,		//livox模块,开始扫描失败
-    LIVOX_TASK_TYPE_ERROR,		//livox模块,任务类型错误
-    lIVOX_CANNOT_PUSH_DATA,		//livox模块,不能添加扫描的数据
-    lIVOX_CHECK_FAILED,		//livox模块,检查失败
-    lIVOX_STATUS_BUSY,		//livox模块,状态正忙
-    lIVOX_STATUS_ERROR,		//livox模块,状态错误
-    LASER_MANAGER_ERROR_BASE=	0x01030000,
-    LASER_MANAGER_READ_PROTOBUF_ERROR,		//雷达管理模块,读取参数错误
-    LASER_MANAGER_STATUS_BUSY,		//雷达管理模块,状态正忙
-    LASER_MANAGER_STATUS_ERROR,		//雷达管理模块,状态错误
-    LASER_MANAGER_TASK_TYPE_ERROR,		//雷达管理模块,任务类型错误
-    LASER_MANAGER_IS_NOT_READY,		//雷达管理模块,不在准备状态
-    LASER_MANAGER_TASK_OVER_TIME,		//雷达管理模块,任务超时
-    LASER_MANAGER_LASER_INDEX_ERRPR,		//雷达管理模块,雷达索引错误，编号错误。
-    LASER_MANAGER_LASER_INDEX_REPEAT,		//雷达管理模块,需要扫描的雷达索引重复,可忽略的错误,提示作用
-    LIVOX_DRIVER_ERROR_BASE	=0x01040000,
-    LIVOX_DRIVER_SN_REPEAT,		//livox驱动模块,雷达广播码重复
-    LIVOX_DRIVER_SN_ERROR,		//livox驱动模块,雷达广播码错误
-    LIVOX_SKD_INIT_FAILED,		//livox驱动模块,livox_sdk初始化失败
-    LIVOX_DRIVER_NOT_READY,		//livox驱动模块,livox没有准备好.
-
-    LOCATER_ERROR_BASE	=0x03000000,
-    LOCATER_MANAGER_ERROR_BASE	=0x03010000,
-    LOCATER_MANAGER_READ_PROTOBUF_ERROR,		//定位管理模块,读取参数错误
-    LOCATER_MANAGER_STATUS_BUSY,		//定位管理模块,状态正忙
-    LOCATER_MANAGER_STATUS_ERROR,		//定位管理模块,状态错误
-    LOCATER_MANAGER_TASK_TYPE_ERROR,		//定位管理模块,任务类型错误
-    LOCATER_MANAGER_IS_NOT_READY,		//定位管理模块,不在准备状态
-    LOCATER_MANAGER_CLOUD_MAP_ERROR,		//定位管理模块,任务输入点云map的error
-    LOCATER_MANAGER_TASK_OVER_TIME,		//定位管理模块,任务超时
-    LOCATER_ALGORITHM_ERROR_BASE	=0x03020000,
-    LOCATER_TASK_INIT_CLOUD_EMPTY	,	//定位任务初始化点云为空
-    LOCATER_TASK_ERROR,		//定位任务错误
-    LOCATER_TASK_INPUT_CLOUD_UNINIT,		//定位任务输入点云为空
-    LOCATER_INPUT_CLOUD_EMPTY,		//定位输入点云为空
-    LOCATER_YOLO_UNINIT,		//定位yolo未初始化
-    LOCATER_POINTSIFT_UNINIT,		//定位POINTSIFT未初始化
-    LOCATER_3DCNN_UNINIT,		//定位3DCNN未初始化
-    LOCATER_INPUT_YOLO_CLOUD_EMPTY,		//定位输入yolo点云为空
-    LOCATER_Y_OUT_RANGE_BY_PLC,		//定位超出plc的限制范围
-    LOCATER_MEASURE_HEIGHT_CLOUD_EMPTY,		//定位测量高点云为空
-    LOCATER_SIFT_ERROR_BASE	=0x03020100,
-    LOCATER_SIFT_INIT_FAILED,		//定位过滤模块,初始化失败
-    LOCATER_SIFT_INPUT_CLOUD_UNINIT,		//定位过滤模块,输入点云未初始化
-    LOCATER_SIFT_INPUT_CLOUD_EMPTY,		//定位过滤模块,输入点云为空
-    LOCATER_SIFT_GRID_ERROR,		//定位过滤模块,筛选网格错误
-    LOCATER_SIFT_SELECT_ERROR,		//定位过滤模块,筛选选择错误
-    LOCATER_SIFT_CLOUD_VERY_LITTLE,		//定位过滤模块,筛选点云很少
-    LOCATER_SIFT_CREATE_INPUT_DATA_FAILED,		//定位过滤模块,筛选创建输入数据失败
-    LOCATER_SIFT_PREDICT_FAILED,		//定位过滤模块,预测失败
-    LOCATER_SIFT_PREDICT_TIMEOUT,		//定位过滤模块,预测超时
-    LOCATER_SIFT_PREDICT_NO_WHEEL_POINT,		//定位过滤模块,预测结果没有车轮点云
-    LOCATER_SIFT_PREDICT_NO_CAR_POINT,		//定位过滤模块,预测结果没有车身点云
-    LOCATER_SIFT_FILTE_OBS_FAILED,		//定位过滤模块,过滤OBS失败
-    LOCATER_SIFT_INPUT_BOX_PARAMETER_FAILED,		//定位过滤模块,输入范围参数错误
-    LOCATER_3DCNN_ERROR_BASE	=0x03020300,
-    LOCATER_3DCNN_INIT_FAILED,		//定位3DCNN模块,初始化失败
-    LOCATER_3DCNN_INPUT_CLOUD_UNINIT,		//定位3DCNN模块,输入点云未初始化
-    LOCATER_3DCNN_INPUT_CLOUD_EMPTY,		//定位3DCNN模块,输入点云为空
-    LOCATER_3DCNN_INPUT_CLOUD_MAP_ERROR,		//定位3DCNN模块,输入点云的map错误
-    LOCATER_3DCNN_PCA_OUT_ERROR,		//定位3DCNN模块,pca错误
-    LOCATER_3DCNN_EXTRACT_RECT_ERROR,		//定位3DCNN模块,提取矩形错误
-    LOCATER_3DCNN_RECT_SIZE_ERROR,		//定位3DCNN模块,矩形范围错误
-    LOCATER_3DCNN_PREDICT_FAILED,		//定位3DCNN模块,预测失败
-    LOCATER_3DCNN_VERIFY_RECT_FAILED_3,		//定位3DCNN模块,验证矩形失败3
-    LOCATER_3DCNN_VERIFY_RECT_FAILED_4,		//定位3DCNN模块,验证矩形失败4
-    LOCATER_3DCNN_KMEANS_FAILED,		//定位3DCNN模块,k均值失败
-    LOCATER_3DCNN_IIU_FAILED,		//定位3DCNN模块,IIU失败
-    LOCATER_3DCNN_PCA_OUT_CLOUD_EMPTY,		//定位3DCNN模块,pca输出点云为空
-
-    WANJI_LIDAR_DEVICE_ERROR_BASE	=0x06080000,	//万集设备模块,错误基类
-    WANJI_LIDAR_DEVICE_STATUS_BUSY,		//万集设备模块,状态正忙
-    WANJI_LIDAR_DEVICE_STATUS_ERROR,		//万集设备模块,状态错误
-    WANJI_LIDAR_DEVICE_TASK_TYPE_ERROR,		//万集设备模块,任务类型错误
-    WANJI_LIDAR_DEVICE_TASK_OVER_TIME,		//万集设备模块,任务超时
-    WANJI_LIDAR_DEVICE_NO_CLOUD,		//万集设备模块,没有点云
-    WJ_LIDAR_COMMUNICATION_ERROR_BASE	=0x06010000,
-    WJ_LIDAR_COMMUNICATION_UNINITIALIZED,		//万集通信,未初始化
-    WJ_LIDAR_COMMUNICATION_DISCONNECT,		//万集通信,断连
-    WJ_LIDAR_COMMUNICATION_FAULT,		//万集通信,故障
-    WJ_LIDAR_CONNECT_FAILED,		//万集通信,连接失败
-    WJ_LIDAR_UNINITIALIZED,		//万集通信,未初始化
-    WJ_LIDAR_READ_FAILED,		//万集通信,读取失败
-    WJ_LIDAR_WRITE_FAILED,		//万集通信,写入失败
-    WJ_LIDAR_GET_CLOUD_TIMEOUT,		//万集通信,获取点云超时
-    WJ_PROTOCOL_ERROR_BASE	=0x06020000,
-    WJ_PROTOCOL_STATUS_BUSY,		//万集解析,状态正忙
-    WJ_PROTOCOL_STATUS_ERROR,		//万集解析,状态错误
-    WJ_PROTOCOL_INTEGRITY_ERROR,		//万集解析,完整性错误
-    WJ_PROTOCOL_PARSE_FAILED,		//万集解析,解析失败
-    WJ_PROTOCOL_EMPTY_PACKAGE,		//万集解析,空包
-    WJ_PROTOCOL_EXCEED_MAX_SIZE,		//万集解析,超出最大范围
-    WJ_REGION_ERROR_BASE	=0x06030000,
-    WJ_REGION_EMPTY_CLOUD,		//万集测量,空点云
-    WJ_REGION_EMPTY_NO_WHEEL_INFORMATION,		//万集测量,没有车轮信息
-    WJ_REGION_RECTANGLE_ANGLE_ERROR,		//万集测量,矩形旋转角错误
-    WJ_REGION_RECTANGLE_SIZE_ERROR,		//万集测量,矩形大小错误
-    WJ_REGION_RECTANGLE_SYMMETRY_ERROR,		//万集测量,矩形对称错误
-    WJ_REGION_CLUSTER_SIZE_ERROR,		//万集测量,簇大小错误
-    WJ_MANAGER_ERROR_BASE	=0x06040000,
-    WJ_MANAGER_UNINITIALIZED,		//万集管理模块,未初始化
-    WJ_MANAGER_LIDAR_DISCONNECTED,		//万集管理模块,雷达断链
-    WJ_MANAGER_PLC_DISCONNECTED,		//万集管理模块,plc断链
-    WJ_MANAGER_EMPTY_CLOUD,		//万集管理模块,空点云
-    WJ_MANAGER_READ_PROTOBUF_ERROR,		//万集管理模块,读取参数错误
-    WJ_MANAGER_INIT_ERROR,		//万集管理模块,重复初始化
-    WJ_MANAGER_TASK_TYPE_ERROR,		//万集管理模块,任务类型错误
-    WJ_MANAGER_STATUS_BUSY,		//万集管理模块,状态正忙
-    WJ_MANAGER_STATUS_ERROR,		//万集管理模块,状态错误
-    WJ_MANAGER_LASER_INDEX_ERRPR,		//万集管理模块,雷达索引错误,编号错误。
-    WJ_MANAGER_LASER_INDEX_REPEAT,		//万集管理模块,需要扫描的雷达索引重复,可忽略的错误,提示作用
-    WJ_MANAGER_TASK_OVER_TIME,		//万集管理模块,任务超时
-    WJ_LIDAR_TASK_ERROR_BASE	=0x06050000,
-    WJ_LIDAR_TASK_EMPTY_RESULT,		//万集任务模块,空结果
-    WJ_LIDAR_TASK_EMPTY_TASK,		//万集任务模块,空任务
-    WJ_LIDAR_TASK_WRONG_TYPE,		//万集任务模块,错误类型
-    WJ_LIDAR_TASK_INVALID_TASK,		//万集任务模块,无效任务
-    WJ_LIDAR_TASK_MEASURE_FAILED,		//万集任务模块,测量失败
-
-
 };
 
 //错误等级，用来做故障处理
@@ -336,7 +626,7 @@ public://外部接口函数
     Error_manager(const Error_manager & error_manager);
     //赋值构造
     Error_manager(Error_code error_code, Error_level error_level = NORMAL,
-                  const char* p_error_description = NULL, int description_length = 0);
+                  const char* p_error_description = NULL);
     //赋值构造
     Error_manager(Error_code error_code, Error_level error_level , std::string & error_aggregate_string);
     //析构函数
@@ -346,12 +636,12 @@ public://外部接口函数
     void error_manager_init();
     //初始化
     void error_manager_init(Error_code error_code, Error_level error_level = NORMAL,
-                            const char* p_error_description = NULL, int description_length = 0);
+                            const char* p_error_description = NULL);
     //初始化
     void error_manager_init(Error_code error_code, Error_level error_level , std::string & error_aggregate_string);
     //重置
     void error_manager_reset(Error_code error_code, Error_level error_level = NORMAL,
-                             const char* p_error_description = NULL, int description_length = 0);
+                             const char* p_error_description = NULL);
     //重置
     void error_manager_reset(Error_code error_code, Error_level error_level , std::string & error_aggregate_string);
     //重置
@@ -380,12 +670,12 @@ public://外部接口函数
     //获取错误等级
     Error_level get_error_level();
     //获取错误描述的指针，（浅拷贝）
-    char* get_error_description();
+    std::string get_error_description();
 
     //复制错误描述，（深拷贝）
     //output：p_error_description     错误描述的字符串指针，不可以为NULL，必须要有实际的内存
     //output:description_length      错误描述的字符串长度，不可以为0，长度最好足够大，一般256即可。
-    void copy_error_description(const char* p_error_description, int description_length);
+    void copy_error_description(const char* p_error_description);
     //复制错误描述，（深拷贝）
     //output：error_description_string     错误描述的string
     void copy_error_description(std::string & error_description_string);
@@ -399,12 +689,12 @@ public://外部接口函数
     //错误等级，设定到固定值
     void set_error_level_location(Error_level error_level);
     //设置错误描述
-    void set_error_description(const char* p_error_description, int description_length = 0);
+    void set_error_description(const char* p_error_description);
     //设置错误描述
     void set_error_description(std::string & error_description_string);
 
     //尾部追加错误描述
-    void add_error_description(const char* p_error_description, int description_length = 0);
+    void add_error_description(const char* p_error_description);
     //尾部追加错误描述
     void add_error_description(std::string & error_description_string);
 
@@ -418,10 +708,6 @@ public://外部接口函数
 	//如果错误相同，则保留this的，将输入参数转入描述。
 	void compare_and_cover_error( Error_manager * p_error_manager);
 
-	//将所有的错误信息，格式化为字符串，用作日志打印。
-    //output：p_error_description     错误汇总的字符串指针，不可以为NULL，必须要有实际的内存
-    //output:description_length      错误汇总的字符串长度，不可以为0，长度最好足够大，一般256即可。
-    void translate_error_to_string(char* p_error_aggregate, int aggregate_length);
     //output：error_description_string     错误汇总的string
     void translate_error_to_string(std::string & error_aggregate_string);
     //错误码转字符串的简易版，可支持cout<<
@@ -433,8 +719,7 @@ public://外部接口函数
 protected:
     Error_code              m_error_code;               //错误码
     Error_level             m_error_level;              //错误等级
-    char*                   pm_error_description;       //错误描述
-    int                     m_description_length;       //错误描述的字符长度
+    std::string             m_error_description;		// 错误描述
 
 protected://内部功能函数
 public:
@@ -456,3 +741,4 @@ public:
 
 #endif //TEST_ERROR_ERROR_CODE_H
 
+