20210402, 调度管理开发完成

communication/communication_message.h

@@ -67,6 +67,12 @@ public:
 		eEntrance_manual_operation_msg=0xb0,            //针对出入口状态操作的手动消息
 		eProcess_manual_operation_msg=0xb1,             //针对流程的手动消息
 
+		eDispatch_plan_request_msg          = 0xe0,     //调度总规划的请求(用于启动整个调度算法)(调度管理->调度算法)
+		eDispatch_plan_response_msg         = 0xe1,     //调度总规划的答复(调度算法->调度管理)
+		eDispatch_control_request_msg       = 0xe2,     //调度控制的任务请求(调度算法->调度管理)
+		eDispatch_control_response_msg      = 0xe3,     //调度控制的任务答复(调度管理->调度算法)
+		eDispatch_manager_status_msg        = 0xea,     //调度管理的设备状态消息(调度底下所有硬件设备状态的汇总)
+		eDispatch_manager_data_msg          = 0xeb,     //调度管理的设备详细的数据信息
 	};
 
 //通讯单元

dispatch/dispatch_manager.cpp

@@ -148,6 +148,70 @@ return Error_code::SUCCESS;
 	}
 }
 
+//检查能否执行消息指令
+Error_manager Dispatch_manager::check_execute_msg(Communication_message* p_msg)
+{
+	Error_manager t_error = Dispatch_manager::get_instance_references().check_status();
+	if ( t_error == Error_code::SUCCESS )
+	{
+		return Error_code::SUCCESS;
+	}
+	else if (t_error.get_error_level() == NEGLIGIBLE_ERROR)//一级故障,轻微故障,
+	{
+		std::cout << "Dispatch_manager   _is_busy , " << std::endl;
+		//返回繁忙之后, 通信模块1秒后再次调用check
+		return Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
+	}
+
+	switch ( p_msg->get_message_type() )
+	{
+		case Communication_message::Message_type::eDispatch_request_msg:
+		{
+			message::Dispatch_request_msg t_dispatch_request_msg;
+			//针对消息类型, 对消息进行二次解析
+			if (t_dispatch_request_msg.ParseFromString(p_msg->get_message_buf()))
+			{
+				//创建一条答复消息
+				message::Dispatch_response_msg t_dispatch_response_msg;
+				t_dispatch_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eDispatch_response_msg);
+				t_dispatch_response_msg.mutable_base_info()->set_timeout_ms(5000);
+				t_dispatch_response_msg.mutable_base_info()->set_sender(message::Communicator::eDispatch_mamager);
+				t_dispatch_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);
+
+				t_dispatch_response_msg.set_command_key(t_dispatch_request_msg.command_key());
+				t_dispatch_response_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
+				t_dispatch_response_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
+				t_dispatch_response_msg.mutable_error_manager()->set_error_description(t_error.get_error_description());
+
+				std::string t_msg = t_dispatch_response_msg.SerializeAsString();
+				System_communication::get_instance_references().encapsulate_msg(t_msg);
+				LOG(INFO) << " System_executor::check_execute_msg executer status error "<< this;
+				return t_error;
+			}
+			else
+			{
+				LOG(INFO) << " System_executor::check_executer Second analysis ERROR "<< this;
+				return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
+									 " message::Measure_request_msg  ParseFromString error ");
+			}
+		}
+		case Communication_message::Message_type::eDispatch_plan_response_msg:
+		{
+			return Error_code::SUCCESS;
+			break;
+		}
+		case Communication_message::Message_type::eDispatch_control_request_msg:
+		{
+			return Error_code::SUCCESS;
+			break;
+		}
+		default :
+			//无效的消息,
+			return Error_manager(Error_code::INVALID_MESSAGE, Error_level::NEGLIGIBLE_ERROR,
+								 " INVALID_MESSAGE error ");
+			break;
+	}
+}
 //检查状态
 Error_manager Dispatch_manager::check_status()
 {
@@ -168,6 +232,112 @@ Error_manager Dispatch_manager::check_status()
 	return Error_code::SUCCESS;
 }
 
+//调度模块 //执行搬运请求(主控->调度管理)
+Error_manager Dispatch_manager::execute_for_dispatch_request_msg(message::Dispatch_request_msg& dispatch_request_msg)
+{
+	Error_manager t_error;
+	//创建调度流程
+	Dispatch_process * tp_dispatch_process(new Dispatch_process);
+	t_error = tp_dispatch_process->Dispatch_process_init(dispatch_request_msg);
+	if ( t_error != Error_code::SUCCESS )
+	{
+		return t_error;
+	}
+
+	//流程缓存到map
+	if ( tp_dispatch_process->m_dispatch_process_type == Dispatch_process::Dispatch_process_type::DISPATCH_PROCESS_STORE )
+	{
+		m_key_to_dispatch_process_store_map[tp_dispatch_process->m_command_key] = tp_dispatch_process;
+	}
+	else if( tp_dispatch_process->m_dispatch_process_type == Dispatch_process::Dispatch_process_type::DISPATCH_PROCESS_PICKUP )
+	{
+		m_key_to_dispatch_process_pickup_map[tp_dispatch_process->m_command_key] = tp_dispatch_process;
+	}
+	else
+	{
+	    return Error_manager(Error_code::DISPATCH_PROCESS_TASK_STATUS_ERROR, Error_level::MINOR_ERROR,
+	    					" tp_dispatch_process->m_dispatch_process_type PARAMRTER ERROR ");
+	}
+	
+	//把流程添加到 调度线程池里面
+	m_process_thread_queue->AddTask(tp_dispatch_process);
+	return Error_code::SUCCESS;
+}
+
+//调度模块 //调度总规划的答复(调度算法->调度管理)
+Error_manager Dispatch_manager::execute_for_dispatch_plan_response_msg(message::Dispatch_plan_response_msg &dispatch_plan_response_msg)
+{
+	Error_manager t_error;
+	//使用 command_key 找到对应的流程
+	std::string t_command_key = dispatch_plan_response_msg.command_key();
+	for (auto iter = m_key_to_dispatch_process_store_map.begin(); iter != m_key_to_dispatch_process_store_map.end(); ++iter)
+	{
+		if ( 0 == iter->first.compare(0, COMMAND_KEY_DEFAULT_LENGTH, t_command_key, 0, COMMAND_KEY_DEFAULT_LENGTH) )
+		{
+			t_error = iter->second->check_process_ready() ;
+			if ( t_error != Error_code::SUCCESS )
+			{
+				return t_error;
+			}
+			//把消息 写入流程
+			iter->second->m_dispatch_plan_response_msg = dispatch_plan_response_msg;
+			return Error_code::SUCCESS;
+		}
+	}
+	for (auto iter = m_key_to_dispatch_process_pickup_map.begin(); iter != m_key_to_dispatch_process_pickup_map.end(); ++iter)
+	{
+		if ( 0 == iter->first.compare(0, COMMAND_KEY_DEFAULT_LENGTH, t_command_key, 0, COMMAND_KEY_DEFAULT_LENGTH) )
+		{
+			t_error = iter->second->check_process_ready() ;
+			if ( t_error != Error_code::SUCCESS )
+			{
+				return t_error;
+			}
+			//把消息 写入流程
+			iter->second->m_dispatch_plan_response_msg = dispatch_plan_response_msg;
+			return Error_code::SUCCESS;
+		}
+	}
+	return Error_code::SUCCESS;
+}
+//调度模块 //调度控制的任务请求(调度算法->调度管理)
+Error_manager Dispatch_manager::execute_for_dispatch_control_request_msg(message::Dispatch_control_request_msg &dispatch_control_request_msg)
+{
+	Error_manager t_error;
+	//使用 command_key 找到对应的流程
+	std::string t_command_key = dispatch_control_request_msg.command_key();
+	for (auto iter = m_key_to_dispatch_process_store_map.begin(); iter != m_key_to_dispatch_process_store_map.end(); ++iter)
+	{
+		if ( 0 == iter->first.compare(0, COMMAND_KEY_DEFAULT_LENGTH, t_command_key, 0, COMMAND_KEY_DEFAULT_LENGTH) )
+		{
+			t_error = iter->second->check_process_ready() ;
+			if ( t_error != Error_code::SUCCESS )
+			{
+				return t_error;
+			}
+			//把消息 写入流程
+			iter->second->m_dispatch_control_request_msg = dispatch_control_request_msg;
+			return Error_code::SUCCESS;
+		}
+	}
+	for (auto iter = m_key_to_dispatch_process_pickup_map.begin(); iter != m_key_to_dispatch_process_pickup_map.end(); ++iter)
+	{
+		if ( 0 == iter->first.compare(0, COMMAND_KEY_DEFAULT_LENGTH, t_command_key, 0, COMMAND_KEY_DEFAULT_LENGTH) )
+		{
+			t_error = iter->second->check_process_ready() ;
+			if ( t_error != Error_code::SUCCESS )
+			{
+				return t_error;
+			}
+			//把消息 写入流程
+			iter->second->m_dispatch_control_request_msg = dispatch_control_request_msg;
+			return Error_code::SUCCESS;
+		}
+	}
+	return Error_code::SUCCESS;
+}
+
+
 //在流程的map 里面释放指定的流程
 Error_manager Dispatch_manager::release_dispatch_process(std::string command_key)
 {

dispatch/dispatch_manager.h

@@ -7,6 +7,10 @@
 
 
 #include "../error_code/error_code.h"
+#include "../communication/communication_message.h"
+#include "../system/system_communication.h"
+
+
 #include "../tool/singleton.h"
 #include "../tool/thread_condition.h"
 #include "../tool/TaskQueue/TQFactory.h"
@@ -78,9 +82,18 @@ public://API functions
 	//对外的接口函数，负责接受并处理任务单，
 	Error_manager execute_task(Dispatch_manager::Dispatch_motion_direction dispatch_motion_direction);
 
+	//检查能否执行消息指令
+	Error_manager check_execute_msg(Communication_message* p_msg);
 	//检查状态
 	Error_manager check_status();
 
+	//调度模块 //执行搬运请求(主控->调度管理)
+	Error_manager execute_for_dispatch_request_msg(message::Dispatch_request_msg &dispatch_request_msg);
+	//调度模块 //调度总规划的答复(调度算法->调度管理)
+	Error_manager execute_for_dispatch_plan_response_msg(message::Dispatch_plan_response_msg &dispatch_plan_response_msg);
+	//调度模块 //调度控制的任务请求(调度算法->调度管理)
+	Error_manager execute_for_dispatch_control_request_msg(message::Dispatch_control_request_msg &dispatch_control_request_msg);
+
 
 	//在流程的map 里面释放指定的流程
 	Error_manager release_dispatch_process(std::string command_key);
@@ -94,6 +107,15 @@ public://member variable
 	Dispatch_manager_status						m_dispatch_manager_status;			//调度管理 的状态
 	int 										m_dispatch_id;						//调度模块的id, (楚天项目就是单元号, 0~2)
 
+	//流程控制
+	std::mutex                              	m_lock;        						//线程池的锁, 增删流程时要加锁.
+	tq::IQueue*                         		m_process_thread_queue;         	//指令流程线程池, 管理线程内存, 负责启动和回收线程内存资源,不负责控制流程.
+
+	//流程管理
+	std::map<std::string, Dispatch_process*>	m_key_to_dispatch_process_store_map;	//存车流程的map
+	std::map<std::string, Dispatch_process*>	m_key_to_dispatch_process_pickup_map;	//取车流程的map
+
+
 	//硬件资源
 	int 														m_catcher_size;					//抓车器的数量, 默认1个
 	std::map<int, std::shared_ptr<Dispatch_device_base>>		m_catcher_map;					//抓车器的对象实例，内存由本类管理
@@ -102,19 +124,10 @@ public://member variable
 	int 														m_passageway_size;				//通道口的数量, 默认7个
 	std::map<int, std::shared_ptr<Dispatch_device_base>>		m_passageway_map;				//通道口的对象实例，内存由本类管理
 
-
-	//流程控制
-	std::mutex                              	m_lock;        						//线程池的锁, 增删流程时要加锁.
-	tq::IQueue*                         		m_process_thread_queue;         	//指令流程线程池, 管理线程内存, 负责启动和回收线程内存资源,不负责控制流程.
+	//调度总管理的线程, 负责资源分配
 	std::thread*                        		m_dispatch_manager_thread;        	//调度总管理的线程, 总控全局, 控制每个流程的先后顺序, 并合理的分配资源.
 	Thread_condition				    		m_dispatch_manager_condition;		//调度总管理的条件变量, 总控全局, 控制每个流程的先后顺序, 并合理的分配资源.
 
-	//流程管理
-	std::map<std::string, Dispatch_process*>	m_key_to_dispatch_process_store_map;	//存车流程的map
-	std::map<std::string, Dispatch_process*>	m_key_to_dispatch_process_pickup_map;	//取车流程的map
-
-
-
 private:
 
 };

dispatch/dispatch_process.cpp

@@ -14,8 +14,8 @@ Dispatch_process::Dispatch_process()
 	m_dispatch_destination = 0;
 	m_wheel_base = 0;
 
-	m_dispatch_process_catcher_motion = CATCHER_MOTION_UNKNOW;
-	m_dispatch_process_carrier_motion = CARRIER_MOTION_UNKNOW;
+//	m_dispatch_process_catcher_motion = CATCHER_MOTION_UNKNOW;
+//	m_dispatch_process_carrier_motion = CARRIER_MOTION_UNKNOW;
 }
 
 Dispatch_process::~Dispatch_process()
@@ -24,7 +24,7 @@ Dispatch_process::~Dispatch_process()
 }
 
 //初始化, 就把主控发送的请求传入即可.
-Error_manager Dispatch_process::Dispatch_process_init(message::Dispatch_request_msg dispatch_request_msg)
+Error_manager Dispatch_process::Dispatch_process_init(message::Dispatch_request_msg &dispatch_request_msg)
 {
 	if ( dispatch_request_msg.base_info().has_timeout_ms() )
 	{
@@ -77,6 +77,20 @@ Error_manager Dispatch_process::Dispatch_process_uninit()
 	return Error_code::SUCCESS;
 }
 
+//检查流程是否空闲待机
+Error_manager Dispatch_process::check_process_ready()
+{
+	if ( m_dispatch_process_status == DISPATCH_PROCESS_READY )
+	{
+	    return Error_code::SUCCESS;
+	}
+	else
+	{
+	    return Error_manager(Error_code::DISPATCH_PROCESS_IS_NOT_READY, Error_level::MINOR_ERROR,
+	    					" Dispatch_process::check_process_ready() fun error ");
+	}
+}
+
 void Dispatch_process::Main()
 {
 	Error_manager t_error;
@@ -88,7 +102,7 @@ void Dispatch_process::Main()
 
 		switch ( m_dispatch_process_status )
 		{
-			case DISPATCH_PROCESS_CREATED:
+			case DISPATCH_PROCESS_CREATED://流程创建,
 			{
 				//检查调度请求
 				m_result = check_dispatch_request_msg();
@@ -108,36 +122,42 @@ void Dispatch_process::Main()
 				m_dispatch_process_status = DISPATCH_PROCESS_READY;
 				break;
 			}
-			case DISPATCH_PROCESS_READY:
+			case DISPATCH_PROCESS_READY://流程准备，待机
 			{
 				//等待控制指令
 				m_result = wait_dispatch_control_request_msg();
-				if ( m_result !=Error_code::SUCCESS)
-				{
-					//不成功, 就表示没有新的指令, 那么什么都不做, 原地待命
-				}
-				else
+				if ( m_result ==Error_code::SUCCESS)
 				{
 					//流程正常, 就去连接设备
 					m_dispatch_process_status = DISPATCH_PROCESS_CONNECT_DEVICE;
 					break;
+
 				}
+				else if ( m_result !=Error_code::NODATA )
+				{
+					m_dispatch_process_status = DISPATCH_PROCESS_FAULT;
+					break;
+				}
+				//else nodata, 就表示没有新的指令, 那么什么都不做, 原地待命
 
 				//等待调度总计划答复
 				m_result = wait_dispatch_plan_response_msg();
-				if ( m_result !=Error_code::SUCCESS)
-				{
-					//不成功, 就表示没有总计划答复, 那么什么都不做, 原地待命
-				}
-				else
+				if ( m_result ==Error_code::SUCCESS)
 				{
 					//流程正常, 就进入完成状态,
 					m_dispatch_process_status = DISPATCH_PROCESS_OVER;
 					break;
 				}
+				else if ( m_result !=Error_code::NODATA )
+				{
+					m_dispatch_process_status = DISPATCH_PROCESS_FAULT;
+					break;
+				}
+				//else nodata, 就表示没有新的指令, 那么什么都不做, 原地待命
+
 				break;
 			}
-			case DISPATCH_PROCESS_CONNECT_DEVICE:
+			case DISPATCH_PROCESS_CONNECT_DEVICE://流程 连接设备
 			{
 				//连接调度设备
 				m_result = connect_dispatch_device();
@@ -149,19 +169,51 @@ void Dispatch_process::Main()
 				//流程正常, 就进入工作状态,
 				m_dispatch_process_status = DISPATCH_PROCESS_WORKING;
 				break;
-
+			}
+			case DISPATCH_PROCESS_WORKING://流程工作正忙, 进行长流程
+			{
+				//执行调度控制指令, 并根据完成情况给答复
+				m_result = excute_dispatch_control();
+				if ( m_result == Error_code::NODATA )
+				{
+					//继续 长流程, 什么也不做
+				}
+				else
+				{
+					//长流程结束, 就答复 control_response_msg
+					// 注:这里执行调度控制, 即使报错了 也要答复给调度控制, 交给调度控制来进行决策.
+					m_dispatch_process_status = DISPATCH_PROCESS_RESPONSE;
+				}
 				break;
 			}
-			case DISPATCH_PROCESS_WORKING:
+			case DISPATCH_PROCESS_RESPONSE://流程 给调度控制答复
 			{
-
+				//发送调度控制答复, 发给调度控制的
+				t_error = send_dispatch_control_response_msg();
+				m_result = t_error;
+				if ( m_result !=Error_code::SUCCESS)
+				{
+					m_dispatch_process_status = DISPATCH_PROCESS_FAULT;
+					break;
+				}
+				//流程正常, 就进入等待状态, 等待调度控制发送动作指令
+				m_dispatch_process_status = DISPATCH_PROCESS_DISCONNECT_DEVICE;
 				break;
 			}
-			case DISPATCH_PROCESS_RESPONSE:
+			case DISPATCH_PROCESS_DISCONNECT_DEVICE://流程 解除设备
 			{
+				//断开调度设备, 释放任务单 与设备解除连接
+				m_result = disconnect_dispatch_device();
+				if ( m_result !=Error_code::SUCCESS)
+				{
+					m_dispatch_process_status = DISPATCH_PROCESS_FAULT;
+					break;
+				}
+				//流程正常, 就回到 等待状态, 等待调度控制发送动作指令
+				m_dispatch_process_status = DISPATCH_PROCESS_READY;
 				break;
 			}
-			case DISPATCH_PROCESS_OVER:
+			case DISPATCH_PROCESS_OVER://流程完成
 			{
 				//发送调度答复, 发给主控的
 				m_result = send_dispatch_response_msg();
@@ -174,7 +226,7 @@ void Dispatch_process::Main()
 				m_dispatch_process_status = DISPATCH_PROCESS_RELEASE;
 				break;
 			}
-			case DISPATCH_PROCESS_RELEASE:
+			case DISPATCH_PROCESS_RELEASE://流程释放
 			{
 				//通知调度管理, 释放资源,
 				m_result = release_resource();
@@ -188,7 +240,7 @@ void Dispatch_process::Main()
 				return;
 				break;
 			}
-			case DISPATCH_PROCESS_FAULT:
+			case DISPATCH_PROCESS_FAULT://故障
 			{
 				Exception_handling();
 				//在这里, 整个流程彻底结束, 之后线程池会自动回收 这个流程对象的资源
@@ -224,7 +276,7 @@ Error_manager Dispatch_process::send_dispatch_plan_request_msg()
 	m_dispatch_plan_request_msg.mutable_base_info()->set_timeout_ms(m_timeout_ms);
 	m_dispatch_plan_request_msg.mutable_base_info()->set_sender(message::Communicator::eDispatch_mamager);
 	m_dispatch_plan_request_msg.mutable_base_info()->set_receiver(message::Communicator::eDispatch_control);
-	m_dispatch_plan_request_msg.set_command_key(m_command_key);
+	m_dispatch_plan_request_msg.set_command_key(m_dispatch_request_msg.command_key());
 
 	m_dispatch_plan_request_msg.set_dispatch_task_type((message::Dispatch_task_type)m_dispatch_process_type);
 	m_dispatch_plan_request_msg.set_dispatch_source(m_dispatch_source);
@@ -379,14 +431,128 @@ Error_manager Dispatch_process::connect_dispatch_device()
 Error_manager Dispatch_process::excute_dispatch_control()
 {
 //设备的动作也使用外部的Main()的线程来循环
+	switch ( m_dispatch_control_request_msg.dispatch_task_type() )
+	{
+		case message::Dispatch_task_type::ROBOT_CATCH_CAR_FROM_INLET:
+		{
+			return excute_robot_catch_car_from_inlet();
+			break;
+		}
+		case message::Dispatch_task_type::ROBOT_PUT_CAR_TO_CARRIER:
+		{
+			return excute_robot_put_car_to_carrier();
+			break;
+		}
+		case message::Dispatch_task_type::ROBOT_CATCH_CAR_FROM_CARRIER:
+		{
+			return excute_robot_catch_car_from_carrier();
+			break;
+		}
+		case message::Dispatch_task_type::ROBOT_PUT_CAR_TO_OUTLET:
+		{
+			return excute_robot_put_car_to_outlet();
+			break;
+		}
+		case message::Dispatch_task_type::ROBOT_MOVE:
+		{
+			return excute_robot_move();
+			break;
+		}
+		case message::Dispatch_task_type::CARRIER_RECEIVE_CAR_FROM_ROBOT:
+		{
+			return excute_carrier_receive_car_from_robot();
+			break;
+		}
+		case message::Dispatch_task_type::CARRIER_STORE_CAR_TO_PARKINGSPACE:
+		{
+			return excute_carrier_store_car_to_parkingspace();
+			break;
+		}
+		case message::Dispatch_task_type::CARRIER_STORE_CAR_TO_PARKINGSPACE_EX:
+		{
+			return excute_carrier_store_car_to_parkingspace_ex();
+			break;
+		}
+		case message::Dispatch_task_type::CARRIER_PICKUP_CAR_FROM_PARKINGSPACE:
+		{
+			return excute_carrier_pickup_car_from_parkingspace();
+			break;
+		}
+		case message::Dispatch_task_type::CARRIER_PICKUP_CAR_FROM_PARKINGSPACE_EX:
+		{
+			return excute_carrier_pickup_car_from_parkingspace_ex();
+			break;
+		}
+		case message::Dispatch_task_type::CARRIER_DELIVER_CAR_TO_ROBOT:
+		{
+			return excute_carrier_deliver_car_to_robot();
+			break;
+		}
+		case message::Dispatch_task_type::CARRIER_MOVE:
+		{
+			return excute_carrier_move();
+			break;
+		}
+		default:
+		{
+			return Error_manager(Error_code::DISPATCH_PROCESS_TASK_STATUS_ERROR, Error_level::MINOR_ERROR,
+								 "Dispatch_process::excute_dispatch_control() fun error ");
+			break;
+		}
+	}
 	return Error_code::SUCCESS;
 }
-
-//连接调度设备, 释放任务单 与设备解除连接
-Error_manager Dispatch_process::disconnect_dispatch_device()
+//发送调度控制答复, 发给调度控制的
+Error_manager Dispatch_process::send_dispatch_control_response_msg()
 {
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	m_dispatch_control_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eDispatch_control_response_msg);
+	m_dispatch_control_response_msg.mutable_base_info()->set_timeout_ms(m_timeout_ms);
+	m_dispatch_control_response_msg.mutable_base_info()->set_sender(message::Communicator::eDispatch_mamager);
+	m_dispatch_control_response_msg.mutable_base_info()->set_receiver(message::Communicator::eDispatch_control);
+	m_dispatch_control_response_msg.set_command_key(m_dispatch_control_request_msg.command_key());
+
+	m_dispatch_control_response_msg.set_dispatch_task_type(m_dispatch_control_request_msg.dispatch_task_type());
+	m_dispatch_control_response_msg.set_dispatch_device_type(m_dispatch_control_request_msg.dispatch_device_type());
+	m_dispatch_control_response_msg.set_dispatch_source(m_dispatch_control_request_msg.dispatch_source());
+	m_dispatch_control_response_msg.set_dispatch_destination(m_dispatch_control_request_msg.dispatch_destination());
+
+	m_dispatch_control_response_msg.mutable_error_manager()->set_error_code(m_result.get_error_code());
+	m_dispatch_control_response_msg.mutable_error_manager()->set_error_level((message::Error_level)m_result.get_error_level());
+	m_dispatch_control_response_msg.mutable_error_manager()->set_error_description(m_result.get_error_description(), m_result.get_description_length());
+
+	std::string t_msg = m_dispatch_control_response_msg.SerializeAsString();
+	System_communication::get_instance_references().encapsulate_msg(t_msg);
 	return Error_code::SUCCESS;
 }
+//断开调度设备, 释放任务单 与设备解除连接
+Error_manager Dispatch_process::disconnect_dispatch_device()
+{
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	Error_manager t_error;
+
+	//机器手
+	if ( m_dispatch_control_request_msg.dispatch_device_type() >= message::Dispatch_device_type::ROBOT_1 &&
+		 m_dispatch_control_request_msg.dispatch_device_type() <= message::Dispatch_device_type::ROBOT_2 )
+	{
+		//收回任务
+		mp_catcher_task->set_task_statu(Task_Base::Task_statu::TASK_WITHDRAW);
+		//释放设备和任务单的指针
+		mp_catcher_task.reset();
+		mp_catcher.reset();
+	}
+	//搬运器
+	else if ( m_dispatch_control_request_msg.dispatch_device_type() >= message::Dispatch_device_type::CARRIER_1 &&
+			  m_dispatch_control_request_msg.dispatch_device_type() <= message::Dispatch_device_type::CARRIER_3 )
+	{
+		//收回任务
+		mp_carrier_task->set_task_statu(Task_Base::Task_statu::TASK_WITHDRAW);
+		//释放设备和任务单的指针
+		mp_carrier_task.reset();
+		mp_carrier.reset();
+	}
+
+	return Error_code::SUCCESS;}
 
 //等待调度总计划答复
 Error_manager Dispatch_process::wait_dispatch_plan_response_msg()
@@ -411,7 +577,7 @@ Error_manager Dispatch_process::send_dispatch_response_msg()
 	m_dispatch_response_msg.mutable_base_info()->set_timeout_ms(m_timeout_ms);
 	m_dispatch_response_msg.mutable_base_info()->set_sender(message::Communicator::eDispatch_mamager);
 	m_dispatch_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);
-	m_dispatch_response_msg.set_command_key(m_command_key);
+	m_dispatch_response_msg.set_command_key(m_dispatch_request_msg.command_key());
 
 	m_dispatch_response_msg.mutable_error_manager()->CopyFrom(m_dispatch_plan_response_msg.error_manager());
 
@@ -591,8 +757,8 @@ Error_manager Dispatch_process::excute_robot_put_car_to_carrier()
 	if ( tp_catcher_task->m_step == 1 )//检查姿态
 	{
 		if ( tp_catcher->m_actual_load_status == Dispatch_device_base::Load_status::HAVE_CAR &&
-		tp_catcher->m_actual_clamp_motion1 == Dispatch_device_base::Clamp_motion::E_CLAMP_TIGHT &&
-		(Common_data::approximate(tp_catcher->m_actual_b, 90, 0.01) || Common_data::approximate(tp_catcher->m_actual_b, 270, 0.01) ) )
+			 tp_catcher->m_actual_clamp_motion1 == Dispatch_device_base::Clamp_motion::E_CLAMP_TIGHT &&
+			 (Common_data::approximate(tp_catcher->m_actual_b, 90, 0.01) || Common_data::approximate(tp_catcher->m_actual_b, 270, 0.01) ) )
 		{
 			//检测正常, 直接跳过即可
 			tp_catcher_task->m_step +=2;
@@ -628,7 +794,7 @@ Error_manager Dispatch_process::excute_robot_put_car_to_carrier()
 	{
 		float temp_y = tp_dispatch_coordinates->m_carrier_default_y1_back - (m_wheel_base /2);
 		if ( Common_data::approximate(tp_catcher->m_actual_x, m_destination_coordinates.x, 0.01) &&
-		Common_data::approximate(tp_catcher->m_actual_y, temp_y, 0.01))
+			 Common_data::approximate(tp_catcher->m_actual_y, temp_y, 0.01))
 		{
 			//检测正常, 直接跳过即可
 			tp_catcher_task->m_step +=2;
@@ -1023,7 +1189,7 @@ Error_manager Dispatch_process::excute_carrier_receive_car_from_robot()
 		if ( tp_carrier->m_actual_load_status == Dispatch_device_base::Load_status::NO_CAR )
 		{
 			if ( tp_carrier_task->m_request_clamp_motion == Carrier_task::Clamp_motion::E_CLAMP_LOOSE &&
-			Common_data::approximate(m_wheel_base, tp_carrier->m_actual_y1-tp_carrier->m_actual_y2, 0.01))
+				 Common_data::approximate(m_wheel_base, tp_carrier->m_actual_y1-tp_carrier->m_actual_y2, 0.01))
 			{
 				tp_carrier_task->m_step +=2;
 			}
@@ -1154,7 +1320,7 @@ Error_manager Dispatch_process::excute_carrier_receive_car_from_robot()
 	}
 	if ( tp_carrier_task->m_step == 15 )
 	{
-	    return Error_code::SUCCESS;
+		return Error_code::SUCCESS;
 	}
 }
 //搬运器把车存到停车位上(例如:小跑车夹车后,搬运器移动到56号停车位,然后小跑车将车存入车位,之后搬运器退回至电梯井)
@@ -1184,7 +1350,7 @@ Error_manager Dispatch_process::excute_carrier_store_car_to_parkingspace()
 	{
 		//检查姿态(注注注注注意了, 调试阶段是无车, 真实环境是有车的)
 		if ( tp_carrier->m_actual_load_status == Dispatch_device_base::Load_status::NO_CAR &&
-		tp_carrier->m_actual_clamp_motion1 == Dispatch_device_base::Clamp_motion::E_CLAMP_LOOSE)
+			 tp_carrier->m_actual_clamp_motion1 == Dispatch_device_base::Clamp_motion::E_CLAMP_LOOSE)
 		{
 			//检测正常, 直接跳过即可
 			tp_carrier_task->m_step +=2;
@@ -1320,8 +1486,8 @@ Error_manager Dispatch_process::excute_carrier_store_car_to_parkingspace()
 	}
 	if ( tp_carrier_task->m_step == 17 )//小跑车 进入车位
 	{
-			carrier_move_y(tp_carrier, tp_carrier_task, tp_dispatch_coordinates, tp_dispatch_coordinates->m_carrier_default_y_leave);
-			tp_carrier_task->m_step++;
+		carrier_move_y(tp_carrier, tp_carrier_task, tp_dispatch_coordinates, tp_dispatch_coordinates->m_carrier_default_y_leave);
+		tp_carrier_task->m_step++;
 	}
 	if ( tp_carrier_task->m_step == 18 )
 	{
@@ -2012,10 +2178,10 @@ Error_manager Dispatch_process::excute_carrier_deliver_car_to_robot()
 	{
 		//检查姿态
 		if ( tp_carrier->m_actual_load_status == Dispatch_device_base::Load_status::HAVE_CAR &&
-		tp_carrier->m_actual_clamp_motion1 == Dispatch_device_base::Clamp_motion::E_CLAMP_TIGHT)
+			 tp_carrier->m_actual_clamp_motion1 == Dispatch_device_base::Clamp_motion::E_CLAMP_TIGHT)
 		{
 			//检测正常, 直接跳过
-				tp_carrier_task->m_step +=2;
+			tp_carrier_task->m_step +=2;
 		}
 		else
 		{

dispatch/dispatch_process.h

@@ -56,8 +56,9 @@ public:
 		DISPATCH_PROCESS_CONNECT_DEVICE			= 3, 	//流程 连接设备
 		DISPATCH_PROCESS_WORKING				= 4, 	//流程工作正忙, 进行长流程
 		DISPATCH_PROCESS_RESPONSE				= 5, 	//流程 给调度控制答复
-		DISPATCH_PROCESS_OVER					= 6, 	//流程完成
-		DISPATCH_PROCESS_RELEASE				= 7, 	//流程释放
+		DISPATCH_PROCESS_DISCONNECT_DEVICE		= 6, 	//流程 解除设备
+		DISPATCH_PROCESS_OVER					= 7, 	//流程完成
+		DISPATCH_PROCESS_RELEASE				= 8, 	//流程释放
 
 		DISPATCH_PROCESS_FAULT					= 10,	//故障
 		DISPATCH_PROCESS_MOTION_FAILED			= 11,	//单个小动作执行失败
@@ -91,10 +92,12 @@ public:
 	~Dispatch_process();
 public://API functions
 	//初始化, 就把主控发送的请求传入即可.
-	Error_manager Dispatch_process_init(message::Dispatch_request_msg dispatch_request_msg);
+	Error_manager Dispatch_process_init(message::Dispatch_request_msg &dispatch_request_msg);
 	//反初始化
 	Error_manager Dispatch_process_uninit();
 
+	//检查流程是否空闲待机
+	Error_manager check_process_ready();
 public://get or set member variable
 
 protected://主流程
@@ -113,7 +116,9 @@ protected://主流程
 	Error_manager connect_dispatch_device();
 	//执行调度控制指令, 并根据完成情况给答复
 	Error_manager excute_dispatch_control();
-	//连接调度设备, 释放任务单 与设备解除连接
+	//发送调度控制答复, 发给调度控制的
+	Error_manager send_dispatch_control_response_msg();
+	//断开调度设备, 释放任务单 与设备解除连接
 	Error_manager disconnect_dispatch_device();
 
 	//等待调度总计划答复
@@ -197,8 +202,6 @@ protected://短流程
 	Error_manager carrier_joint_x(Carrier * tp_carrier, Carrier_task * tp_carrier_task, Dispatch_coordinates * tp_dispatch_coordinates, Carrier_task::Joint_motion target);
 	//搬运器 修正轴距
 	Error_manager carrier_adjust_wheel_base(Carrier * tp_carrier, Carrier_task * tp_carrier_task, Dispatch_coordinates * tp_dispatch_coordinates);
-//	//搬运器调整到 正常待机的姿态
-//	Error_manager carrier_adjust_to_ready(Carrier * tp_carrier, Carrier_task * tp_carrier_task, Dispatch_coordinates * tp_dispatch_coordinates);
 
 public://member variable
 	Dispatch_process_status					m_dispatch_process_status;	//调度流程的状态, 控制步骤
@@ -206,8 +209,8 @@ public://member variable
 	//流程总规划数据, 外部指令
 	std::mutex                          	m_lock;
 	Dispatch_process_type					m_dispatch_process_type;	//调度任务类型
-	int 									m_dispatch_source;			//调度的起点,源头
-	int 									m_dispatch_destination;		//调度的终点,目的地
+	int 									m_dispatch_source;			//调度的起点,源头 (Dispatch_plan 总计划的起点)
+	int 									m_dispatch_destination;		//调度的终点,目的地(Dispatch_plan 总计划的终点)
 	Common_data::Car_measure_information	m_car_measure_information;	//整车的测量信息
 	Common_data::Parkspace_information		m_parkspace_information;	//单个车位基本信息与状态信息,车位信息以及车位上的车辆信息
 
@@ -215,11 +218,11 @@ public://member variable
 	int 									m_timeout_ms;						//超时时间,单位ms
 	std::chrono::system_clock::time_point	m_start_time;						//流程开始时间
 	Error_manager 							m_result;							//流程的执行结果
-	Point3D_tool::Point3D					m_source_coordinates;				//起点 的坐标
-	Point3D_tool::Point3D					m_destination_coordinates;			//终点 的坐标
+	Point3D_tool::Point3D					m_source_coordinates;				//起点 的坐标 (Dispatch_control 长流程的起点)
+	Point3D_tool::Point3D					m_destination_coordinates;			//终点 的坐标 (Dispatch_control 长流程的终点)
 	float 									m_wheel_base;						//轮距
-	Dispatch_process_catcher_motion			m_dispatch_process_catcher_motion;	//机器手的动作, 控制步骤
-	Dispatch_process_carrier_motion			m_dispatch_process_carrier_motion;	//搬运器的动作, 控制步骤
+//	Dispatch_process_catcher_motion			m_dispatch_process_catcher_motion;	//机器手的动作, 控制步骤
+//	Dispatch_process_carrier_motion			m_dispatch_process_carrier_motion;	//搬运器的动作, 控制步骤
 
 
 

error_code/error_code.h

@@ -209,12 +209,12 @@ enum Error_code
     LOCATER_3DCNN_PCA_OUT_CLOUD_EMPTY,					//定位3DCNN模块，pca输出点云为空
 
     //System_manager error from 0x04010000-0x0401FFFF
-    SYSTEM_READ_PARAMETER_ERROR=0x04010100,
+    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_NOT_READY								=0x04010200,
     TERMINOR_INPUT_LASER_NULL,
     TERMINOR_NOT_CONTAINS_LASER,
     TERMINOR_INPUT_PLC_NULL,
@@ -227,7 +227,7 @@ enum Error_code
 
     ////Hardware limit from 0x05010000 - 0x0501ffff
     ///railing.cpp from 0x05010100-0x050101ff
-    HARDWARE_LIMIT_LEFT_RAILING=0x05010100,         //左栏杆限制
+    HARDWARE_LIMIT_LEFT_RAILING						=0x05010100,         //左栏杆限制
     HARDWARE_LIMIT_RAILING_PARAMETER_ERROR,
     HARDWARE_LIMIT_RAILING_ERROR,
     HARDWARE_LIMIT_CENTER_X_LEFT,
@@ -243,7 +243,7 @@ enum Error_code
 
 
 
-    WANJI_LIDAR_DEVICE_ERROR_BASE=0x06080000,						//万集设备模块，错误基类
+    WANJI_LIDAR_DEVICE_ERROR_BASE					=0x06080000,						//万集设备模块，错误基类
 	WANJI_LIDAR_DEVICE_STATUS_BUSY,									//万集设备模块，状态正忙
 	WANJI_LIDAR_DEVICE_STATUS_ERROR,								//万集设备模块，状态错误
 	WANJI_LIDAR_DEVICE_TASK_TYPE_ERROR,								//万集设备模块，任务类型错误
@@ -252,7 +252,7 @@ enum Error_code
 
 
 	//wj_lidar error from 0x06010000-0x0601FFFF
-	WJ_LIDAR_COMMUNICATION_ERROR_BASE=0x06010000,
+	WJ_LIDAR_COMMUNICATION_ERROR_BASE				=0x06010000,
 	WJ_LIDAR_COMMUNICATION_UNINITIALIZED,							//万集通信,未初始化
 	WJ_LIDAR_COMMUNICATION_DISCONNECT,								//万集通信,断连
 	WJ_LIDAR_COMMUNICATION_FAULT,									//万集通信,故障
@@ -263,7 +263,7 @@ enum Error_code
     WJ_LIDAR_GET_CLOUD_TIMEOUT,
 
     //wj lidar protocol error from 0x06020000-0x0602FFFF
-        WJ_PROTOCOL_ERROR_BASE=0x06020000,
+        WJ_PROTOCOL_ERROR_BASE						=0x06020000,
 	WJ_PROTOCOL_STATUS_BUSY,										//万集解析, 状态正忙
 	WJ_PROTOCOL_STATUS_ERROR,										//系统执行模块, 状态错误
     WJ_PROTOCOL_INTEGRITY_ERROR,
@@ -272,7 +272,7 @@ enum Error_code
     WJ_PROTOCOL_EXCEED_MAX_SIZE,
 
     //wj region detect error from 0x06030000-0x0603FFFF
-	WJ_REGION_ERROR_BASE					= 0x06030000,
+	WJ_REGION_ERROR_BASE							= 0x06030000,
 	WJ_REGION_EMPTY_CLOUD,
 	WJ_REGION_EMPTY_NO_WHEEL_INFORMATION,
     WJ_REGION_RECTANGLE_ANGLE_ERROR,
@@ -281,7 +281,7 @@ enum Error_code
     WJ_REGION_CLUSTER_SIZE_ERROR,
 
     //wj manager error from 0x06040000-0x0604FFFF
-    WJ_MANAGER_UNINITIALIZED=0x06040000,
+    WJ_MANAGER_UNINITIALIZED						=0x06040000,
     WJ_MANAGER_LIDAR_DISCONNECTED,
     WJ_MANAGER_PLC_DISCONNECTED,
     WJ_MANAGER_EMPTY_CLOUD,
@@ -355,8 +355,10 @@ enum Error_code
 	DISPATCH_DEVICE_TASK_NOTHINGNESS,					//调度设备模块，任务不存在
 
 	DISPATCH_PROCESS_ERROR_BASE								= 0x13020000,
+	DISPATCH_PROCESS_IS_NOT_READY,						//调度流程, 不在准备状态
 	DISPATCH_PROCESS_DEVICE_TYPE_ERROR,					//调度流程, 设备类型错误
-	DISPATCH_PROCESS_DEVICE_STATUS_ERROR,				//调度流程, 设备类型错误
+	DISPATCH_PROCESS_DEVICE_STATUS_ERROR,				//调度流程, 设备状态错误
+	DISPATCH_PROCESS_TASK_STATUS_ERROR,					//调度流程, 任务类型错误
 
 
 	CARRIER_ERROR_BASE								= 0x13030000,

main.cpp

@@ -57,9 +57,12 @@ using namespace std;
 
 int main(int argc,char* argv[])
 {
-	Dispatch_coordinates::get_instance_references().dispatch_coordinates_init();
+	std::string aaa = "asdzxc";
+	std::string bbb = "asdzxc";
 
+	int x = aaa.compare(0,8, bbb, 0, 8);
 
+	std::cout << " huli test :::: " << " x = " << x << std::endl;
 	return 0;
 
 

system/system_executor.cpp

@@ -40,34 +40,33 @@ Error_manager System_executor::check_msg(Communication_message* p_msg)
 							 "  POINTER IS NULL ");
 	}
 
-	//检查消息类型
-	switch ( p_msg->get_message_type() )
+	//检查接受人
+	if ( p_msg->get_receiver() == Communication_message::Communicator::eDispatch )
 	{
-		case Communication_message::Message_type::eDispatch_request_msg:
+		//检查消息类型
+		switch ( p_msg->get_message_type() )
 		{
-			//检查接受人
-			if ( p_msg->get_receiver() == Communication_message::Communicator::eDispatch )
+			case Communication_message::Message_type::eDispatch_request_msg:
 			{
-				message::Dispatch_request_msg t_dispatch_request_msg;
-				//针对消息类型, 对消息进行二次解析
-				if (t_dispatch_request_msg.ParseFromString(p_msg->get_message_buf()))
-				{
-					int t_dispatch_id = Dispatch_manager::get_instance_references().get_dispatch_id();
-					//检查终端id
-					if ( t_dispatch_request_msg.terminal_id() == t_dispatch_id*2+0 || t_dispatch_request_msg.terminal_id() == t_dispatch_id*2+1)
-					{
-						return Error_code::SUCCESS;
-					}
-				}
+				return Error_code::SUCCESS;
+				break;
 			}
-			break;
+			case Communication_message::Message_type::eDispatch_plan_response_msg:
+			{
+				return Error_code::SUCCESS;
+				break;
+			}
+			case Communication_message::Message_type::eDispatch_control_request_msg:
+			{
+				return Error_code::SUCCESS;
+				break;
+			}
+			default :
+				;
+				break;
 		}
-		default :
-			;
-			break;
 	}
 
-
 	//无效的消息,
 	return Error_manager(Error_code::INVALID_MESSAGE, Error_level::NEGLIGIBLE_ERROR,
 						 " INVALID_MESSAGE error ");
@@ -81,71 +80,27 @@ Error_manager System_executor::check_executer(Communication_message* p_msg)
 							 "  POINTER IS NULL ");
 	}
 
-	Error_manager t_error;
-	//通过 p_msg->get_message_type() 和 p_msg->get_receiver() 找到处理模块的实例对象, 查询执行人是否可以处理这条消息
-	switch ( p_msg->get_message_type() )
+	//检查执行线程池
+	Error_manager t_executor_result = System_executor::get_instance_references().check_status();
+	if (t_executor_result.get_error_level() == NEGLIGIBLE_ERROR)//一级故障,轻微故障,
 	{
-
-		case Communication_message::Message_type::eDispatch_request_msg:
-		{
-			Error_manager t_dispatch_result = Dispatch_manager::get_instance_references().check_status();
-			Error_manager t_executor_result = System_executor::get_instance_references().check_status();
-			if (t_dispatch_result == SUCCESS
-				&& t_executor_result == SUCCESS)
-			{
-				return Error_code::SUCCESS;
-			}
-			else
-			{
-				//整合所有的错误码
-				t_error.compare_and_cover_error(t_dispatch_result);
-				t_error.compare_and_cover_error(t_executor_result);
-				if (t_error.get_error_level() == NEGLIGIBLE_ERROR)//一级故障,轻微故障,
-				{
-					std::cout << "executer_is_busy , " << std::endl;
-					//返回繁忙之后, 通信模块1秒后再次调用check
-					return Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
-				}
-				else//返回二级故障,可以封装一条答复信息, 返回错误码
-				{
-					message::Dispatch_request_msg t_dispatch_request_msg;
-					//针对消息类型, 对消息进行二次解析
-					if (t_dispatch_request_msg.ParseFromString(p_msg->get_message_buf()))
-					{
-						//创建一条答复消息
-						message::Dispatch_response_msg t_dispatch_response_msg;
-						t_dispatch_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eDispatch_response_msg);
-						t_dispatch_response_msg.mutable_base_info()->set_timeout_ms(5000);
-						t_dispatch_response_msg.mutable_base_info()->set_sender(message::Communicator::eDispatch_mamager);
-						t_dispatch_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);
-
-						t_dispatch_response_msg.set_command_key(t_dispatch_request_msg.command_key());
-						t_dispatch_response_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
-						t_dispatch_response_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
-						t_dispatch_response_msg.mutable_error_manager()->set_error_description(t_error.get_error_description());
-
-						std::string t_msg = t_dispatch_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 analysis ERROR "<< this;
-						return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
-											 " message::Measure_request_msg  ParseFromString error ");
-					}
-				}
-			}
-			break;
-		}
-		default :
-			;
-			break;
+		std::cout << "executer_is_busy , " << std::endl;
+		//返回繁忙之后, 通信模块1秒后再次调用check
+		return Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
+	}
+	else if (t_executor_result.get_error_level() > NEGLIGIBLE_ERROR)
+	{
+		return Error_manager(Error_code::SYSTEM_EXECUTOR_STATUS_ERROR, Error_level::MINOR_ERROR,
+							"System_executor::get_instance_references().check_status(); fun error ");
 	}
 
+	//检查接受人
+	if ( p_msg->get_receiver() == Communication_message::Communicator::eDispatch )
+	{
+		return Dispatch_manager::get_instance_references().check_execute_msg(p_msg);
+	}
 
-	return t_error;
+	return Error_code::SUCCESS;
 }
 
 
@@ -157,66 +112,95 @@ 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() )
+
+	//检查接受人
+	if ( p_msg->get_receiver() == Communication_message::Communicator::eDispatch )
 	{
-		case Communication_message::Message_type::eLocate_request_msg:
+		switch ( p_msg->get_message_type() )
 		{
-			message::Measure_request_msg t_measure_request_msg;
-			//针对消息类型, 对消息进行二次解析
-			if (t_measure_request_msg.ParseFromString(p_msg->get_message_buf()))
+			case Communication_message::Message_type::eDispatch_request_msg:
+			{
+				message::Dispatch_request_msg t_dispatch_request_msg;
+				//针对消息类型, 对消息进行二次解析
+				if (t_dispatch_request_msg.ParseFromString(p_msg->get_message_buf()))
+				{
+					//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
+					m_thread_pool.enqueue(&System_executor::execute_for_dispatch_request_msg, this,
+										  t_dispatch_request_msg	);
+				}
+				else
+				{
+					return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
+										 " message::Dispatch_request_msg  ParseFromString error ");
+				}
+				break;
+			}
+			case Communication_message::Message_type::eDispatch_plan_response_msg:
 			{
-				//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
-				m_thread_pool.enqueue(&System_executor::execute_for_measure, this,
-									  t_measure_request_msg.command_key(), t_measure_request_msg.terminal_id());
+				message::Dispatch_plan_response_msg t_dispatch_plan_response_msg;
+				//针对消息类型, 对消息进行二次解析
+				if (t_dispatch_plan_response_msg.ParseFromString(p_msg->get_message_buf()))
+				{
+					//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
+					m_thread_pool.enqueue(&System_executor::execute_for_dispatch_plan_response_msg, this,
+										  t_dispatch_plan_response_msg	);
+				}
+				else
+				{
+					return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
+										 " message::Dispatch_request_msg  ParseFromString error ");
+				}
+				break;
 			}
-			else
+			case Communication_message::Message_type::eDispatch_control_request_msg:
 			{
-				return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
-									 " message::Measure_request_msg  ParseFromString error ");
+				message::Dispatch_control_request_msg t_dispatch_control_request_msg;
+				//针对消息类型, 对消息进行二次解析
+				if (t_dispatch_control_request_msg.ParseFromString(p_msg->get_message_buf()))
+				{
+					//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
+					m_thread_pool.enqueue(&System_executor::execute_for_dispatch_control_request_msg, this,
+										  t_dispatch_control_request_msg	);
+				}
+				else
+				{
+					return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
+										 " message::Dispatch_request_msg  ParseFromString error ");
+				}
+				break;
 			}
-			break;
+			default:
+				break;
 		}
-		case Communication_message::Message_type::eDispatch_request_msg:
+	}
+	//检查接受人
+	if ( p_msg->get_receiver() == Communication_message::Communicator::eMeasurer )
+	{
+		switch ( p_msg->get_message_type() )
 		{
-			message::Dispatch_request_msg t_dispatch_request_msg;
-			//针对消息类型, 对消息进行二次解析
-			if (t_dispatch_request_msg.ParseFromString(p_msg->get_message_buf()))
+			case Communication_message::Message_type::eLocate_request_msg:
 			{
-				Locate_information t_locate_information;
-
-				if ( t_dispatch_request_msg.dispatch_motion_direction() == message::Dispatch_motion_direction::E_STORE_CAR
-				&& t_dispatch_request_msg.has_locate_information())
+				message::Measure_request_msg t_measure_request_msg;
+				//针对消息类型, 对消息进行二次解析
+				if (t_measure_request_msg.ParseFromString(p_msg->get_message_buf()))
 				{
-					t_locate_information.locate_x = t_dispatch_request_msg.locate_information().locate_x();
-					t_locate_information.locate_y = t_dispatch_request_msg.locate_information().locate_y();
-					t_locate_information.locate_angle = t_dispatch_request_msg.locate_information().locate_angle();
-					t_locate_information.locate_length = t_dispatch_request_msg.locate_information().locate_length();
-					t_locate_information.locate_width = t_dispatch_request_msg.locate_information().locate_width();
-					t_locate_information.locate_height = t_dispatch_request_msg.locate_information().locate_height();
-					t_locate_information.locate_wheel_base = t_dispatch_request_msg.locate_information().locate_wheel_base();
-					t_locate_information.locate_wheel_width = t_dispatch_request_msg.locate_information().locate_wheel_width();
-					t_locate_information.locate_correct = t_dispatch_request_msg.locate_information().locate_correct();
+					//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
+					m_thread_pool.enqueue(&System_executor::execute_for_measure, this,
+										  t_measure_request_msg.command_key(), t_measure_request_msg.terminal_id());
 				}
-				//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
-				m_thread_pool.enqueue(&System_executor::execute_for_dispatch, this,
-									  t_dispatch_request_msg.command_key(),
-									  (Dispatch_manager::Dispatch_motion_direction)t_dispatch_request_msg.dispatch_motion_direction(),
-									  t_dispatch_request_msg.terminal_id(),
-									  t_dispatch_request_msg.parkspace_info().parkspace_id(),
-									  &t_locate_information		);
-			}
-			else
-			{
-				return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
-									 " message::Dispatch_request_msg  ParseFromString error ");
+				else
+				{
+					return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
+										 " message::Measure_request_msg  ParseFromString error ");
+				}
+				break;
 			}
-			break;
+
+			default:
+				break;
 		}
-		default:
-			break;
 	}
 
-
 	return Error_code::SUCCESS;
 }
 
@@ -407,4 +391,28 @@ void System_executor::execute_for_dispatch(std::string command_key, Dispatch_man
 	LOG(INFO) << " System_executor::execute_for_dispatch end "<< this;
 	return ;
 
-}
+}
+
+//调度模块的处理函数
+void System_executor::execute_for_dispatch_request_msg(message::Dispatch_request_msg dispatch_request_msg)
+{
+	Dispatch_manager::get_instance_references().execute_for_dispatch_request_msg(dispatch_request_msg);
+	return;
+}
+//调度模块 //调度总规划的答复(调度算法->调度管理)
+void System_executor::execute_for_dispatch_plan_response_msg(message::Dispatch_plan_response_msg dispatch_plan_response_msg)
+{
+	Dispatch_manager::get_instance_references().execute_for_dispatch_plan_response_msg(dispatch_plan_response_msg);
+	return;
+}
+//调度模块 //调度控制的任务请求(调度算法->调度管理)
+void System_executor::execute_for_dispatch_control_request_msg(message::Dispatch_control_request_msg dispatch_control_request_msg)
+{
+	Dispatch_manager::get_instance_references().execute_for_dispatch_control_request_msg(dispatch_control_request_msg);
+	return;
+}
+
+
+
+
+

system/system_executor.h

@@ -78,6 +78,12 @@ public:
 	void execute_for_dispatch(std::string command_key, Dispatch_manager::Dispatch_motion_direction dispatch_motion_direction,
 							  int terminal_id, int parkspace_id, Locate_information * p_locate_information);
 
+	//调度模块 //执行搬运请求(主控->调度管理)
+	void execute_for_dispatch_request_msg(message::Dispatch_request_msg dispatch_request_msg);
+	//调度模块 //调度总规划的答复(调度算法->调度管理)
+	void execute_for_dispatch_plan_response_msg(message::Dispatch_plan_response_msg dispatch_plan_response_msg);
+	//调度模块 //调度控制的任务请求(调度算法->调度管理)
+	void execute_for_dispatch_control_request_msg(message::Dispatch_control_request_msg dispatch_control_request_msg);
 protected://member variable
 
 	System_executor_status		m_system_executor_status;		//系统执行者的状态

tool/common_data.h

@@ -18,6 +18,8 @@ public:
 #define PARKSPACE_ID_BASE							0
 #define PASSAGEWAY_ID_BASE							1100
 
+//唯一码的默认长度 32byte
+#define COMMAND_KEY_DEFAULT_LENGTH					32