Merge remote-tracking branch 'zzw/hl' into yct

# Conflicts:
#	communication/communication_socket_base.cpp

communication/communication_socket_base.h

@@ -83,7 +83,7 @@ protected:
 	//receive_data_thread 内部线程负责接受消息
 	void receive_data_thread();
 
-	//检查消息是否可以被解析, 需要子类重载
+	//检查消息是否有效, 主要检查消息类型和接受者, 判断这条消息是不是给我的.
 	virtual Error_manager check_msg(Communication_message* p_msg);
 
 	//mp_analysis_data_thread 解析线程执行函数，

error_code/error_code.cpp

@@ -179,6 +179,11 @@ char* Error_manager::get_error_description()
     return pm_error_description;
 }
 
+int Error_manager::get_description_length()
+{
+	return m_description_length;
+}
+
 //复制错误描述，（深拷贝）
 //output：p_error_description     错误描述的字符串指针，不可以为NULL，必须要有实际的内存
 //output:description_length      错误描述的字符串长度，不可以为0，长度最好足够大，一般256即可。

error_code/error_code.h

@@ -275,8 +275,11 @@ enum Error_code
 	//system module, 系统模块
 	SYSTEM_EXECUTOR_ERROR_BASE						= 0x12010000,		//系统执行模块,
 	SYSTEM_EXECUTOR_PARSE_ERROR,										//系统执行模块, 解析消息错误
-	
-	    LOCATER_MSG_TABLE_NOT_EXIST ,
+	SYSTEM_EXECUTOR_STATUS_BUSY,										//系统执行模块, 状态正忙
+	SYSTEM_EXECUTOR_STATUS_ERROR,										//系统执行模块, 状态错误
+	SYSTEM_EXECUTOR_CHECK_ERROR,										//系统执行模块, 检查错误
+
+	LOCATER_MSG_TABLE_NOT_EXIST ,
     LOCATER_MSG_RESPONSE_TYPE_ERROR,
     LOCATER_MSG_RESPONSE_INFO_ERROR,
     LOCATER_MSG_REQUEST_INVALID,
@@ -384,6 +387,8 @@ public://外部接口函数
     //获取错误描述的指针，（浅拷贝）
     char* get_error_description();
 
+	int get_description_length();
+
     //复制错误描述，（深拷贝）
     //output：p_error_description     错误描述的字符串指针，不可以为NULL，必须要有实际的内存
     //output:description_length      错误描述的字符串长度，不可以为0，长度最好足够大，一般256即可。

laser/Laser.cpp

@@ -168,7 +168,7 @@ Error_manager Laser_base::check_status()
 	}
 	else if ( get_laser_statu() == LASER_BUSY  )
 	{
-		return Error_manager(Error_code::LASER_STATUS_BUSY, Error_level::MINOR_ERROR,
+		return Error_manager(Error_code::LASER_STATUS_BUSY, Error_level::NEGLIGIBLE_ERROR,
 							 " CLivoxLaser::check_status error ");
 	}
 	else
@@ -353,6 +353,8 @@ int Laser_base::get_laser_id()
 	return m_laser_id;
 }
 
+
+
 //线程执行函数，将二进制消息存入队列缓存，
 void Laser_base::thread_receive()
 {
@@ -542,6 +544,8 @@ Error_manager Laser_base::set_laser_matrix(double* p_matrix, int size)
 	}
 	return Error_code::SUCCESS;
 }
+
+
 //三维点的坐标变换的功能函数，从雷达自己的坐标系，转化到公共坐标系，（目前以plc为公共坐标系）
 CPoint3D Laser_base::transform_by_matrix(CPoint3D point)
 {

laser/Laser.h

@@ -84,9 +84,14 @@ public:
 
 	//获取雷达id
 	int get_laser_id();
+
+	Laser_statu get_laser_statu();
+
 	//设置变换矩阵，用作三维点的坐标变换，
 	Error_manager set_laser_matrix(double* p_matrix, int size);
 
+
+
 protected:
 	//接受二进制消息的功能函数，并将其存入 m_queue_laser_data, 每次只转化一个CBinaryData，
 	// 纯虚函数，必须由子类重载，
@@ -105,8 +110,6 @@ protected:
 	//线程执行函数，公开发布雷达的相关信息，用作上位机的监视。
 	static void thread_publish(Laser_base* p_laser);
 
-	//获取雷达状态
-	Laser_statu get_laser_statu();
 protected:
 	//初始化变换矩阵，设置默认值
 	Error_manager init_laser_matrix();

laser/laser_manager.cpp

@@ -312,6 +312,15 @@ bool Laser_manager::is_ready()
 	return m_laser_manager_status == LASER_MANAGER_READY;
 }
 
+Laser_manager::Laser_manager_status Laser_manager::get_laser_manager_status()
+{
+	return m_laser_manager_status;
+}
+
+std::vector<Laser_base*> & Laser_manager::get_laser_vector()
+{
+	return m_laser_vector;
+}
 
 
 //下发给子雷达任务。这里为下发雷达任务分配内存, 后续要记得回收 m_laser_task_map 。

laser/laser_manager.h

@@ -84,7 +84,8 @@ public: //API 对外接口
 	bool is_ready();
 
 public://get or set member variable
-
+	Laser_manager_status get_laser_manager_status();
+	std::vector<Laser_base*> & get_laser_vector();
 
 protected:
 	//下发给子雷达任务。这里为下发雷达任务分配内存, 后续要记得回收 m_laser_task_map 。

locate/locate_manager.cpp

@@ -255,7 +255,7 @@ Error_manager Locate_manager::check_status()
 			  || m_locate_manager_status == LOCATE_MANAGER_CAR
 			  || m_locate_manager_status == LOCATE_MANAGER_WHEEL)
 	{
-		return Error_manager(Error_code::LOCATER_MANAGER_STATUS_BUSY, Error_level::MINOR_ERROR,
+		return Error_manager(Error_code::LOCATER_MANAGER_STATUS_BUSY, Error_level::NEGLIGIBLE_ERROR,
 							 " Locate_manager::check_status error ");
 	}
 	else
@@ -324,6 +324,11 @@ bool Locate_manager::is_ready()
 	return m_locate_manager_status == LOCATE_MANAGER_READY;;
 }
 
+Locate_manager::Locate_manager_status Locate_manager::get_locate_manager_status()
+{
+	return m_locate_manager_status;
+}
+
 //mp_locate_manager_thread 线程执行函数，
 //thread_work 内部线程负责locate定位分析整车的信息，并且回收汇总雷达的数据
 void Locate_manager::thread_work()

locate/locate_manager.h

@@ -69,6 +69,10 @@ public: //API 对外接口
 
 	//判断是否为待机，如果已经准备好，则可以执行任务。
 	bool is_ready();
+
+public://get and set
+	Locate_manager_status get_locate_manager_status();
+
 protected:
 	//mp_locate_manager_thread 线程执行函数，
 	//thread_work 内部线程负责locate定位分析整车的信息，并且回收汇总雷达的数据

main.cpp

@@ -17,6 +17,7 @@
 
 #include "./tool/thread_pool.h"
 #include "./system/system_communication.h"
+#include "./system/system_executor.h"
 
 #define LIVOX_NUMBER	     2
 
@@ -28,21 +29,24 @@ void asd(int i)
 
 int main(int argc,char* argv[])
 {
+	Laser_manager::get_instance_references().laser_manager_init();
+	std::cout << "Laser_manager = " << Laser_manager::get_instance_references().get_laser_manager_status() << std::endl;
+	Locate_manager::get_instance_references().Locate_manager_init();
+	std::cout << "Locate_manager = " << Locate_manager::get_instance_references().get_locate_manager_status() << std::endl;
+	System_executor::get_instance_references().system_executor_init(4);
+	std::cout << "System_executor = " << System_executor::get_instance_references().get_system_executor_status() << std::endl;
 
+	System_communication::get_instance_references().communication_init();
 
-//	System_communication csb;
+	char ch ;
+	std::cin >> ch ;
 
-//	std::vector<std::string> connect_string_vector;
-//	connect_string_vector.push_back("tcp://192.168.2.166:9001");
-//	csb.communication_init("tcp://192.168.2.166:9000", connect_string_vector);
+	System_communication::get_instance_references().communication_uninit();
+	System_executor::get_instance_references().system_executor_uninit();
+	Locate_manager::get_instance_references().Locate_manager_uninit();
+	Laser_manager::get_instance_references().laser_manager_uninit();
 
-//	csb.communication_init();
-
-//	System_communication::get_instance_references().communication_init();
-//
-//	char ch ;
-//	std::cin >> ch ;
-//	return 0;
+	return 0;
 
 	Thread_pool pool(4);
 	std::vector< std::future<int> > results;

setting/communication.prototxt

@@ -8,7 +8,10 @@ communication_parameters
  # connect_string_vector:"tcp://192.168.2.166:9002"
 
   # connect_string_vector:"tcp://192.168.2.125:9876"
-   connect_string_vector:"tcp://192.168.2.166:1234"
+  # connect_string_vector:"tcp://192.168.2.166:1234"
+
+   bind_string:"tcp://192.168.2.166:4444"
+
 
 }
 

system/system_communication.cpp

@@ -3,6 +3,9 @@
 //
 
 #include "system_communication.h"
+#include "../laser/laser_manager.h"
+#include "../locate/locate_manager.h"
+#include "../system/system_executor.h"
 
 System_communication::System_communication()
 {
@@ -14,10 +17,108 @@ System_communication::~System_communication()
 
 }
 
+
+//检查消息是否有效, 主要检查消息类型和接受者, 判断这条消息是不是给我的.
+Error_manager System_communication::check_msg(Communication_message*  p_msg)
+{
+
+	//通过 p_msg->get_message_type() 和 p_msg->get_receiver() 判断这条消息是不是给我的.
+	if ( p_msg->get_message_type() == Communication_message::Message_type::eLocate_request_msg
+		 && p_msg->get_receiver() == Communication_message::Communicator::eMeasurer )
+	{
+		return Error_code::SUCCESS;
+	}
+	else
+	{
+//		std::cout << "System_communication::check_msg INVALID_MESSAGE" << std::endl;
+		//无效的消息,
+		return Error_code::INVALID_MESSAGE;
+	}
+}
+
+//检查执行者的状态, 判断能否处理这条消息, 需要子类重载
+Error_manager System_communication::check_executer(Communication_message*  p_msg)
+{
+	//检查对应模块的状态, 判断是否可以处理这条消息
+	//同时也要判断是否超时, 超时返回 COMMUNICATION_ANALYSIS_TIME_OUT
+	//如果处理器正在忙别的, 那么返回 COMMUNICATION_EXCUTER_IS_BUSY
+//	std::cout << "Communication_socket_base::check_msg  p_buf =  " << p_msg->get_message_buf() << std::endl;
+//	std::cout << "Communication_socket_base::check_msg   size =  " << p_msg->get_message_buf().size() << std::endl;
+
+	Error_manager t_error;
+	if ( p_msg->is_over_time() )
+	{
+		std::cout << "COMMUNICATION_ANALYSIS_TIME_OUT , " << std::endl;
+		//超时:接收方不做处理,发送方会进行超时处理
+		return Error_code::COMMUNICATION_ANALYSIS_TIME_OUT;
+	}
+	else
+	{
+
+		return System_executor::get_instance_references().check_executer(p_msg);
+	}
+	return Error_code::SUCCESS;
+}
+
+//处理消息, 需要子类重载
+Error_manager System_communication::execute_msg(Communication_message* p_msg)
+{
+	return System_executor::get_instance_references().execute_msg(p_msg);
+}
+
 //定时封装发送消息, 一般为心跳和状态信息, 需要子类重载
 Error_manager System_communication::encapsulate_send_data()
 {
-	return Communication_socket_base::encapsulate_send_data();
+	Error_manager t_error;
+
+	message::Measure_request_msg t_measure_request_msg;
+	t_measure_request_msg.mutable_base_info()->set_msg_type(message::Message_type::eLocate_request_msg);
+	t_measure_request_msg.mutable_base_info()->set_timeout_ms(5000);
+	t_measure_request_msg.mutable_base_info()->set_sender(message::Communicator::eMain);
+	t_measure_request_msg.mutable_base_info()->set_receiver(message::Communicator::eMeasurer);
+	t_measure_request_msg.set_command_id(123);
+	t_measure_request_msg.set_terminal_id(1);
+	string t_msg = t_measure_request_msg.SerializeAsString();
+	System_communication::get_instance_references().encapsulate_msg(t_msg);
+	/*
+	//创建一条状态消息
+	message::Measure_status_msg t_measure_status_msg;
+	t_measure_status_msg.mutable_base_info()->set_msg_type(message::Message_type::eLocate_status_msg);
+	t_measure_status_msg.mutable_base_info()->set_timeout_ms(5000);
+	t_measure_status_msg.mutable_base_info()->set_sender(message::Communicator::eMeasurer);
+	t_measure_status_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);
+
+	Laser_manager::Laser_manager_status t_laser_manager_status = Laser_manager::get_instance_references().get_laser_manager_status();
+	t_measure_status_msg.set_laser_manager_status((message::Laser_manager_status)t_laser_manager_status);
+
+	std::vector<Laser_base*> & t_laser_vector = Laser_manager::get_instance_references().get_laser_vector();
+	for (auto iter = t_laser_vector.begin(); iter != t_laser_vector.end(); ++iter)
+	{
+		Laser_statu t_laser_statu = (*iter)->get_laser_statu();
+		t_measure_status_msg.add_laser_statu_vector((message::Laser_statu)t_laser_statu);
+	}
+
+	Locate_manager::Locate_manager_status t_locate_manager_status = Locate_manager::get_instance_references().get_locate_manager_status();
+	t_measure_status_msg.set_locate_manager_status((message::Locate_manager_status)t_locate_manager_status);
+
+	t_measure_status_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
+	t_measure_status_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
+	t_measure_status_msg.mutable_error_manager()->set_error_description(t_error.get_error_description());
+
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_x(0);
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_y(0);
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_angle(0);
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_length(0);
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_width(0);
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_height(0);
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_wheel_base(0);
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_wheel_width(0);
+	t_measure_status_msg.mutable_locate_information_realtime()->set_locate_correct(0);
+
+	string t_msg = t_measure_status_msg.SerializeAsString();
+	System_communication::get_instance_references().encapsulate_msg(t_msg);
+*/
+	return Error_code::SUCCESS;
 }
 
 

system/system_communication.h

@@ -22,6 +22,13 @@ public:
     System_communication& operator =(const System_communication& other) = delete;
     ~System_communication();
 public://API functions
+	//检查消息是否有效, 主要检查消息类型和接受者, 判断这条消息是不是给我的.
+	virtual Error_manager check_msg(Communication_message* p_msg);
+	//检查执行者的状态, 判断能否处理这条消息, 需要子类重载
+	virtual Error_manager check_executer(Communication_message* p_msg);
+	//处理消息, 需要子类重载
+	virtual Error_manager execute_msg(Communication_message* p_msg);
+
 	//定时封装发送消息, 一般为心跳和状态信息, 需要子类重载
 	virtual Error_manager encapsulate_send_data();
 

system/system_executor.cpp

@@ -6,16 +6,32 @@
 #include "../message/measure_message.pb.h"
 #include "../laser/laser_manager.h"
 #include "../locate/locate_manager.h"
+#include "../system/system_communication.h"
 
-System_executor::System_executor(int thread_pool_size)
-:m_thread_pool(thread_pool_size)
+System_executor::System_executor()
 {
 
 }
 
 System_executor::~System_executor()
 {
+	system_executor_uninit();
+}
 
+//初始化
+Error_manager System_executor::system_executor_init(int threads_size)
+{
+	m_thread_pool.thread_pool_init(threads_size);
+	m_system_executor_status = SYSTEM_EXECUTOR_READY;
+	return Error_code::SUCCESS;
+}
+
+//反初始化
+Error_manager System_executor::system_executor_uninit()
+{
+	m_thread_pool.thread_pool_uninit();
+	m_system_executor_status = SYSTEM_EXECUTOR_UNKNOW;
+	return Error_code::SUCCESS;
 }
 
 //检查执行者的状态, 判断能否处理这条消息,
@@ -28,32 +44,70 @@ Error_manager System_executor::check_executer(Communication_message* p_msg)
 	}
 
 	Error_manager t_error;
+	//通过 p_msg->get_message_type() 和 p_msg->get_receiver() 找到处理模块的实例对象, 查询执行人是否可以处理这条消息
 	switch ( p_msg->get_message_type() )
 	{
-		case Communication_message::eLocate_request_msg:
-			if ( Laser_manager::get_instance_references().check_status() == SUCCESS &&
-			Locate_manager::get_instance_references().check_status() == SUCCESS	)
-			{
-				t_error =  Error_code::SUCCESS;
-			}
-			else if ( Laser_manager::get_instance_references().check_status() == LASER_MANAGER_STATUS_BUSY &&
-					  Locate_manager::get_instance_references().check_status() == LOCATER_MANAGER_STATUS_BUSY )
+		case Communication_message::Message_type::eLocate_request_msg:
+		{
+			Error_manager t_laser_result = Laser_manager::get_instance_references().check_status();
+			Error_manager t_executor_result = System_executor::get_instance_references().check_status();
+			Error_manager t_locate_result = Locate_manager::get_instance_references().check_status();
+
+			if (t_laser_result == SUCCESS
+				&& t_executor_result == SUCCESS
+				&& t_locate_result == SUCCESS)
 			{
-				t_error =  Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
+				return Error_code::SUCCESS;
 			}
 			else
 			{
-			    if ( Laser_manager::get_instance_references().check_status() == LASER_MANAGER_STATUS_ERROR )
-			    {
-					t_error.compare_and_cover_error(Laser_manager::get_instance_references().check_status());
-			    }
-				if ( Locate_manager::get_instance_references().check_status() == LOCATER_MANAGER_STATUS_ERROR )
+				//整合所有的错误码
+				t_error.compare_and_cover_error(t_laser_result);
+				t_error.compare_and_cover_error(t_executor_result);
+				t_error.compare_and_cover_error(t_locate_result);
+				if (t_error.get_error_level() == NEGLIGIBLE_ERROR)//一级故障,轻微故障,
 				{
-					t_error.compare_and_cover_error(Laser_manager::get_instance_references().check_status());
+					std::cout << "executer_is_busy , " << std::endl;
+					//返回繁忙之后, 通信模块1秒后再次调用check
+					return Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
+				}
+				else//返回二级故障,可以封装一条答复信息, 返回错误码
+				{
+					message::Measure_request_msg t_measure_request_msg;
+					//针对消息类型, 对消息进行二次解析
+					if (t_measure_request_msg.ParseFromString(p_msg->get_message_buf()))
+					{
+						//创建一条答复消息
+						message::Measure_response_msg t_measure_response_msg;
+						t_measure_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eLocate_response_msg);
+						t_measure_response_msg.mutable_base_info()->set_timeout_ms(5000);
+						t_measure_response_msg.mutable_base_info()->set_sender(message::Communicator::eMeasurer);
+						t_measure_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);
+
+						t_measure_response_msg.set_command_id(t_measure_request_msg.command_id());
+						t_measure_response_msg.set_terminal_id(t_measure_request_msg.terminal_id());
+						t_measure_response_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
+						t_measure_response_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
+						t_measure_response_msg.mutable_error_manager()->set_error_description(t_error.get_error_description());
+
+						string t_msg = t_measure_response_msg.SerializeAsString();
+						System_communication::get_instance_references().encapsulate_msg(t_msg);
+						LOG(INFO) << " System_executor::check_executer executer status error "<< this;
+						return t_error;
+					}
+					else
+					{
+						LOG(INFO) << " System_executor::check_executer second PARSE_ERROR "<< this;
+						return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
+											 " message::Measure_request_msg  ParseFromString error ");
+					}
 				}
 			}
 			break;
-
+		}
+		default :
+			;
+			break;
 	}
 
 
@@ -69,7 +123,6 @@ Error_manager System_executor::execute_msg(Communication_message* p_msg)
 		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
 							 "  POINTER IS NULL ");
 	}
-
 	switch ( p_msg->get_message_type() )
 	{
 		case Communication_message::eLocate_request_msg:
@@ -94,6 +147,27 @@ Error_manager System_executor::execute_msg(Communication_message* p_msg)
 	return Error_code::SUCCESS;
 }
 
+//检查状态
+Error_manager System_executor::check_status()
+{
+	if ( m_system_executor_status == SYSTEM_EXECUTOR_READY )
+	{
+		if ( m_thread_pool.thread_is_full_load() == false )
+		{
+		    return Error_code::SUCCESS;
+		}
+		else
+		{
+		    return Error_manager(Error_code::SYSTEM_EXECUTOR_STATUS_BUSY, Error_level::NEGLIGIBLE_ERROR,
+		    					" System_executor::check_status error ");
+		}
+	}
+	else
+	{
+		return Error_manager(Error_code::SYSTEM_EXECUTOR_STATUS_ERROR, Error_level::MINOR_ERROR,
+							" System_executor::check_status error ");
+	}
+}
 
 //判断是否为待机，如果已经准备好，则可以执行任务。
 bool System_executor::is_ready()
@@ -108,6 +182,10 @@ bool System_executor::is_ready()
 	}
 }
 
+System_executor::System_executor_status System_executor::get_system_executor_status()
+{
+	return m_system_executor_status;
+}
 
 
 
@@ -118,5 +196,35 @@ bool System_executor::is_ready()
 //return::void, 没有返回, 执行结果直接生成一条答复消息, 然后通过通信返回
 void System_executor::execute_for_measure(int command_id, int terminal_id)
 {
+	Error_manager t_error;
 
+	LOG(INFO) << " System_executor::execute_for_measure run "<< this;
+	//这里要处理.......以后再写
+
+	//创建一条答复消息
+	message::Measure_response_msg t_measure_response_msg;
+	t_measure_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eLocate_response_msg);
+	t_measure_response_msg.mutable_base_info()->set_timeout_ms(5000);
+	t_measure_response_msg.mutable_base_info()->set_sender(message::Communicator::eMeasurer);
+	t_measure_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);
+
+	t_measure_response_msg.set_command_id(command_id);
+	t_measure_response_msg.set_terminal_id(terminal_id);
+	t_measure_response_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
+	t_measure_response_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
+	t_measure_response_msg.mutable_error_manager()->set_error_description(t_error.get_error_description(), t_error.get_description_length());
+
+	t_measure_response_msg.mutable_locate_information()->set_locate_x(0);
+	t_measure_response_msg.mutable_locate_information()->set_locate_y(0);
+	t_measure_response_msg.mutable_locate_information()->set_locate_angle(0);
+	t_measure_response_msg.mutable_locate_information()->set_locate_length(0);
+	t_measure_response_msg.mutable_locate_information()->set_locate_width(0);
+	t_measure_response_msg.mutable_locate_information()->set_locate_height(0);
+	t_measure_response_msg.mutable_locate_information()->set_locate_wheel_base(0);
+	t_measure_response_msg.mutable_locate_information()->set_locate_wheel_width(0);
+	t_measure_response_msg.mutable_locate_information()->set_locate_correct(0);
+
+	string t_msg = t_measure_response_msg.SerializeAsString();
+	System_communication::get_instance_references().encapsulate_msg(t_msg);
+	return ;
 }

system/system_executor.h

@@ -29,24 +29,30 @@ public:
    
 private:
  // 父类的构造函数必须保护，子类的构造函数必须私有。
-   System_executor(int thread_pool_size);
+   System_executor();
 public:
     //必须关闭拷贝构造和赋值构造，只能通过 get_instance 函数来进行操作唯一的实例。
     System_executor(const System_executor& other) = delete;
     System_executor& operator =(const System_executor& other) = delete;
     ~System_executor();
 public://API functions
-
+	//初始化
+	Error_manager system_executor_init(int threads_size);
+	//反初始化
+	Error_manager system_executor_uninit();
 
 	//检查执行者的状态, 判断能否处理这条消息,
 	Error_manager check_executer(Communication_message* p_msg);
 	//处理消息的执行函数
 	Error_manager execute_msg(Communication_message* p_msg);
 
+	//检查状态
+	Error_manager check_status();
+
 	//判断是否为待机，如果已经准备好，则可以执行任务。
 	bool is_ready();
 public://get or set member variable
-
+	System_executor_status get_system_executor_status();
 public:
 	//雷达感测定位 的处理函数
 //input::command_id, 消息指令id, 由主控制系统生成的唯一码

tool/thread_pool.h

@@ -55,6 +55,9 @@ public:
 	//初始化,初始化 threads_size 数量的线程
 	void thread_pool_init(size_t threads_size);
 
+	//反初始化
+	void thread_pool_uninit();
+
 	//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
 	//input: F&& f  			函数指针(函数名)
 	//input: Args&&... args		函数的参数, 自定义
@@ -176,7 +179,22 @@ inline void Thread_pool::thread_pool_init(size_t threads_size)
 		);
 }
 
+//反初始化
+inline void Thread_pool::thread_pool_uninit()
+{
+	{
+		std::unique_lock<std::mutex> lock(queue_mutex);
+		stop = true;
+	}
+	condition.notify_all();
 
+	for (auto iter = workers.begin(); iter != workers.end(); )
+	{
+		iter->join();
+		iter = workers.erase(iter);
+	}
+	working_flag_vector.clear();
+}
 
 
 //往线程池添加执行任务, 之后会唤醒一个线程去执行他.