20210325, 调度流程

CMakeLists.txt

@@ -7,7 +7,7 @@ set (CMAKE_CXX_STANDARD 11)
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(nanomsg REQUIRED nanomsg)
 FIND_PACKAGE(Protobuf REQUIRED)
-FIND_PACKAGE(Glog REQUIRED)
+#FIND_PACKAGE(Glog REQUIRED)
 FIND_PACKAGE(OpenCV REQUIRED)
 FIND_PACKAGE(PCL REQUIRED)
 
@@ -87,9 +87,9 @@ target_link_libraries(terminal
         ${PCL_LIBRARIES}
         ${PROTOBUF_LIBRARIES}
 
-        libtensorflow_cc.so
+#        libtensorflow_cc.so
         #tf_3dcnn_api.so
-        pointSIFT_API.so
+#        pointSIFT_API.so
 		snap7
         -lpthread
         )

dispatch/carrier.cpp

@@ -59,7 +59,7 @@ Carrier::~Carrier()
 Error_manager Carrier::check_task_type(std::shared_ptr<Task_Base> p_task)
 {
 	//检查任务类型，
-	if (p_task->get_task_type() != CARRIER_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::CARRIER_TASK)
 	{
 		return Error_manager(Error_code::CARRIER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Carrier::check_task_type  get_task_type() != CARRIER_TASK ");
@@ -79,7 +79,7 @@ Carrier::Device_status Carrier::get_actual_device_status()
 Error_manager Carrier::write_task_to_memory(std::shared_ptr<Task_Base> p_task)
 {
 	//检查任务类型，
-	if (p_task->get_task_type() != CARRIER_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::CARRIER_TASK)
 	{
 		return Error_manager(Error_code::CARRIER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Carrier::check_task_type  get_task_type() != CARRIER_TASK ");
@@ -236,7 +236,7 @@ Error_manager Carrier::check_and_read_memory_to_task(std::shared_ptr<Task_Base>
 	Dispatch_communication::get_instance_references().communication_start();
 
 	//检查任务类型，
-	if (p_task->get_task_type() != CARRIER_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::CARRIER_TASK)
 	{
 		return Error_manager(Error_code::CARRIER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Carrier::check_task_type  get_task_type() != CARRIER_TASK ");

dispatch/catcher.cpp

@@ -57,7 +57,7 @@ Catcher::~Catcher()
 Error_manager Catcher::check_task_type(std::shared_ptr<Task_Base> p_task)
 {
 	//检查任务类型，
-	if (p_task->get_task_type() != CATCHER_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::CATCHER_TASK)
 	{
 		return Error_manager(Error_code::CATCHER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Catcher::check_task_type  get_task_type() != CATCHER_TASK ");
@@ -77,7 +77,7 @@ Catcher::Device_status Catcher::get_actual_device_status()
 Error_manager Catcher::write_task_to_memory(std::shared_ptr<Task_Base> p_task)
 {
 	//检查任务类型，
-	if (p_task->get_task_type() != CATCHER_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::CATCHER_TASK)
 	{
 		return Error_manager(Error_code::CATCHER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Catcher::check_task_type  get_task_type() != CATCHER_TASK ");
@@ -243,7 +243,7 @@ Error_manager Catcher::check_and_read_memory_to_task(std::shared_ptr<Task_Base>
 	Dispatch_communication::get_instance_references().communication_start();
 
 	//检查任务类型，
-	if (p_task->get_task_type() != CATCHER_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::CATCHER_TASK)
 	{
 		return Error_manager(Error_code::CATCHER_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Catcher::check_task_type  get_task_type() != CATCHER_TASK ");

dispatch/dispatch_coordinates.cpp

@@ -79,7 +79,7 @@ Error_manager Dispatch_coordinates::dispatch_coordinates_init_from_protobuf(Disp
 	for (int i = 0; i < size; ++i)
 	{
 		Point3D_tool::Point3D t_point3d;
-		int id = dispatch_coordinates_parameter_all.passageway_coordinates_parameters(i).id();
+		int id = dispatch_coordinates_parameter_all.catcher_coordinates_parameters(i).id();
 		t_point3d.x = dispatch_coordinates_parameter_all.catcher_coordinates_parameters(i).x();
 		t_point3d.y = dispatch_coordinates_parameter_all.catcher_coordinates_parameters(i).y();
 		t_point3d.z = dispatch_coordinates_parameter_all.catcher_coordinates_parameters(i).z();
@@ -113,26 +113,5 @@ Error_manager Dispatch_coordinates::dispatch_coordinates_init_from_protobuf(Disp
 	std::cout << " huli test :::: " << " m_carrier_coordinates.size() = " << m_carrier_coordinates.size() << std::endl;
 	std::cout << " huli test :::: " << " m_catcher_coordinates.size() = " << m_catcher_coordinates.size() << std::endl;
 
-/*
-	if ( communication_parameter_all.communication_parameters().has_bind_string() )
-	{
-		t_error = communication_bind(communication_parameter_all.communication_parameters().bind_string());
-		if ( t_error != Error_code::SUCCESS )
-		{
-			return t_error;
-		}
-	}
-
-
-	for(int i=0;i<communication_parameter_all.communication_parameters().connect_string_vector_size();++i)
-	{
-		t_error = communication_connect( communication_parameter_all.communication_parameters().connect_string_vector(i) );
-		if ( t_error != Error_code::SUCCESS )
-		{
-			return t_error;
-		}
-	}
-*/
-
 	return Error_code::SUCCESS;
 }

dispatch/dispatch_device_base.cpp

@@ -178,19 +178,19 @@ Error_manager Dispatch_device_base::sign_for_task(std::shared_ptr<Task_Base> p_t
 		case E_ONE_LEVEL:
 		{
 			mp_device_one_level_task = p_task;
-			mp_device_one_level_task->set_task_statu(TASK_SIGNED);
+			mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
 			break;
 		}
 		case E_TWO_LEVEL:
 		{
 			mp_device_two_level_task = p_task;
-			mp_device_two_level_task->set_task_statu(TASK_SIGNED);
+			mp_device_two_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
 			break;
 		}
 		case E_THREE_LEVEL:
 		{
 			mp_device_three_level_task = p_task;
-			mp_device_three_level_task->set_task_statu(TASK_SIGNED);
+			mp_device_three_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
 			break;
 		}
 		default:
@@ -241,12 +241,12 @@ Error_manager Dispatch_device_base::end_task(std::shared_ptr<Task_Base> p_task)
 	if ( p_task->get_task_error_manager().get_error_level() < Error_level::MINOR_ERROR)
 	{
 		//强制改为TASK_OVER，不管它当前在做什么。
-		p_task->set_task_statu(TASK_OVER);
+		p_task->set_task_statu(Task_Base::Task_statu::TASK_OVER);
 	}
 	else
 	{
 		//强制改为 TASK_ERROR，不管它当前在做什么。
-		p_task->set_task_statu(TASK_ERROR);
+		p_task->set_task_statu(Task_Base::Task_statu::TASK_ERROR);
 	}
 	return Error_code::SUCCESS;
 }
@@ -347,7 +347,7 @@ Error_manager Dispatch_device_base::cancel_task(std::shared_ptr<Task_Base> p_tas
 		}
 	}
 	//上级的任务单指针,改为死亡,表示任务已经失效.
-	p_task->set_task_statu(TASK_DEAD);
+	p_task->set_task_statu(Task_Base::Task_statu::TASK_DEAD);
 	return Error_code::SUCCESS;
 }
 
@@ -387,7 +387,7 @@ void Dispatch_device_base::execute_thread_fun()
 				{
 					if ( mp_device_three_level_task.get() != NULL )
 					{
-						mp_device_three_level_task->set_task_statu(TASK_WORKING);
+						mp_device_three_level_task->set_task_statu(Task_Base::Task_statu::TASK_WORKING);
 						//执行三级任务
 						write_task_to_memory(mp_device_three_level_task);
 						//更新通信
@@ -427,17 +427,17 @@ void Dispatch_device_base::execute_thread_fun()
 						//检查任务状态,
 						//在 E_THREE_LEVEL_WORK 里面, 已经 设为 TASK_OVER 了.
 						//等待发送方的新指令, (发送方会把状态改为回收, 表示这个任务结束)
-						if ( mp_device_three_level_task->get_task_statu() == TASK_WITHDRAW )
+						if ( mp_device_three_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WITHDRAW )
 						{
 							//这里会通知任务已经释放, 然后销毁任务单,  并降级
-							mp_device_three_level_task->set_task_statu(TASK_FREE);
+							mp_device_three_level_task->set_task_statu(Task_Base::Task_statu::TASK_FREE);
 							mp_device_three_level_task.reset();
 							m_dispatch_device_status = E_TWO_LEVEL_WORK;
 						}
 							//任务单重新创建, 调度创建的新的任务,那么回去继续工作
-						else if (  mp_device_three_level_task->get_task_statu() == TASK_CREATED )
+						else if (  mp_device_three_level_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED )
 						{
-							mp_device_three_level_task->set_task_statu(TASK_SIGNED);
+							mp_device_three_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
 							m_dispatch_device_status = E_THREE_LEVEL_WORK;
 						}
 						//else //保持不动, 直到发送方给定新的任务,
@@ -453,7 +453,7 @@ void Dispatch_device_base::execute_thread_fun()
 				{
 					if ( mp_device_two_level_task.get() != NULL )
 					{
-						mp_device_two_level_task->set_task_statu(TASK_WORKING);
+						mp_device_two_level_task->set_task_statu(Task_Base::Task_statu::TASK_WORKING);
 						//执行二级任务
 						write_task_to_memory(mp_device_two_level_task);
 						//更新通信
@@ -493,17 +493,17 @@ void Dispatch_device_base::execute_thread_fun()
 						//检查任务状态,
 						//在 E_TWO_LEVEL_WORK 里面, 已经 设为 TASK_OVER 了.
 						//等待发送方的新指令, (发送方会把状态改为回收, 表示这个任务结束)
-						if ( mp_device_two_level_task->get_task_statu() == TASK_WITHDRAW )
+						if ( mp_device_two_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WITHDRAW )
 						{
 							//这里会通知任务已经释放, 然后销毁任务单,  并降级
-							mp_device_two_level_task->set_task_statu(TASK_FREE);
+							mp_device_two_level_task->set_task_statu(Task_Base::Task_statu::TASK_FREE);
 							mp_device_two_level_task.reset();
 							m_dispatch_device_status = E_ONE_LEVEL_WORK;
 						}
 							//任务单重新创建, 调度创建的新的任务,那么回去继续工作
-						else if (  mp_device_two_level_task->get_task_statu() == TASK_CREATED )
+						else if (  mp_device_two_level_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED )
 						{
-							mp_device_two_level_task->set_task_statu(TASK_SIGNED);
+							mp_device_two_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
 							m_dispatch_device_status = E_TWO_LEVEL_WORK;
 						}
 						//else //保持不动, 直到发送方给定新的任务,
@@ -519,7 +519,7 @@ void Dispatch_device_base::execute_thread_fun()
 				{
 					if ( mp_device_one_level_task.get() != NULL )
 					{
-						mp_device_one_level_task->set_task_statu(TASK_WORKING);
+						mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_WORKING);
 						//执行一级任务,
 						write_task_to_memory(mp_device_one_level_task);
 						//更新通信
@@ -559,17 +559,17 @@ void Dispatch_device_base::execute_thread_fun()
 						//检查任务状态,
 						//在 E_ONE_LEVEL_WORK 里面, 已经 设为 TASK_OVER 了.
 						//等待发送方的新指令, (发送方会把状态改为回收, 表示这个任务结束)
-						if ( mp_device_one_level_task->get_task_statu() == TASK_WITHDRAW )
+						if ( mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WITHDRAW )
 						{
 							//这里会通知任务已经释放, 然后销毁任务单,  并降级
-							mp_device_one_level_task->set_task_statu(TASK_FREE);
+							mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_FREE);
 							mp_device_one_level_task.reset();
 							m_dispatch_device_status = E_READY;
 						}
 							//任务单重新创建, 调度创建的新的任务,那么回去继续工作
-						else if (  mp_device_one_level_task->get_task_statu() == TASK_CREATED )
+						else if (  mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED )
 						{
-							mp_device_one_level_task->set_task_statu(TASK_SIGNED);
+							mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_SIGNED);
 							m_dispatch_device_status = E_ONE_LEVEL_WORK;
 						}
 						//else //保持不动, 直到发送方给定新的任务,

dispatch/dispatch_manager.h

@@ -89,7 +89,7 @@ public://get or set member variable
 	Dispatch_manager_status get_dispatch_manager_status();
 	int get_dispatch_id();
 	void set_dispatch_id(int dispatch_id);
-protected://member variable
+public://member variable
 
 	Dispatch_manager_status						m_dispatch_manager_status;			//调度管理 的状态
 	int 										m_dispatch_id;						//调度模块的id, (楚天项目就是单元号, 0~2)

dispatch/dispatch_process.cpp

@@ -12,6 +12,9 @@ Dispatch_process::Dispatch_process()
 	m_dispatch_process_type = DISPATCH_PROCESS_TYPE_UNKNOW;
 	m_dispatch_source = 0;
 	m_dispatch_destination = 0;
+
+	m_dispatch_process_catcher_motion = CATCHER_MOTION_UNKNOW;
+	m_dispatch_process_carrier_motion = CARRIER_MOTION_UNKNOW;
 }
 
 Dispatch_process::~Dispatch_process()
@@ -106,8 +109,8 @@ void Dispatch_process::Main()
 				}
 				else
 				{
-					//流程正常, 就进入工作状态,
-					m_dispatch_process_status = DISPATCH_PROCESS_WORKING;
+					//流程正常, 就去连接设备
+					m_dispatch_process_status = DISPATCH_PROCESS_CONNECT_DEVICE;
 					break;
 				}
 
@@ -125,7 +128,27 @@ void Dispatch_process::Main()
 				}
 				break;
 	        }
+			case DISPATCH_PROCESS_CONNECT_DEVICE:
+			{
+				//连接调度设备
+				m_result = connect_dispatch_device();
+				if ( m_result !=Error_code::SUCCESS)
+				{
+					m_dispatch_process_status = DISPATCH_PROCESS_FAULT;
+					break;
+				}
+				//流程正常, 就进入工作状态,
+				m_dispatch_process_status = DISPATCH_PROCESS_WORKING;
+				break;
+
+				break;
+			}
 			case DISPATCH_PROCESS_WORKING:
+			{
+
+				break;
+			}
+			case DISPATCH_PROCESS_RESPONSE:
 			{
 				break;
 			}
@@ -217,15 +240,309 @@ Error_manager Dispatch_process::wait_dispatch_control_request_msg()
 	}
 }
 
+
+
+//连接调度设备
+Error_manager Dispatch_process::connect_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 )
+	{
+		//找到对应的设备
+		if ( m_dispatch_control_request_msg.dispatch_device_type() == message::Dispatch_device_type::ROBOT_1 )
+		{
+			mp_catcher = Dispatch_manager::get_instance_references().m_catcher_map[0];
+		}
+		if ( m_dispatch_control_request_msg.dispatch_device_type() == message::Dispatch_device_type::ROBOT_2 )
+		{
+			mp_catcher = Dispatch_manager::get_instance_references().m_catcher_map[1];
+		}
+
+		//检查设备状态
+		if ( mp_catcher->check_status() == Error_code::SUCCESS &&
+			 mp_catcher->m_actual_device_status == Dispatch_device_base::DEVICE_READY &&
+			 mp_catcher->m_actual_load_status == Dispatch_device_base::NO_CAR)
+		{
+			//创建任务单
+			mp_catcher_task = std::shared_ptr<Task_Base>(new Catcher_task);
+			mp_catcher_task->task_init(NULL,std::chrono::milliseconds(15000));
+			Catcher_task * tp_catcher_task = (Catcher_task *)mp_catcher_task.get();
+
+			//第一次发送 空的唯一码, 可以和设备建立联系
+			tp_catcher_task->m_request_key = "";
+			tp_catcher_task->m_request_x = mp_catcher->m_actual_x;
+			tp_catcher_task->m_request_y = mp_catcher->m_actual_y;
+			tp_catcher_task->m_request_b = mp_catcher->m_actual_b;
+			tp_catcher_task->m_request_z = mp_catcher->m_actual_z;
+			tp_catcher_task->m_request_d1 = mp_catcher->m_actual_d1;
+			tp_catcher_task->m_request_d2 = mp_catcher->m_actual_d2;
+			tp_catcher_task->m_request_wheelbase = 0;
+			tp_catcher_task->m_request_clamp_motion = (Catcher_task::Clamp_motion)mp_catcher->m_actual_clamp_motion1;
+
+			t_error = mp_catcher->execute_task(mp_catcher_task, Dispatch_device_base::E_ONE_LEVEL);
+			if ( t_error != Error_code::SUCCESS )
+			{
+				return t_error;
+			}
+		}
+		else
+		{
+			return Error_manager(Error_code::DISPATCH_PROCESS_DEVICE_STATUS_ERROR, Error_level::MINOR_ERROR,
+								 " Dispatch_process::excute_robot_catch_car_from_inlet device_status error ");
+		}
+
+		//设置起点
+		if ( m_dispatch_control_request_msg.dispatch_source() == 0 )
+		{
+			m_source_coordinates.x = 0;
+			m_source_coordinates.y = 0;
+			m_source_coordinates.z = 0;
+		}
+		else if ( m_dispatch_control_request_msg.dispatch_source() > 0 && m_dispatch_control_request_msg.dispatch_source() <= 165)
+		{
+			m_source_coordinates = Dispatch_coordinates::get_instance_references().m_packspace_coordinates[m_dispatch_control_request_msg.dispatch_source()];
+		}
+		else
+		{
+			m_source_coordinates = Dispatch_coordinates::get_instance_references().m_catcher_coordinates[m_dispatch_control_request_msg.dispatch_source()];
+		}
+
+		//设置终点
+		if ( m_dispatch_control_request_msg.dispatch_destination() == 0 )
+		{
+			m_destination_coordinates.x = 0;
+			m_destination_coordinates.y = 0;
+			m_destination_coordinates.z = 0;
+		}
+		else if ( m_dispatch_control_request_msg.dispatch_destination() > 0 && m_dispatch_control_request_msg.dispatch_destination() <= 165)
+		{
+			m_destination_coordinates = Dispatch_coordinates::get_instance_references().m_packspace_coordinates[m_dispatch_control_request_msg.dispatch_destination()];
+		}
+		else
+		{
+			m_destination_coordinates = Dispatch_coordinates::get_instance_references().m_catcher_coordinates[m_dispatch_control_request_msg.dispatch_destination()];
+		}
+	}
+	//搬运器的配置 准备工作
+	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 )
+	{
+		//找到对应的设备
+		if ( m_dispatch_control_request_msg.dispatch_device_type() == message::Dispatch_device_type::CARRIER_1 )
+		{
+			mp_carrier = Dispatch_manager::get_instance_references().m_carrier_map[0];
+		}
+		if ( m_dispatch_control_request_msg.dispatch_device_type() == message::Dispatch_device_type::CARRIER_2 )
+		{
+			mp_carrier = Dispatch_manager::get_instance_references().m_carrier_map[1];
+		}
+		if ( m_dispatch_control_request_msg.dispatch_device_type() == message::Dispatch_device_type::CARRIER_3 )
+		{
+			mp_carrier = Dispatch_manager::get_instance_references().m_carrier_map[1];
+		}
+
+		//检查设备状态
+		if ( mp_carrier->check_status() == Error_code::SUCCESS &&
+			 mp_carrier->m_actual_device_status == Dispatch_device_base::DEVICE_READY &&
+			 mp_carrier->m_actual_load_status == Dispatch_device_base::NO_CAR)
+		{
+			//创建任务单
+			mp_carrier_task = std::shared_ptr<Task_Base>(new Carrier_task);
+			mp_carrier_task->task_init(NULL,std::chrono::milliseconds(15000));
+			Carrier_task * tp_carrier_task = (Carrier_task *)mp_carrier_task.get();
+
+			//第一次发送 空的唯一码, 可以和设备建立联系
+			tp_carrier_task->m_request_key = "";
+			tp_carrier_task->m_request_x = mp_carrier->m_actual_x;
+			tp_carrier_task->m_request_y = mp_carrier->m_actual_y;
+			tp_carrier_task->m_request_z = mp_carrier->m_actual_z;
+			tp_carrier_task->m_request_y1 = mp_carrier->m_actual_y1;
+			tp_carrier_task->m_request_y2 = mp_carrier->m_actual_y2;
+			tp_carrier_task->m_request_clamp_motion = (Carrier_task::Clamp_motion)mp_carrier->m_actual_clamp_motion1;
+			tp_carrier_task->m_request_joint_motion_x = (Carrier_task::Joint_motion)mp_carrier->m_actual_joint_motion_x1;
+			tp_carrier_task->m_request_joint_motion_y = Carrier_task::Joint_motion::E_JOINT_NO_ACTION;
+			tp_carrier_task->m_request_space_id = 0;
+			tp_carrier_task->m_request_floor_id = 0;
+			tp_carrier_task->m_request_wheelbase = 0;
+
+			t_error = mp_carrier->execute_task(mp_catcher_task, Dispatch_device_base::E_ONE_LEVEL);
+			if ( t_error != Error_code::SUCCESS )
+			{
+				return t_error;
+			}
+		}
+		else
+		{
+			return Error_manager(Error_code::DISPATCH_PROCESS_DEVICE_STATUS_ERROR, Error_level::MINOR_ERROR,
+								 " Dispatch_process::excute_robot_catch_car_from_inlet device_status error ");
+		}
+
+		//设置起点
+		if ( m_dispatch_control_request_msg.dispatch_source() == 0 )
+		{
+			m_source_coordinates.x = 0;
+			m_source_coordinates.y = 0;
+			m_source_coordinates.z = 0;
+		}
+		else if ( m_dispatch_control_request_msg.dispatch_source() > 0 && m_dispatch_control_request_msg.dispatch_source() <= 165)
+		{
+			m_source_coordinates = Dispatch_coordinates::get_instance_references().m_packspace_coordinates[m_dispatch_control_request_msg.dispatch_source()];
+		}
+		else
+		{
+			m_source_coordinates = Dispatch_coordinates::get_instance_references().m_carrier_coordinates[m_dispatch_control_request_msg.dispatch_source()];
+		}
+
+		//设置终点
+		if ( m_dispatch_control_request_msg.dispatch_destination() == 0 )
+		{
+			m_destination_coordinates.x = 0;
+			m_destination_coordinates.y = 0;
+			m_destination_coordinates.z = 0;
+		}
+		else if ( m_dispatch_control_request_msg.dispatch_destination() > 0 && m_dispatch_control_request_msg.dispatch_destination() <= 165)
+		{
+			m_destination_coordinates = Dispatch_coordinates::get_instance_references().m_packspace_coordinates[m_dispatch_control_request_msg.dispatch_destination()];
+		}
+		else
+		{
+			m_destination_coordinates = Dispatch_coordinates::get_instance_references().m_carrier_coordinates[m_dispatch_control_request_msg.dispatch_destination()];
+		}
+	}
+
+	return Error_code::SUCCESS;
+}
+
+//检查机器手任务单
+Error_manager Dispatch_process::check_catcher_task()
+{
+	if ( mp_catcher_task.get() == NULL )
+	{
+	    return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
+	    					"Dispatch_process::check_catcher_task  POINTER IS NULL ");
+	}
+	else
+	{
+		Catcher_task * tp_catcher_task = (Catcher_task *)mp_catcher_task.get();
+
+		if ( tp_catcher_task->get_task_statu() == Task_Base::Task_statu::TASK_OVER )
+	    {
+			return Error_code::SUCCESS;
+	    }
+		else if ( tp_catcher_task->get_task_statu() == Task_Base::Task_statu::TASK_ERROR )
+		{
+			return tp_catcher_task->get_task_error_manager();
+		}
+		else if ( tp_catcher_task->get_task_statu() == Task_Base::Task_statu::TASK_WORKING &&
+		tp_catcher_task->get_task_statu() == Task_Base::Task_statu::TASK_SIGNED &&
+			tp_catcher_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED)
+		{
+			return Error_code::NODATA;
+		}
+	}
+}
+//检查搬运器任务单
+Error_manager Dispatch_process::check_carrier_task()
+{
+
+}
+//检查通道口任务单
+Error_manager Dispatch_process::check_passageway_task()
+{
+
+}
+
 //执行调度控制指令, 并根据完成情况给答复
 Error_manager Dispatch_process::excute_dispatch_control()
 {
-	std::unique_lock<std::mutex> t_lock(m_lock);
 
 	return Error_code::SUCCESS;
 }
 
+//机器手去入口抓车(例如:机器手移动到2号入口上方,然后下降到一楼抓车,最后上升到最上方)
+Error_manager Dispatch_process::excute_robot_catch_car_from_inlet()
+{
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	Error_manager t_error;
 
+	//设备的动作也使用外部的Main()的线程来循环
+	static int s_step = 0;
+
+	//第一次进入动作时, 创建任务单
+	if ( mp_catcher_task.get() == NULL )
+	{
+		//检查设备状态
+		if ( mp_catcher->check_status() == Error_code::SUCCESS &&
+		mp_catcher->m_actual_device_status == Dispatch_device_base::DEVICE_READY &&
+		mp_catcher->m_actual_load_status == Dispatch_device_base::NO_CAR)
+		{
+			s_step = 0;
+			//创建任务单
+			mp_catcher_task = std::shared_ptr<Task_Base>(new Catcher_task);
+			mp_catcher_task->task_init(NULL,std::chrono::milliseconds(15000));
+			Catcher_task * tp_catcher_task = (Catcher_task *)mp_catcher_task.get();
+
+			tp_catcher_task->m_request_key = "";
+			tp_catcher_task->m_request_x = mp_catcher->m_actual_x;
+			tp_catcher_task->m_request_y = mp_catcher->m_actual_y;
+			tp_catcher_task->m_request_b = mp_catcher->m_actual_b;
+			tp_catcher_task->m_request_z = mp_catcher->m_actual_z;
+			tp_catcher_task->m_request_d1 = mp_catcher->m_actual_d1;
+			tp_catcher_task->m_request_d2 = mp_catcher->m_actual_d2;
+			tp_catcher_task->m_request_wheelbase = 0;
+			tp_catcher_task->m_request_clamp_motion = (Catcher_task::Clamp_motion)mp_catcher->m_actual_clamp_motion1;
+
+			//第一次发送 空的唯一码, 可以和设备建立联系
+			t_error = mp_catcher->execute_task(mp_catcher_task, Dispatch_device_base::E_ONE_LEVEL);
+			if ( t_error != Error_code::SUCCESS )
+			{
+				return t_error;
+			}
+		}
+		else
+		{
+			return Error_manager(Error_code::DISPATCH_PROCESS_DEVICE_STATUS_ERROR, Error_level::MINOR_ERROR,
+								 " Dispatch_process::excute_robot_catch_car_from_inlet device_status error ");
+		}
+
+	}
+
+	Catcher_task * tp_catcher_task = (Catcher_task *)mp_catcher_task.get();
+
+	switch ( s_step )
+	{
+	    case 0://
+	    {
+
+	        break;
+	    }
+	    case 1:
+	    {
+	        ;
+	        break;
+	    }
+	    default:
+	    {
+
+	        break;
+	    }
+	}
+}
+//机器手把车放到中跑车上面(例如:机器手下降到中跑车上放车,最后上升到最上方)(通过目标点 指定放到哪一个中跑车上)
+Error_manager Dispatch_process::excute_robot_put_car_to_carrier()
+{
+
+}
+
+//执行通道口动作
+Error_manager Dispatch_process::excute_passageway_motion()
+{
+return Error_code::SUCCESS;
+}
 
 //等待调度总计划答复
 Error_manager Dispatch_process::wait_dispatch_plan_response_msg()

dispatch/dispatch_process.h

@@ -32,9 +32,11 @@
 #include "../dispatch/carrier.h"
 #include "../dispatch/catcher.h"
 #include "../dispatch/passageway.h"
+#include "../dispatch/dispatch_coordinates.h"
 
 #include "../message/dispatch_message.pb.h"
 #include "../message/dispatch_control.pb.h"
+#include "../tool/point3D_tool.h"
 
 //调度流程 存车
 class Dispatch_process : public tq::BaseTask
@@ -51,9 +53,11 @@ public:
 		DISPATCH_PROCESS_STATUS_UNKNOW          = 0,    //未知
 		DISPATCH_PROCESS_CREATED				= 1, 	//流程创建,
 		DISPATCH_PROCESS_READY               	= 2,    //流程准备，待机
-		DISPATCH_PROCESS_WORKING				= 3, 	//流程工作正忙
-		DISPATCH_PROCESS_OVER					= 4, 	//流程完成
-		DISPATCH_PROCESS_RELEASE				= 5, 	//流程释放
+		DISPATCH_PROCESS_CONNECT_DEVICE			= 3, 	//流程 连接设备
+		DISPATCH_PROCESS_WORKING				= 4, 	//流程工作正忙, 进行长流程
+		DISPATCH_PROCESS_RESPONSE				= 5, 	//流程 给调度控制答复
+		DISPATCH_PROCESS_OVER					= 6, 	//流程完成
+		DISPATCH_PROCESS_RELEASE				= 7, 	//流程释放
 
 		DISPATCH_PROCESS_FAULT					= 10,	//故障
 		DISPATCH_PROCESS_MOTION_FAILED			= 11,	//单个小动作执行失败
@@ -65,6 +69,21 @@ public:
 		DISPATCH_PROCESS_STORE  				= 101,    //存车
 		DISPATCH_PROCESS_PICKUP					= 102,	//取车
 	};
+
+	//机器手的动作, 控制步骤
+	enum Dispatch_process_catcher_motion
+	{
+		CATCHER_MOTION_UNKNOW          = 0,    //未知
+
+
+	};
+	//搬运器的动作, 控制步骤
+	enum Dispatch_process_carrier_motion
+	{
+		CARRIER_MOTION_UNKNOW          = 0,    //未知
+
+
+	};
 public:
 	Dispatch_process();
 	Dispatch_process(const Dispatch_process& other)= default;
@@ -91,8 +110,24 @@ protected://member functions
 	//等待控制指令
 	Error_manager wait_dispatch_control_request_msg();
 
+	//连接调度设备
+	Error_manager connect_dispatch_device();
+
+	//检查机器手任务单
+	Error_manager check_catcher_task();
+	//检查搬运器任务单
+	Error_manager check_carrier_task();
+	//检查通道口任务单
+	Error_manager check_passageway_task();
 	//执行调度控制指令, 并根据完成情况给答复
 	Error_manager excute_dispatch_control();
+	//机器手去入口抓车(例如:机器手移动到2号入口上方,然后下降到一楼抓车,最后上升到最上方)
+	Error_manager excute_robot_catch_car_from_inlet();
+	//机器手把车放到中跑车上面(例如:机器手下降到中跑车上放车,最后上升到最上方)(通过目标点 指定放到哪一个中跑车上)
+	Error_manager excute_robot_put_car_to_carrier();
+	//执行通道口动作
+	Error_manager excute_passageway_motion();
+
 
 	//等待调度总计划答复
 	Error_manager wait_dispatch_plan_response_msg();
@@ -130,6 +165,10 @@ 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;			//终点 的坐标
+	Dispatch_process_catcher_motion			m_dispatch_process_catcher_motion;	//机器手的动作, 控制步骤
+	Dispatch_process_carrier_motion			m_dispatch_process_carrier_motion;	//搬运器的动作, 控制步骤
 
 
 	//通信缓存

dispatch/passageway.cpp

@@ -44,7 +44,7 @@ Passageway::~Passageway()
 Error_manager Passageway::check_task_type(std::shared_ptr<Task_Base> p_task)
 {
 	//检查任务类型，
-	if (p_task->get_task_type() != PASSAGEWAY_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::PASSAGEWAY_TASK)
 	{
 		return Error_manager(Error_code::PASSAGEWAY_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Passageway::check_task_type  get_task_type() != PASSAGEWAY_TASK ");
@@ -64,7 +64,7 @@ Passageway::Device_status Passageway::get_actual_device_status()
 Error_manager Passageway::write_task_to_memory(std::shared_ptr<Task_Base> p_task)
 {
 	//检查任务类型，
-	if (p_task->get_task_type() != PASSAGEWAY_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::PASSAGEWAY_TASK)
 	{
 		return Error_manager(Error_code::PASSAGEWAY_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Passageway::check_task_type  get_task_type() != PASSAGEWAY_TASK ");
@@ -282,7 +282,7 @@ Error_manager Passageway::check_and_read_memory_to_task(std::shared_ptr<Task_Bas
 {
 	Dispatch_communication::get_instance_references().communication_start();
 	//检查任务类型，
-	if (p_task->get_task_type() != PASSAGEWAY_TASK)
+	if (p_task->get_task_type() != Task_Base::Task_type::PASSAGEWAY_TASK)
 	{
 		return Error_manager(Error_code::PASSAGEWAY_TASK_TYPE_ERROR, Error_level::MINOR_ERROR,
 							 "Passageway::check_task_type  get_task_type() != PASSAGEWAY_TASK ");

error_code/error_code.h

@@ -354,8 +354,9 @@ enum Error_code
 	DISPATCH_DEVICE_RESPONS_ERROR,						//调度设备模块，指令的执行失败
 	DISPATCH_DEVICE_TASK_NOTHINGNESS,					//调度设备模块，任务不存在
 
-
-
+	DISPATCH_PROCESS_ERROR_BASE								= 0x13020000,
+	DISPATCH_PROCESS_DEVICE_TYPE_ERROR,				//调度流程, 设备类型错误
+	DISPATCH_PROCESS_DEVICE_STATUS_ERROR,				//调度流程, 设备类型错误
 
 
 	CARRIER_ERROR_BASE								= 0x13030000,

task/task_base.cpp

@@ -109,12 +109,12 @@ unsigned int  Task_Base::get_task_id()
 }
 
 //获取任务类型
-Task_type Task_Base::get_task_type()
+Task_Base::Task_type Task_Base::get_task_type()
 {
     return m_task_type;
 }
 //获取任务单状态
-Task_statu  Task_Base::get_task_statu()
+Task_Base::Task_statu  Task_Base::get_task_statu()
 {
     return m_task_statu;
 }

task/task_base.h

@@ -57,6 +57,51 @@ enum Task_statu
 //任务单基类
 class Task_Base
 {
+
+public:
+
+//任务超时时间默认值10000ms，10秒
+#define TASK_OVER_TIME_DEFAULT				10000
+
+//任务类型
+	enum Task_type
+	{
+		UNKNOW_TASK             =0,				//未知任务单//初始化,默认值
+		LASER_MANGER_SCAN_TASK  =1,             //雷达管理模块的扫描任务,
+		LASER_BASE_SCAN_TASK    =2,             //单个雷达的扫描任务,
+		LOCATE_MANGER_TASK		=3,             //测量任务
+		PLC_TASK                =4,             //上传PLC任务
+
+		WANJI_MANAGER_TASK,						//万集雷达管理任务
+		WANJI_LIDAR_SCAN,						//万集雷达扫描任务
+		WANJI_LIDAR_DETECT,						//万集雷达定位任务
+
+		DISPATCH_MANAGER_TASK,					//调度管理任务
+		CARRIER_TASK,							//搬运器任务
+		CATCHER_TASK,							//抓取器任务
+		PASSAGEWAY_TASK,						//通道口任务
+
+	};
+//任务状态，如果任务故障，任务状态改为TASK_OVER，然后在m_task_error_manager 补充错误码。
+	enum Task_statu
+	{
+		TASK_CREATED            = 0,      		//任务创建, 发送方
+
+		TASK_ISSUE				= 1, 			//任务下发, 发送方
+		TASK_SIGNED             = 2,      		//已签收, 接收方
+		TASK_WORKING            = 3,      		//处理中, 接收方
+		TASK_OVER               = 4,   			//已结束, 接收方
+		TASK_STOP				= 5, 			//任务暂停, 接收方
+
+		TASK_ERROR              = 11,			//任务错误, 接收方
+
+		TASK_CANCEL				= 21,			//任务取消, 发送方
+		TASK_DEAD               = 22,           //任务死亡, 接收方
+
+		TASK_WITHDRAW			= 31, 			//任务收回, 发送方
+		TASK_FREE				= 32, 			//任务释放, 接收方
+
+	};
 protected:
 	//不允许构造基类，只允许子类构造，（多态）
 	Task_Base();

tool/thread_condition.h

@@ -36,7 +36,7 @@
 #include <atomic>
 #include <mutex>
 #include <condition_variable>
-
+#include <functional>
 
 class Thread_condition
 {