20210520, 调度流程修改

dispatch/carrier.cpp

@@ -92,8 +92,6 @@ Error_manager Carrier::write_task_to_memory(std::shared_ptr<Task_Base> p_task)
 	}
 	else
 	{
-		std::unique_lock<std::mutex> t_lock(m_lock);
-
 		Carrier_task* tp_carrier_task = (Carrier_task*)p_task.get();
 		std::unique_lock<std::mutex> t_lock1(tp_carrier_task->m_lock);
 		m_request_key = tp_carrier_task->m_request_key;
@@ -117,8 +115,6 @@ Error_manager Carrier::write_task_to_memory(std::shared_ptr<Task_Base> p_task)
 Error_manager Carrier::update_device_communication()
 {
 	std::unique_lock<std::mutex> t_lock1(Dispatch_communication::get_instance_references().m_data_lock);
-	std::unique_lock<std::mutex> t_lock(m_lock);
-
 	//请求消息, 调度->plc
 	Dispatch_communication::Carrier_request_from_dispatch_to_plc_for_data * tp_carrier_request_from_dispatch_to_plc_for_data =
 	& Dispatch_communication::get_instance_references().m_carrier_request_from_dispatch_to_plc_for_data[m_device_id];
@@ -261,18 +257,7 @@ Error_manager Carrier::update_device_communication()
 //从内存中读数据到任务单, 子类必须重载
 Error_manager Carrier::check_and_read_memory_to_task(std::shared_ptr<Task_Base> p_task)
 {
-
-
-//	std::cout << " huli test :::: " << " ((((((((((((((((((((((((((333333333333333333 = " << 333 << std::endl;
-//	std::cout << " huli test :::: " << " m_request_key = " << m_request_key << std::endl;
-//	std::cout << " huli test :::: " << " m_respons_key = " << m_respons_key << std::endl;
-//	std::cout << " huli test :::: " << " m_respons_status = " << m_respons_status << std::endl;
-//	std::cout << " huli test :::: " << " )))))))))))))))))))))))))))))))4444444444444 = " << 444 << std::endl;
-
-
-
-
-		Dispatch_communication::get_instance_references().communication_start();
+	Dispatch_communication::get_instance_references().communication_start();
 
 	//检查任务类型，
 	if (p_task->get_task_type() != Task_Base::Task_type::CARRIER_TASK)
@@ -282,7 +267,6 @@ Error_manager Carrier::check_and_read_memory_to_task(std::shared_ptr<Task_Base>
 	}
 	else
 	{
-		std::unique_lock<std::mutex> t_lock(m_lock);
 		if ( m_respons_key == m_request_key && m_respons_status != RESPONS_WORKING )
 		{
 			Carrier_task* tp_carrier_task = (Carrier_task*)p_task.get();
@@ -389,7 +373,7 @@ Error_manager Carrier::update_actual_coordinates_id()
 	//更新空间锁, 只是 覆盖写入加锁.
 	if ( m_actual_coordinates_id != 0 )
 	{
-		Dispatch_manager::get_instance_references().set_space_lock_for_carrier(m_actual_coordinates_id, m_device_id);
+		Dispatch_coordinates::get_instance_references().set_space_lock_for_carrier(m_actual_coordinates_id, m_device_id);
 	}
 
 

dispatch/catcher.cpp

@@ -88,8 +88,6 @@ Error_manager Catcher::write_task_to_memory(std::shared_ptr<Task_Base> p_task)
 	}
 	else
 	{
-		std::unique_lock<std::mutex> t_lock(m_lock);
-
 		Catcher_task* tp_catcher_task = (Catcher_task*)p_task.get();
 		std::unique_lock<std::mutex> t_lock1(tp_catcher_task->m_lock);
 		m_request_key = tp_catcher_task->m_request_key;
@@ -111,7 +109,6 @@ Error_manager Catcher::write_task_to_memory(std::shared_ptr<Task_Base> p_task)
 Error_manager Catcher::update_device_communication()
 {
 	std::unique_lock<std::mutex> t_lock1(Dispatch_communication::get_instance_references().m_data_lock);
-	std::unique_lock<std::mutex> t_lock(m_lock);
 
 	//请求消息, 调度->plc
 	Dispatch_communication::Catcher_request_from_dispatch_to_plc_for_data * tp_catcher_request_from_dispatch_to_plc_for_data =
@@ -265,8 +262,6 @@ Error_manager Catcher::check_and_read_memory_to_task(std::shared_ptr<Task_Base>
 	}
 	else
 	{
-		std::unique_lock<std::mutex> t_lock(m_lock);
-
 		if ( m_respons_key == m_request_key && m_respons_status != RESPONS_WORKING )
 		{
 			Catcher_task* tp_catcher_task = (Catcher_task*)p_task.get();
@@ -372,7 +367,7 @@ Error_manager Catcher::update_actual_coordinates_id()
 	//更新空间锁, 只是 覆盖写入加锁.
 	if ( m_actual_coordinates_id != 0 )
 	{
-	    Dispatch_manager::get_instance_references().set_space_lock_for_catcher(m_actual_coordinates_id, m_device_id);
+		Dispatch_coordinates::get_instance_references().set_space_lock_for_catcher(m_actual_coordinates_id, m_device_id);
 	}
 
 

dispatch/dispatch_coordinates.cpp

@@ -8,12 +8,15 @@
 
 Dispatch_coordinates::Dispatch_coordinates()
 {
-
+	mpp_space_lock = nullptr;
+	m_space_lock_rows = 0;
+	m_space_lock_columns = 0;
+	m_space_lock_total = 0;
 
 }
 Dispatch_coordinates::~Dispatch_coordinates()
 {
-
+	dispatch_coordinates_uninit();
 }
 
 //初始化 调度的坐标系 模块。如下三选一
@@ -40,8 +43,25 @@ Error_manager Dispatch_coordinates::dispatch_coordinates_init_from_protobuf(Disp
 {
 	LOG(INFO) << " ---Dispatch_coordinates::dispatch_coordinates_init_from_protobuf() run--- "<< this;
 	Error_manager t_error;
-	int size;
 
+	m_space_lock_rows = dispatch_coordinates_parameter_all.parkspace_number().rows();
+	m_space_lock_columns = dispatch_coordinates_parameter_all.parkspace_number().columns();
+	m_space_lock_total = dispatch_coordinates_parameter_all.parkspace_number().total();
+	mpp_space_lock = new space_device*[m_space_lock_rows];
+	for (int i = 0; i < m_space_lock_rows; ++i)
+	{
+		mpp_space_lock[i] = new space_device[m_space_lock_columns];
+		for (int j = 0; j < m_space_lock_columns; ++j)
+		{
+			//注意了, 这里一定要初始化为-1, 因为设备id=0 是有效设备
+			mpp_space_lock[i][j].m_catcher_id = -1;
+			mpp_space_lock[i][j].m_carrier_id = -1;
+		}
+	}
+
+
+
+	int size;
 	size = dispatch_coordinates_parameter_all.packspace_coordinates_parameters_size();
 	for (int i = 0; i < size; ++i)
 	{
@@ -160,4 +180,51 @@ Error_manager Dispatch_coordinates::dispatch_coordinates_init_from_protobuf(Disp
 	m_car_wheel_base_max = dispatch_coordinates_parameter_all.car_wheel_base_max();
 
 	return Error_code::SUCCESS;
-}
+}
+//反初始化
+Error_manager Dispatch_coordinates::dispatch_coordinates_uninit()
+{
+	for (int i = 0; i < m_space_lock_rows; ++i)
+	{
+		delete [](mpp_space_lock[i]);
+	}
+	delete [](mpp_space_lock);
+	return Error_code::SUCCESS;
+}
+
+
+void Dispatch_coordinates::set_space_lock(int space_rows, int space_columns, int catcher_id, int carrier_id)
+{
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	mpp_space_lock[space_rows][space_columns].m_catcher_id = catcher_id;
+	mpp_space_lock[space_rows][space_columns].m_carrier_id = carrier_id;
+}
+void Dispatch_coordinates::set_space_lock_for_catcher(int space_rows, int space_columns, int catcher_id)
+{
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	mpp_space_lock[space_rows][space_columns].m_catcher_id = catcher_id;
+}
+void Dispatch_coordinates::set_space_lock_for_carrier(int space_rows, int space_columns, int carrier_id)
+{
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	mpp_space_lock[space_rows][space_columns].m_carrier_id = carrier_id;
+}
+void Dispatch_coordinates::set_space_lock(int space_id, int catcher_id, int carrier_id)
+{
+	int space_rows = (space_id-1) / m_space_lock_columns;
+	int space_columns = (space_id-1) % m_space_lock_columns;
+	set_space_lock(space_rows, space_columns, catcher_id, carrier_id);
+}
+void Dispatch_coordinates::set_space_lock_for_catcher(int space_id, int catcher_id)
+{
+	int space_rows = (space_id-1) / m_space_lock_columns;
+	int space_columns = (space_id-1) % m_space_lock_columns;
+	set_space_lock_for_catcher(space_rows, space_columns, catcher_id);
+}
+void Dispatch_coordinates::set_space_lock_for_carrier(int space_id, int carrier_id)
+{
+	int space_rows = (space_id-1) / m_space_lock_columns;
+	int space_columns = (space_id-1) % m_space_lock_columns;
+	set_space_lock_for_carrier(space_rows, space_columns, carrier_id);
+}
+

dispatch/dispatch_coordinates.h

@@ -11,6 +11,7 @@
 #include "../tool/point3D_tool.h"
 #include <glog/logging.h>
 #include <map>
+#include <mutex>
 
 //调度的坐标系
 class Dispatch_coordinates:public Singleton<Dispatch_coordinates>
@@ -31,6 +32,13 @@ public:
 		PASSAGEWAY_FUNCTIONING_PATTERN_BIDIRECTION      = 3,    //双向口
 	};
 
+	//调度设备的id集合
+	struct space_device
+	{
+		int m_catcher_id;
+		int m_carrier_id;
+	};
+
 private:
 	// 父类的构造函数必须保护，子类的构造函数必须私有。
 	Dispatch_coordinates();
@@ -46,13 +54,31 @@ public://API functions
 	Error_manager dispatch_coordinates_init_from_protobuf(std::string prototxt_path);
 	//初始化 调度的坐标系 模块。从protobuf读取
 	Error_manager dispatch_coordinates_init_from_protobuf(Dispatch_proto::Dispatch_coordinates_parameter_all& dispatch_coordinates_parameter_all);
+	//反初始化
+	virtual Error_manager dispatch_coordinates_uninit();
 public://get or set member variable
 
+	void set_space_lock(int space_rows, int space_columns, int catcher_id, int carrier_id);
+	void set_space_lock_for_catcher(int space_rows, int space_columns, int catcher_id);
+	void set_space_lock_for_carrier(int space_rows, int space_columns, int carrier_id);
 
+	void set_space_lock(int space_id, int catcher_id, int carrier_id);
+	void set_space_lock_for_catcher(int space_id, int catcher_id);
+	void set_space_lock_for_carrier(int space_id, int carrier_id);
 protected://member functions
 
 public://member variable
 
+	std::mutex											m_lock;
+	//空间锁, 防撞. (存放着调度设备的id集合, 交接过程中, 允许两个个设备占有同一个空间)
+	space_device**										mpp_space_lock;						//空间锁, 二维数组, 存放着调度设备的id集合, 内存由本模块管理, (默认11*15=165)
+	int													m_space_lock_rows;					//空间锁, 行
+	int													m_space_lock_columns;				//空间锁, 列
+	int													m_space_lock_total;					//空间锁, 总数
+
+
+
+
 	//楼上车位的坐标 1~165
 	std::map<int, Point3D_tool::Point3D>	m_packspace_coordinates;
 

dispatch/dispatch_device_base.cpp

@@ -128,14 +128,61 @@ Error_manager Dispatch_device_base::check_task_level(Dispatch_task_level dispatc
 		{
 			case DISPATCH_TASK_ONE_LEVEL:
 			{
-				if ( ( m_dispatch_device_status == DISPATCH_DEVICE_READY ) && mp_device_one_level_task.get() == NULL)
+				if ( mp_device_one_level_task.get() == NULL )
 				{
-				    return Error_code::SUCCESS;
+					//一级任务直接插入
+					if (  m_dispatch_device_status == DISPATCH_DEVICE_READY ||
+						  m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_OVER ||
+						  m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_WORK ||
+						  m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_OVER ||
+						  m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_WORK )
+					{
+						return Error_code::SUCCESS;
+					}
+					else
+					{
+						return Error_manager(Error_code::DISPATCH_DEVICE_TASK_LEVEL_ERROR, Error_level::MINOR_ERROR,
+											 " Dispatch_device_base::check_task_level error ");
+					}
+				}
+				else
+				{
+					return Error_manager(Error_code::DISPATCH_DEVICE_TASK_REPEAT, Error_level::MINOR_ERROR,
+										 " Dispatch_device_base::check_task_level error ");
 				}
 				break;
 			}
 			case DISPATCH_TASK_TWO_LEVEL:
 			{
+				if ( mp_device_two_level_task.get() == NULL )
+				{
+					//二级任务如果打断了一级任务, 那么要通知一级任务暂停, 后续一级任务会重新执行
+					if (  m_dispatch_device_status == DISPATCH_DEVICE_READY )
+					{
+						return Error_code::SUCCESS;
+					}
+					else if ( ( m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_WORK ||
+								m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_OVER ) && mp_device_one_level_task.get() == NULL)
+					{
+						mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_STOP);
+						return Error_code::SUCCESS;
+					}
+					else
+					{
+						return Error_manager(Error_code::DISPATCH_DEVICE_TASK_LEVEL_ERROR, Error_level::MINOR_ERROR,
+											 " Dispatch_device_base::check_task_level error ");
+					}
+				}
+				else
+				{
+					return Error_manager(Error_code::DISPATCH_DEVICE_TASK_REPEAT, Error_level::MINOR_ERROR,
+										 " Dispatch_device_base::check_task_level error ");
+				}
+				break;
+
+
+
+
 				if ( ( m_dispatch_device_status == DISPATCH_DEVICE_READY ||
 					 m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_WORK ||
 					 m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_OVER ) && mp_device_two_level_task.get() == NULL)
@@ -240,7 +287,6 @@ bool Dispatch_device_base::is_ready()
 Error_manager Dispatch_device_base::end_task(std::shared_ptr<Task_Base> p_task)
 {
 	LOG(INFO) << " ---Dispatch_device_base::end_task ---"<< this;
-	std::unique_lock<std::mutex> t_lock(m_lock);
 	//注:这里只修改任务单的状态, 搬运器的状态不管
 	//在结束任务单时，将雷达任务状态改为 TASK_OVER 已结束
 	//判断任务单的错误等级，
@@ -260,89 +306,24 @@ Error_manager Dispatch_device_base::end_task(std::shared_ptr<Task_Base> p_task)
 //取消任务单，由发送方提前取消任务单
 Error_manager Dispatch_device_base::cancel_task(std::shared_ptr<Task_Base> p_task, Dispatch_task_level dispatch_task_level)
 {
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	cancel_command();
 	//找到对应的任务单
 	switch ( dispatch_task_level )
 	{
 		case DISPATCH_TASK_ONE_LEVEL:
 		{
-			if ( m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_WORK || m_dispatch_device_status == DISPATCH_DEVICE_ONE_LEVEL_OVER )
-			{
-				//如果正在执行一级任务, 那么取消当前指令, 然后降级
-				m_execute_condition.notify_all(false);
-				//确保内部线程已经停下
-				while (m_execute_condition.is_working())
-				{
-
-				}
-				cancel_command();
-				{
-					std::unique_lock<std::mutex> t_lock(m_lock);
-					mp_device_one_level_task.reset();
-					m_dispatch_device_status = DISPATCH_DEVICE_READY;
-				}
-
-				m_execute_condition.notify_all(true);
-			}
-			else
-			{
-				std::unique_lock<std::mutex> t_lock(m_lock);
-				//否则直接销毁任务单
-				mp_device_one_level_task.reset();
-			}
+			mp_device_one_level_task.reset();
 			break;
 		}
 		case DISPATCH_TASK_TWO_LEVEL:
 		{
-			if ( m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_WORK || m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_OVER )
-			{
-				//如果正在执行一级任务, 那么取消当前指令, 然后降级
-				m_execute_condition.notify_all(false);
-				//确保内部线程已经停下
-				while (m_execute_condition.is_working())
-				{
-
-				}
-				cancel_command();
-				{
-					std::unique_lock<std::mutex> t_lock(m_lock);
-					mp_device_two_level_task.reset();
-					m_dispatch_device_status = DISPATCH_DEVICE_ONE_LEVEL_WORK;
-				}
-				m_execute_condition.notify_all(true);
-			}
-			else
-			{
-				std::unique_lock<std::mutex> t_lock(m_lock);
-				//否则直接销毁任务单
-				mp_device_one_level_task.reset();
-			}
+			mp_device_two_level_task.reset();
 			break;
 		}
 		case DISPATCH_TASK_THREE_LEVEL:
 		{
-			if ( m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_WORK || m_dispatch_device_status == DISPATCH_DEVICE_THREE_LEVEL_OVER )
-			{
-				//如果正在执行一级任务, 那么取消当前指令, 然后降级
-				m_execute_condition.notify_all(false);
-				//确保内部线程已经停下
-				while (m_execute_condition.is_working())
-				{
-
-				}
-				cancel_command();
-				{
-					std::unique_lock<std::mutex> t_lock(m_lock);
-					mp_device_three_level_task.reset();
-					m_dispatch_device_status = DISPATCH_DEVICE_TWO_LEVEL_WORK;
-				}
-				m_execute_condition.notify_all(true);
-			}
-			else
-			{
-				std::unique_lock<std::mutex> t_lock(m_lock);
-				//否则直接销毁任务单
-				mp_device_one_level_task.reset();
-			}
+			mp_device_three_level_task.reset();
 			break;
 		}
 		default:
@@ -379,7 +360,6 @@ int Dispatch_device_base::get_device_id()
 void Dispatch_device_base::execute_thread_fun()
 {
 	LOG(INFO) << " Dispatch_device_base::execute_thread_fun() start " << this;
-
 	Error_manager t_error;
 
 	while (m_execute_condition.is_alive())
@@ -392,7 +372,7 @@ void Dispatch_device_base::execute_thread_fun()
 //			std::this_thread::sleep_for(std::chrono::seconds(1));
 
 			std::this_thread::yield();
-
+			std::unique_lock<std::mutex> t_lock(m_lock);
 //			std::cout << " huli test :::: " << " m_device_id = " << m_device_id << std::endl;
 //			std::cout << " huli test :::: " << "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa m_dispatch_device_status = " << m_dispatch_device_status << std::endl;
 
@@ -535,35 +515,43 @@ void Dispatch_device_base::execute_thread_fun()
 				{
 					if ( mp_device_one_level_task.get() != NULL )
 					{
-						mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_WORKING);
-						//执行一级任务,
-						write_task_to_memory(mp_device_one_level_task);
-						//更新通信
-						update_device_communication();
-						//从内存中读数据到任务单
-						t_error = check_and_read_memory_to_task(mp_device_one_level_task);
-
-//						std::cout << " huli test :::: " << " 1111111111111111111111111111111111111111 = " << 111 << std::endl;
-//						std::cout << " huli test :::: " << " 12312312313131 = " << 123 << std::endl;
-//						std::cout << " huli test :::: " << " t_error = " << t_error.to_string() << std::endl;
-//						std::cout << " huli test :::: " << " 2222222222222222222222222222222222222222 = " << 222 << std::endl;
-
-
-						if ( t_error == NODATA )
+						if ( mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WITHDRAW )
 						{
-							//设备正常运行
-							//延时1ms, snap7的通信效率偏慢, 不需要高频率检查
-							std::this_thread::sleep_for(std::chrono::milliseconds(1));
+							//这里会通知任务已经释放, 然后销毁任务单,  并降级
+							mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_FREE);
+							mp_device_one_level_task.reset();
+							m_dispatch_device_status = DISPATCH_DEVICE_READY;
 						}
-						else
+
+						else if (mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_CREATED ||
+								 mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_SIGNED ||
+								 mp_device_one_level_task->get_task_statu() == Task_Base::Task_statu::TASK_WORKING )
 						{
-							if ( t_error != SUCCESS )
+							mp_device_one_level_task->set_task_statu(Task_Base::Task_statu::TASK_WORKING);
+							//执行一级任务,
+							write_task_to_memory(mp_device_one_level_task);
+							//更新通信
+							update_device_communication();
+							//从内存中读数据到任务单
+							t_error = check_and_read_memory_to_task(mp_device_one_level_task);
+
+							if ( t_error == NODATA )
+							{
+								//设备正常运行
+								//延时1ms, snap7的通信效率偏慢, 不需要高频率检查
+								std::this_thread::sleep_for(std::chrono::milliseconds(1));
+							}
+							else
 							{
-								mp_device_one_level_task->set_task_error_manager(t_error);
+								if ( t_error != SUCCESS )
+								{
+									mp_device_one_level_task->set_task_error_manager(t_error);
+								}
+								end_task(mp_device_one_level_task);
+								m_dispatch_device_status = DISPATCH_DEVICE_ONE_LEVEL_OVER;
 							}
-							end_task(mp_device_one_level_task);
-							m_dispatch_device_status = DISPATCH_DEVICE_ONE_LEVEL_OVER;
 						}
+						//else等待发送方给新的指令. TASK_STOP 之后 不执行.
 					}
 					else
 					{

dispatch/dispatch_device_base.h

@@ -237,9 +237,6 @@ protected://member variable
 	Dispatch_device_type				m_dispatch_device_type;
 	std::mutex							m_lock;	//锁
 
-
-
-
 	//任务执行线程
 	std::thread*        				mp_execute_thread;   			//执行的线程指针，内存由本类管理
 	Thread_condition					m_execute_condition;			//执行的条件变量

dispatch/dispatch_manager.cpp

@@ -19,10 +19,7 @@ Dispatch_manager::Dispatch_manager()
 	m_process_thread_queue = nullptr;
 	m_dispatch_manager_thread = nullptr;
 
-	mpp_space_lock = nullptr;
-	m_space_lock_rows = 0;
-	m_space_lock_columns = 0;
-	m_space_lock_total = 0;
+
 }
 
 Dispatch_manager::~Dispatch_manager()
@@ -96,73 +93,7 @@ Error_manager Dispatch_manager::dispatch_manager_init_from_protobuf(Dispatch_pro
 		m_passageway_map[t_id] = tp_dispatch_device_base;
 	}
 
-	m_space_lock_rows = dispatch_device_parameter_all.parkspace_number().rows();
-	m_space_lock_columns = dispatch_device_parameter_all.parkspace_number().columns();
-	m_space_lock_total = dispatch_device_parameter_all.parkspace_number().total();
-	mpp_space_lock = new space_device*[m_space_lock_rows];
-	for (int i = 0; i < m_space_lock_rows; ++i)
-	{
-		mpp_space_lock[i] = new space_device[m_space_lock_columns];
-		for (int j = 0; j < m_space_lock_columns; ++j)
-		{
-			//注意了, 这里一定要初始化为-1, 因为设备id=0 是有效设备
-			mpp_space_lock[i][j].m_catcher_id = -1;
-			mpp_space_lock[i][j].m_carrier_id = -1;
-		}
-	}
 
-	//等待和plc建立通信后, 标定初始位置, 并加锁. (初始位置可能不标准, 要把左右的都加锁)
-//	auto t_time = std::chrono::system_clock::now();
-//	bool t_flag = false;
-//	int t_rows_index = 0;
-//	int t_columns_index = 0;
-//	while ( std::chrono::system_clock::now() - t_time < std::chrono::seconds(5) || t_flag == false)
-//	{
-//		t_flag = true;
-//		//先判断搬运器的
-//
-//		for (auto iter = m_catcher_map.begin(); iter != m_catcher_map.end(); ++iter)
-//		{
-//			Catcher* tp_catcher = (Catcher*)iter->second.get();
-//			int coordinates_id = tp_catcher->m_actual_coordinates_id;
-//			if ( coordinates_id == 0 )
-//			{
-//				t_flag = false;
-//			}
-//			else if(coordinates_id>0 && coordinates_id<=dispatch_device_parameter_all.parkspace_number().total())
-//			{
-//				t_rows_index = coordinates_id/columns;
-//				t_columns_index = coordinates_id%columns;
-//				mpp_space_lock[t_rows_index][t_columns_index].catcher_id = tp_catcher->get_device_id();
-//				t_rows_index = (coordinates_id+1)/columns;
-//				t_columns_index = (coordinates_id+1)%columns;
-//				mpp_space_lock[t_rows_index][t_columns_index].catcher_id = tp_catcher->get_device_id();
-//				t_rows_index = (coordinates_id-1)/columns;
-//				t_columns_index = (coordinates_id-1)%columns;
-//				mpp_space_lock[t_rows_index][t_columns_index].catcher_id = tp_catcher->get_device_id();
-//			}
-//			else if ( coordinates_id>PASSAGEWAY_ID_BASE )
-//			{
-//				coordinates_id
-//			}
-//		}
-//		std::this_thread::sleep_for(std::chrono::microseconds(1));
-//	}
-//	if ( t_flag == false )
-//	{
-//	    return Error_manager(Error_code::DISPATCH_MANAGER_SPACE_LOCK_ERROR, Error_level::MINOR_ERROR,
-//	    					" Dispatch_manager::dispatch_manager_init_from_protobuf error ");
-//	}
-
-	std::cout << " huli test :::: " << " m_catcher_size = " << m_catcher_size << std::endl;
-	std::cout << " huli test :::: " << " m_catcher_map.size() = " << m_catcher_map.size() << std::endl;
-	std::cout << " huli test :::: " << " m_carrier_size = " << m_carrier_size << std::endl;
-	std::cout << " huli test :::: " << " m_carrier_map.size() = " << m_carrier_map.size() << std::endl;
-	std::cout << " huli test :::: " << " m_passageway_size = " << m_passageway_size << std::endl;
-	std::cout << " huli test :::: " << " m_passageway_map.size() = " << m_passageway_map.size() << std::endl;
-
-	std::cout << " huli test :::: " << " m_space_lock_rows = " << m_space_lock_rows << std::endl;
-	std::cout << " huli test :::: " << " m_space_lock_columns = " << m_space_lock_columns << std::endl;
 
 	//调度管理 设备复位
 	t_error = dispatch_manager_device_reset();
@@ -207,31 +138,6 @@ Error_manager Dispatch_manager::dispatch_manager_uninit()
 	m_dispatch_manager_id = -1;
 
 
-//	for (int i = 0; i < m_catcher_size; ++i)
-//	{
-//		m_catcher_vector[i]->dispatch_device_base_uninit();
-//		delete(m_catcher_vector[i]);
-//	}
-//	m_catcher_size = 0;
-//	m_catcher_vector.clear();
-//
-//	for (int i = 0; i < m_carrier_size; ++i)
-//	{
-//		m_carrier_vector[i]->dispatch_device_base_uninit();
-//		delete(m_carrier_vector[i]);
-//	}
-//	m_carrier_size = 0;
-//	m_carrier_vector.clear();
-//
-//	for (int i = 0; i < m_passageway_size; ++i)
-//	{
-//		m_passageway_vector[i]->dispatch_device_base_uninit();
-//		delete(m_passageway_vector[i]);
-//	}
-//	m_passageway_size = 0;
-//	m_passageway_vector.clear();
-
-
 	return Error_code::SUCCESS;
 }
 
@@ -733,38 +639,3 @@ void Dispatch_manager::set_dispatch_manager_id(int dispatch_manager_id)
 {
 	m_dispatch_manager_id = dispatch_manager_id;
 }
-
-void Dispatch_manager::set_space_lock(int space_rows, int space_columns, int catcher_id, int carrier_id)
-{
-	std::unique_lock<std::mutex> t_lock(m_lock);
-	mpp_space_lock[space_rows][space_columns].m_catcher_id = catcher_id;
-	mpp_space_lock[space_rows][space_columns].m_carrier_id = carrier_id;
-}
-void Dispatch_manager::set_space_lock_for_catcher(int space_rows, int space_columns, int catcher_id)
-{
-	std::unique_lock<std::mutex> t_lock(m_lock);
-	mpp_space_lock[space_rows][space_columns].m_catcher_id = catcher_id;
-}
-void Dispatch_manager::set_space_lock_for_carrier(int space_rows, int space_columns, int carrier_id)
-{
-	std::unique_lock<std::mutex> t_lock(m_lock);
-	mpp_space_lock[space_rows][space_columns].m_carrier_id = carrier_id;
-}
-void Dispatch_manager::set_space_lock(int space_id, int catcher_id, int carrier_id)
-{
-	int space_rows = (space_id-1) / m_space_lock_columns;
-	int space_columns = (space_id-1) % m_space_lock_columns;
-	set_space_lock(space_rows, space_columns, catcher_id, carrier_id);
-}
-void Dispatch_manager::set_space_lock_for_catcher(int space_id, int catcher_id)
-{
-	int space_rows = (space_id-1) / m_space_lock_columns;
-	int space_columns = (space_id-1) % m_space_lock_columns;
-	set_space_lock_for_catcher(space_rows, space_columns, catcher_id);
-}
-void Dispatch_manager::set_space_lock_for_carrier(int space_id, int carrier_id)
-{
-	int space_rows = (space_id-1) / m_space_lock_columns;
-	int space_columns = (space_id-1) % m_space_lock_columns;
-	set_space_lock_for_carrier(space_rows, space_columns, carrier_id);
-}

dispatch/dispatch_manager.h

@@ -70,12 +70,7 @@ public:
 		E_PICKUP_CAR            =1,         //取车, 停车位 -> 出入口
 	};
 
-	//调度设备的id集合
-	struct space_device
-	{
-	    int m_catcher_id;
-	    int m_carrier_id;
-	};
+
 private:
  // 父类的构造函数必须保护，子类的构造函数必须私有。
    Dispatch_manager();
@@ -131,13 +126,7 @@ public://get or set member variable
 	int get_dispatch_manager_id();
 	void set_dispatch_manager_id(int dispatch_id);
 
-	void set_space_lock(int space_rows, int space_columns, int catcher_id, int carrier_id);
-	void set_space_lock_for_catcher(int space_rows, int space_columns, int catcher_id);
-	void set_space_lock_for_carrier(int space_rows, int space_columns, int carrier_id);
 
-	void set_space_lock(int space_id, int catcher_id, int carrier_id);
-	void set_space_lock_for_catcher(int space_id, int catcher_id);
-	void set_space_lock_for_carrier(int space_id, int carrier_id);
 
 public://member variable
 
@@ -169,12 +158,6 @@ public://member variable
 	std::thread*                        		m_dispatch_manager_thread;        	//调度总管理的线程, 总控全局, 控制每个流程的先后顺序, 并合理的分配资源.
 	Thread_condition				    		m_dispatch_manager_condition;		//调度总管理的条件变量, 总控全局, 控制每个流程的先后顺序, 并合理的分配资源.
 
-	//空间锁, 防撞. (存放着调度设备的id集合, 交接过程中, 允许两个个设备占有同一个空间)
-	space_device**										mpp_space_lock;						//空间锁, 二维数组, 存放着调度设备的id集合, 内存由本模块管理, (默认11*15=165)
-	int													m_space_lock_rows;					//空间锁, 行
-	int													m_space_lock_columns;				//空间锁, 列
-	int													m_space_lock_total;					//空间锁, 总数
-
 private:
 
 };

dispatch/dispatch_parameter.proto

@@ -20,12 +20,7 @@ message Passageway_parameter
     required int32                  key = 2;
 }
 
-message Parkspace_number
-{
-    required int32                  rows = 1;
-    required int32                  columns = 2;
-    required int32                  total = 3;
-}
+
 
 message Dispatch_device_parameter_all
 {
@@ -36,7 +31,6 @@ message Dispatch_device_parameter_all
     required int32                  passageway_size=5;
     repeated Passageway_parameter   passageway_parameters=6;
 
-    required Parkspace_number       parkspace_number=7;
 }
 
 
@@ -144,6 +138,13 @@ enum Passageway_functioning_pattern
     PASSAGEWAY_FUNCTIONING_PATTERN_BIDIRECTION      = 3;    //双向口
 }
 
+message Parkspace_number
+{
+    required int32                  rows = 1;
+    required int32                  columns = 2;
+    required int32                  total = 3;
+}
+
 message Dispatch_coordinates_parameter_all
 {
     repeated Packspace_coordinates_parameter            packspace_coordinates_parameters = 1;
@@ -200,5 +201,5 @@ message Dispatch_coordinates_parameter_all
     optional int32                                      car_wheel_base_min = 38;
     optional int32                                      car_wheel_base_max = 39;
 
-
+    required Parkspace_number                           parkspace_number=40;
 }

dispatch/dispatch_process.h

@@ -102,10 +102,6 @@ public:
 		std::shared_ptr<Dispatch_device_base>	mp_dispatch_device;					//调度设备指针, 内存由Dispatch_manager来管理
 		std::shared_ptr<Task_Base>				mp_dispatch_task;					//调度任务指针, 内存由本模块管理
 
-
-
-
-
 		//注释
 		message::Dispatch_control_request_msg	m_dispatch_control_request_msg;		//3调度控制的任务请求(调度算法->调度管理) 注释
 		message::Dispatch_control_response_msg	m_dispatch_control_response_msg;	//4调度控制的任务答复(调度管理->调度算法) 注释
@@ -114,7 +110,31 @@ public:
 
 		Error_manager							m_error;							//错误码
 		std::chrono::system_clock::time_point	m_time_to_send_control_response;		//发送 控制的任务答复 的时间 注释
+	};
 
+	//调度设备机器人节点
+	struct Dispatch_catcher_node
+	{
+		Dispatch_control_status					m_dispatch_control_status;			//调度控制的状态, 控制步骤(对于一个设备的长流程的控制)
+		//核心机器人, 2号
+		std::shared_ptr<Catcher>				mp_main_catcher;						//调度设备指针, 内存由Dispatch_manager来管理
+		std::shared_ptr<Catcher_task>			mp_main_catcher_task;					//调度任务指针, 内存由本模块管理
+		//跟随搬运器, 3号搬运器
+		std::shared_ptr<Carrier>				mp_following_carrier;					//调度设备指针, 内存由Dispatch_manager来管理
+		std::shared_ptr<Carrier_task>			mp_following_carrier_task;				//调度任务指针, 内存由本模块管理
+		//目前没有让别人避让的功能
+	};
+
+	//调度设备机器人节点
+	struct Dispatch_carrier_node
+	{
+		Dispatch_control_status					m_dispatch_control_status;			//调度控制的状态, 控制步骤(对于一个设备的长流程的控制)
+		//核心搬运器, 1号或者2号搬运器
+		std::shared_ptr<Carrier>				mp_main_carrier;					//调度设备指针, 内存由Dispatch_manager来管理
+		std::shared_ptr<Carrier_task>			mp_main_carrier_task;				//调度任务指针, 内存由本模块管理
+		//给机器人发送避让指令, 2号机器人(可选)
+		std::shared_ptr<Catcher>				mp_avoid_catcher;						//调度设备指针, 内存由Dispatch_manager来管理
+		std::shared_ptr<Catcher_task>			mp_avoid_catcher_task;					//调度任务指针, 内存由本模块管理
 	};
 
 

dispatch/passageway.cpp

@@ -71,8 +71,6 @@ Error_manager Passageway::write_task_to_memory(std::shared_ptr<Task_Base> p_task
 	}
 	else
 	{
-		std::unique_lock<std::mutex> t_lock(m_lock);
-
 		Passageway_task* tp_passageway_task = (Passageway_task*)p_task.get();
 		std::unique_lock<std::mutex> t_lock1(tp_passageway_task->m_lock);
 		m_request_key = tp_passageway_task->m_request_key;
@@ -88,7 +86,6 @@ Error_manager Passageway::write_task_to_memory(std::shared_ptr<Task_Base> p_task
 Error_manager Passageway::update_device_communication()
 {
 	std::unique_lock<std::mutex> t_lock1(Dispatch_communication::get_instance_references().m_data_lock);
-	std::unique_lock<std::mutex> t_lock(m_lock);
 
 	//请求消息, 调度->plc
 	Dispatch_communication::Passageway_request_from_dispatch_to_plc_for_data * tp_passageway_request_from_dispatch_to_plc_for_data =
@@ -290,7 +287,6 @@ Error_manager Passageway::check_and_read_memory_to_task(std::shared_ptr<Task_Bas
 	}
 	else
 	{
-		std::unique_lock<std::mutex> t_lock(m_lock);
 		if ( m_respons_key == m_request_key && m_respons_status != RESPONS_WORKING )
 		{
 			Passageway_task* tp_passageway_task = (Passageway_task*)p_task.get();

error_code/error_code.h

@@ -361,9 +361,11 @@ enum Error_code
 	DISPATCH_DEVICE_STATUS_DISCONNECT,					//调度设备模块，状态断连
 	DISPATCH_DEVICE_TASK_TYPE_ERROR,					//调度设备模块，任务类型错误
 	DISPATCH_DEVICE_TASK_OVER_TIME,						//调度设备模块，任务超时
+	DISPATCH_DEVICE_TASK_REPEAT,						//调度设备模块，任务重复, 任务已经存在
 	DISPATCH_DEVICE_IS_NOT_READY,						//调度设备模块，不在准备状态
 	DISPATCH_DEVICE_RESPONS_ERROR,						//调度设备模块，指令的执行失败
 	DISPATCH_DEVICE_TASK_NOTHINGNESS,					//调度设备模块，任务不存在
+	DISPATCH_DEVICE_TASK_LEVEL_ERROR,					//调度设备模块，任务等级错误
 
 
 	CARRIER_ERROR_BASE								= 0x13040000,

main.cpp

@@ -71,7 +71,7 @@ int main(int argc,char* argv[])
 	FLAGS_stop_logging_if_full_disk = true;
 
 
-#define MAIN_TEST 1
+//#define MAIN_TEST 1
 #ifdef MAIN_TEST
 	t_error = Dispatch_coordinates::get_instance_references().dispatch_coordinates_init();
 	std::cout << " huli test :::: " << " Dispatch_coordinates::get_instance_references().dispatch_coordinates_init() = " << t_error.to_string() << std::endl;
@@ -91,25 +91,25 @@ int main(int argc,char* argv[])
 
 	while (1)
 	{
-		Dispatch_manager::space_device** tpp = Dispatch_manager::get_instance_references().mpp_space_lock;
-		for (int i = 0; i < 11; ++i)
-		{
-			for (int j = 0; j < 15; ++j)
-			{
-				if ( tpp[i][j].m_catcher_id  != -1 )
-				{
-					std::cout << " huli test :::: " << " tpp[i][j].m_catcher_id = " << tpp[i][j].m_catcher_id << std::endl;
-					std::cout << " huli test :::: " << " i = " << i << std::endl;
-					std::cout << " huli test :::: " << " j = " << j << std::endl;
-				}
-				if ( tpp[i][j].m_carrier_id  != -1 )
-				{
-					std::cout << " huli test :::: " << " tpp[i][j].m_carrier_id = " << tpp[i][j].m_carrier_id << std::endl;
-					std::cout << " huli test :::: " << " i = " << i << std::endl;
-					std::cout << " huli test :::: " << " j = " << j << std::endl;
-				}
-			}
-		}
+//		Dispatch_manager::space_device** tpp = Dispatch_manager::get_instance_references().mpp_space_lock;
+//		for (int i = 0; i < 11; ++i)
+//		{
+//			for (int j = 0; j < 15; ++j)
+//			{
+//				if ( tpp[i][j].m_catcher_id  != -1 )
+//				{
+//					std::cout << " huli test :::: " << " tpp[i][j].m_catcher_id = " << tpp[i][j].m_catcher_id << std::endl;
+//					std::cout << " huli test :::: " << " i = " << i << std::endl;
+//					std::cout << " huli test :::: " << " j = " << j << std::endl;
+//				}
+//				if ( tpp[i][j].m_carrier_id  != -1 )
+//				{
+//					std::cout << " huli test :::: " << " tpp[i][j].m_carrier_id = " << tpp[i][j].m_carrier_id << std::endl;
+//					std::cout << " huli test :::: " << " i = " << i << std::endl;
+//					std::cout << " huli test :::: " << " j = " << j << std::endl;
+//				}
+//			}
+//		}
 
 		std::this_thread::sleep_for(std::chrono::seconds(1));
 	}
@@ -154,11 +154,12 @@ int main(int argc,char* argv[])
 	std::cout << " huli test :::: " << " t_error = " << t_error << std::endl;
 	std::this_thread::sleep_for(std::chrono::seconds(2));
 
+
 	std::shared_ptr<Task_Base> tp_task_Base1(new Catcher_task);
 	Catcher_task * tp_catcher_task1 = (Catcher_task *)tp_task_Base1.get();
 	tp_catcher_task1->task_init(NULL,std::chrono::milliseconds(15000));
 	tp_catcher_task1->m_request_key = "x23456789012345678901234567890r1";
-	tp_catcher_task1->m_request_x = 11055;
+	tp_catcher_task1->m_request_x = 24855;
 	tp_catcher_task1->m_request_y = 3000;
 	tp_catcher_task1->m_request_b = 90;
 	tp_catcher_task1->m_request_z = 5410;
@@ -170,6 +171,7 @@ int main(int argc,char* argv[])
 	std::cout << " huli test :::: " << " t_error = " << t_error << std::endl;
 	std::cout << " ---------------------------------------------------" << std::endl;
 
+	
 	/*
 	char zxczxcxzc1 ;
 	std::cin >> zxczxcxzc1 ;

setting/dispatch_coordinates.prototxt

@@ -3324,5 +3324,10 @@ parkspace_id_total:165
 car_wheel_base_min:1000
 car_wheel_base_max:4000
 
-
+parkspace_number
+{
+    rows:11
+    columns:15
+    total:165
+}
 

setting/dispatch_device.prototxt

@@ -27,12 +27,7 @@ carrier_parameters
 
 passageway_size:0
 
-parkspace_number
-{
-    rows:11
-    columns:15
-    total:165
-}
+
 
 
 

task/task_base.h

@@ -10,6 +10,7 @@
 #include <string>
 #include "../error_code/error_code.h"
 #include <chrono>
+#include <atomic>
 
 //任务超时时间默认值10000ms，10秒
 #define TASK_OVER_TIME_DEFAULT				10000
@@ -182,7 +183,7 @@ public:
 protected:
 	unsigned int				m_task_id;						//任务id, 每次新建任务, 自动+1, 用于多任务的管理
     Task_type                   m_task_type;					//任务类型，不允许中途修改
-    Task_statu                  m_task_statu;					//任务状态
+	std::atomic<Task_statu>     m_task_statu;					//任务状态
     std::string					m_task_statu_information;		//任务状态说明
     void*						mp_tast_receiver;				//任务接收方，Task_Base并不分配和释放内存。
     //注：mp_tast_receiver是可选的，可以为NULL。如果为NULL，则需要task_command_manager去找到接收对象。