20210527, 调度资源分配

dispatch/carrier.cpp

@@ -54,6 +54,12 @@ Carrier::Carrier()
 	m_actual_coordinates_rows = 0;
 	m_actual_coordinates_columns = 0;
 
+	m_redirect_flag = false;
+	m_catcher_run_flag = false;
+	m_redirect_pickup_parkspace_id = 0;
+	m_redirect_pickup_car_type = Common_data::Car_type::UNKNOW_CAR_TYPE;
+	m_redirect_store_parkspace_id = 0;
+	m_redirect_store_car_type = Common_data::Car_type::UNKNOW_CAR_TYPE;
 }
 
 Carrier::~Carrier()
@@ -410,7 +416,3 @@ Error_manager Carrier::update_actual_coordinates_id()
 
 
 
-
-
-
-

dispatch/carrier.h

@@ -22,9 +22,11 @@ public:
 public://API functions
 	//检查任务类型, 子类必须重载, 用来检查输入的任务是否为子类所需的.
 	Error_manager check_task_type(std::shared_ptr<Task_Base> p_task);
+
 public://get or set member variable
 	//获取硬件设备的状态, 必须子类继承
 	Hardware_device_status get_actual_device_status();
+
 protected://member functions
 	//把任务单写入到内存中, 子类必须重载
 	Error_manager write_task_to_memory(std::shared_ptr<Task_Base> p_task);
@@ -55,6 +57,9 @@ public:
 	int 								m_request_floor_id;			//搬运器楼层位置的id.
 	float 								m_request_wheelbase;		//搬运器小跑车的抓车杆前后轮距.
 
+
+
+
 	//plc反馈给调度
 	std::string							m_respons_key;				//应答的唯一码, 用作识别
 	Respons_status						m_respons_status;			//指令完成状态, 搬运器答复指令, 返回任务完成的情况
@@ -101,6 +106,14 @@ public:
 	int 								m_actual_coordinates_rows;			//搬运器真实 空间位置的行.
 	int 								m_actual_coordinates_columns;		//搬运器真实 空间位置的列.
 
+	//改道模块, 3级存车任务和1级取车任务 此时需要改道
+	bool 								m_redirect_flag;				//能否改道的标志位, 真:存车时搬运器还没有做电梯上去, 此时可以为了下一辆取车改道, 假:不能改道
+	bool 								m_catcher_run_flag;				//存车任务是否在等机器人就绪, 假:存车时机器人在干别的事情, 此时可能要等很久, 降低改道的权重, 真:机器人已经在做3级存车任务
+	int 								m_redirect_pickup_parkspace_id;		//一级取车任务 需要改道去的停车位
+	Common_data::Car_type				m_redirect_pickup_car_type;			//一级取车任务 车辆类型
+	int 								m_redirect_store_parkspace_id;		//三级存车任务 需要被改道的停车位
+	Common_data::Car_type				m_redirect_store_car_type;			//三级存车任务 车辆类型
+
 private:
 
 };

dispatch/carrier_task.cpp

@@ -26,6 +26,8 @@ Carrier_task::Carrier_task()
 	m_request_floor_id = 0;			//搬运器楼层位置的id.
 	m_request_wheelbase = 0;		//搬运器抓车杆前后轮距.
 
+
+
 	m_respons_status = RESPONS_WORKING;			//指令完成状态, 搬运器答复指令, 返回任务完成的情况
 	m_respons_x = 0;				//搬运器坐标x轴,
 	m_respons_y = 0;				//搬运器坐标y轴,

dispatch/carrier_task.h

@@ -71,6 +71,7 @@ public://member variable
 	int 								m_request_floor_id;			//搬运器楼层位置的id.
 	float 								m_request_wheelbase;		//搬运器小跑车的抓车杆前后轮距.
 
+
 	//plc反馈给调度
 	std::string							m_respons_key;				//应答的唯一码, 用作识别
 	Respons_status						m_respons_status;			//指令完成状态, 搬运器答复指令, 返回任务完成的情况

dispatch/dispatch_coordinates.cpp

@@ -47,6 +47,8 @@ Error_manager Dispatch_coordinates::dispatch_coordinates_init_from_protobuf(Disp
 	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();
+	m_liftway_width = dispatch_coordinates_parameter_all.parkspace_number().liftway_width();
+
 	mpp_space_lock = new space_device*[m_space_lock_rows];
 	for (int i = 0; i < m_space_lock_rows; ++i)
 	{
@@ -124,7 +126,7 @@ Error_manager Dispatch_coordinates::dispatch_coordinates_init_from_protobuf(Disp
 	m_catcher_b_min = dispatch_coordinates_parameter_all.catcher_b_min();
 	m_catcher_b_max = dispatch_coordinates_parameter_all.catcher_b_max();
 	m_catcher_d1_min = dispatch_coordinates_parameter_all.catcher_d1_min();
-	m_catcher_d1_max = dispatch_coordinates_parameter_all.catcher_d1_max();	
+	m_catcher_d1_max = dispatch_coordinates_parameter_all.catcher_d1_max();
 	m_catcher_d2_min = dispatch_coordinates_parameter_all.catcher_d2_min();
 	m_catcher_d2_max = dispatch_coordinates_parameter_all.catcher_d2_max();
 
@@ -176,9 +178,14 @@ Error_manager Dispatch_coordinates::dispatch_coordinates_init_from_protobuf(Disp
 	m_parkspace_id_max = dispatch_coordinates_parameter_all.parkspace_id_max();
 	m_parkspace_id_total = dispatch_coordinates_parameter_all.parkspace_id_total();
 
+	m_third_floor_parkspace_id_min = dispatch_coordinates_parameter_all.third_floor_parkspace_id_min();
+	m_third_floor_parkspace_id_max = dispatch_coordinates_parameter_all.third_floor_parkspace_id_max();
+	m_third_floor_parkspace_id_total = dispatch_coordinates_parameter_all.third_floor_parkspace_id_total();
+
 	m_car_wheel_base_min = dispatch_coordinates_parameter_all.car_wheel_base_min();
 	m_car_wheel_base_max = dispatch_coordinates_parameter_all.car_wheel_base_max();
 
+
 	return Error_code::SUCCESS;
 }
 //反初始化
@@ -192,6 +199,201 @@ Error_manager Dispatch_coordinates::dispatch_coordinates_uninit()
 	return Error_code::SUCCESS;
 }
 
+//获取2点之间的路径长度, 只算x轴和z轴, 只是计算一个大概值
+Error_manager Dispatch_coordinates::get_distance(int coordinates_id_1, int coordinates_id_2, Parkspace_path parkspace_path, float & distance)
+{
+	//是否在1楼的标记位,
+	float t_distance_x = 0;
+	float t_distance_z = 0;
+
+	//检查合法性
+	if ( m_carrier_coordinates.find(coordinates_id_1) != m_carrier_coordinates.end() &&
+		 m_carrier_coordinates.find(coordinates_id_2) != m_carrier_coordinates.end() )
+	{
+		//计算距离
+		if(coordinates_id_1 == coordinates_id_2)
+		{
+			distance = 0;
+		}
+		else if ( m_carrier_coordinates[coordinates_id_1].z == m_carrier_coordinates[coordinates_id_2].z )
+		{
+			distance = m_carrier_coordinates[coordinates_id_1].x - m_carrier_coordinates[coordinates_id_2].x;
+			if ( distance<0 )
+			{
+				distance = -distance;
+			}
+		}
+		else if ( parkspace_path == Dispatch_coordinates::Parkspace_path::LEFT_PATH )
+		{
+			t_distance_x = (m_carrier_coordinates[coordinates_id_1].x - m_carrier_default_x_left) +
+						   (m_carrier_coordinates[coordinates_id_2].x - m_carrier_default_x_left);
+			t_distance_z = m_carrier_coordinates[coordinates_id_1].z - m_carrier_coordinates[coordinates_id_2].z;
+			if ( t_distance_z<0 )
+			{
+				t_distance_z = -t_distance_z;
+			}
+			distance = t_distance_x + t_distance_z;
+		}
+		else if ( parkspace_path == Dispatch_coordinates::Parkspace_path::RIGHT_PATH )
+		{
+			t_distance_x = (m_carrier_default_x_right - m_carrier_coordinates[coordinates_id_1].x ) +
+						   (m_carrier_default_x_right - m_carrier_coordinates[coordinates_id_2].x );
+			t_distance_z = m_carrier_coordinates[coordinates_id_1].z - m_carrier_coordinates[coordinates_id_2].z;
+			if ( t_distance_z<0 )
+			{
+				t_distance_z = -t_distance_z;
+			}
+			distance = t_distance_x + t_distance_z;
+		}
+		else if ( parkspace_path == Dispatch_coordinates::Parkspace_path::TEMPORARY_CACHE_PATH )
+		{
+			t_distance_x = m_carrier_coordinates[coordinates_id_1].x - m_carrier_coordinates[coordinates_id_2].x;
+			if ( t_distance_x<0 )
+			{
+				t_distance_x = -t_distance_x;
+			}
+			t_distance_z = m_carrier_coordinates[coordinates_id_1].z - m_carrier_coordinates[coordinates_id_2].z;
+			if ( t_distance_z<0 )
+			{
+				t_distance_z = -t_distance_z;
+			}
+			distance = t_distance_x + t_distance_z;
+		}
+		else
+		{
+			return Error_manager(Error_code::DISPATCH_COORDINATES_PATH_ERROR, Error_level::MINOR_ERROR,
+								 " Dispatch_coordinates::get_distance parkspace_path error ");
+		}
+	}
+	else
+	{
+		return Error_manager(Error_code::DISPATCH_COORDINATES_ID_ERROR, Error_level::MINOR_ERROR,
+							 " Dispatch_coordinates::get_distance coordinates_id error ");
+	}
+	return Error_code::SUCCESS;
+}
+
+//把1楼出入口的坐标修正到2楼.
+bool Dispatch_coordinates::amend_coordinates_from_1st_floor_to_2nd_floor(int & coordinates_id)
+{
+	if ( coordinates_id >= PASSAGEWAY_ID_BASE+1 && coordinates_id<= PASSAGEWAY_ID_BASE + m_passageway_terminal_id_max-1)
+	{
+		coordinates_id = coordinates_id+100;	//例如:把 1103 改为 1203
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+	return false;
+}
+
+//选择最近的搬运器, return true:选左边, return false:选右边
+bool Dispatch_coordinates::choice_nearest_carrier(int dispatch_source, int coordinates_id_1, int coordinates_id_2)
+{
+	Error_manager t_error;
+	//选最近的搬运器
+	float t_distance_left = 0;
+	t_error = get_distance(dispatch_source, coordinates_id_1, Dispatch_coordinates::Parkspace_path::LEFT_PATH, t_distance_left );
+	if ( t_error != Error_code::SUCCESS )
+	{
+		LOG(INFO) << " Dispatch_manager::resource_allocation() m_process_pickup_list error = "<< t_error.to_string() << "   " << this;
+	}
+	float t_distance_right = 0;
+	t_error = get_distance(dispatch_source, coordinates_id_2, Dispatch_coordinates::Parkspace_path::RIGHT_PATH, t_distance_right );
+	if ( t_error != Error_code::SUCCESS )
+	{
+		LOG(INFO) << " Dispatch_manager::resource_allocation() m_process_pickup_list error = "<< t_error.to_string() << "   " << this;
+	}
+	if ( t_distance_left <= t_distance_right )
+	{
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+//判断取车的路径
+Dispatch_coordinates::Parkspace_path Dispatch_coordinates::get_pickup_path(int dispatch_source, int dispatch_destination)
+{
+	if ( dispatch_source >= 0 && dispatch_source <= 165 &&
+		 dispatch_destination >= 1100 && dispatch_destination <= 1107)
+	{
+		if ( dispatch_source >= 19 && dispatch_source <= 27 )
+		{
+			if ( dispatch_destination >= 1101 && dispatch_destination <= 1106 )
+			{
+				return Dispatch_coordinates::Parkspace_path::THIRD_FLOOR_PATH;
+			}
+			else
+			{
+				return Dispatch_coordinates::Parkspace_path::UNKNOW_PATH;
+			}
+		}
+		else
+		{
+			int t_columns = dispatch_source % 15;
+			if ( (t_columns ==1 && t_columns == 2 && t_columns ==3) ||
+				 (dispatch_source >= 34 && dispatch_source <= 37) )
+			{
+				if ( dispatch_destination >= 1100 && dispatch_destination <= 1106 )
+				{
+					return Dispatch_coordinates::Parkspace_path::LEFT_PATH;
+				}
+				else
+				{
+					return Dispatch_coordinates::Parkspace_path::UNKNOW_PATH;
+				}
+			}
+			else if ( (t_columns ==13 && t_columns == 14 && t_columns ==0) ||
+					  (dispatch_source >= 38 && dispatch_source <= 42) )
+			{
+				if ( dispatch_destination >= 1101 && dispatch_destination <= 1107 )
+				{
+					return Dispatch_coordinates::Parkspace_path::RIGHT_PATH;
+				}
+				else
+				{
+					return Dispatch_coordinates::Parkspace_path::UNKNOW_PATH;
+				}
+			}
+			else
+			{
+				if ( dispatch_destination >= 1101 && dispatch_destination <= 1106 )
+				{
+					return Dispatch_coordinates::Parkspace_path::DOUBLE_PATH;
+				}
+				else if ( dispatch_destination == 1100 )
+				{
+					return Dispatch_coordinates::Parkspace_path::LEFT_PATH;
+				}
+				else if ( dispatch_destination == 1107 )
+				{
+					return Dispatch_coordinates::Parkspace_path::RIGHT_PATH;
+				}
+				else
+				{
+					return Dispatch_coordinates::Parkspace_path::UNKNOW_PATH;
+				}
+			}
+		}
+	}
+	else
+	{
+		return Dispatch_coordinates::Parkspace_path::UNKNOW_PATH;
+	}
+
+	return Dispatch_coordinates::Parkspace_path::UNKNOW_PATH;
+}
+
+
+//检查停车位和取车位, 判断是否能改道
+bool Dispatch_coordinates::is_able_redirect(int pickup_parkspace_id, int store_parkspace_id)
+{
+	return true;
+}
 
 void Dispatch_coordinates::set_space_lock(int space_rows, int space_columns, int catcher_id, int carrier_id)
 {

dispatch/dispatch_coordinates.h

@@ -9,6 +9,7 @@
 #include "../dispatch/dispatch_parameter.pb.h"
 #include "../tool/singleton.h"
 #include "../tool/point3D_tool.h"
+#include "../tool/common_data.h"
 #include <glog/logging.h>
 #include <map>
 #include <mutex>
@@ -32,6 +33,20 @@ public:
 		PASSAGEWAY_FUNCTIONING_PATTERN_BIDIRECTION      = 3,    //双向口
 	};
 
+	//车位分配路线（根据中跑车的路线来定）
+	enum Parkspace_path
+	{
+		UNKNOW_PATH = 0,				//未知
+		OPTIMAL_PATH = 1,				//最优路径, A方案
+		LEFT_PATH = 2,					//左侧路径, B方案
+		RIGHT_PATH = 3,					//右车路径, B方案
+		TEMPORARY_CACHE_PATH = 4,		//临时停车位路径, B方案
+
+		DOUBLE_PATH = 5, 				//左右都可以的路径, B方案取车专用
+		THIRD_FLOOR_PATH = 6, 			//3楼路径, B方案取车专用
+
+	};
+
 	//调度设备的id集合
 	struct space_device
 	{
@@ -56,6 +71,16 @@ public://API functions
 	Error_manager dispatch_coordinates_init_from_protobuf(Dispatch_proto::Dispatch_coordinates_parameter_all& dispatch_coordinates_parameter_all);
 	//反初始化
 	virtual Error_manager dispatch_coordinates_uninit();
+	//获取2点之间的路径长度, 只算x轴和z轴, 只是计算一个大概值
+	Error_manager get_distance(int coordinates_id_1, int coordinates_id_2, Parkspace_path parkspace_path, float & distance);
+	//把1楼出入口的坐标修正到2楼.
+	bool amend_coordinates_from_1st_floor_to_2nd_floor(int & coordinates_id);
+	//选择最近的搬运器, return true:选左边, return false:选右边
+	bool choice_nearest_carrier(int dispatch_source, int coordinates_id_1, int coordinates_id_2);
+	//判断取车的路径
+	Parkspace_path get_pickup_path(int dispatch_source, int dispatch_destination);
+	//检查停车位和取车位, 判断是否能改道
+	bool is_able_redirect(int pickup_parkspace_id, int store_parkspace_id);
 public://get or set member variable
 
 	void set_space_lock(int space_rows, int space_columns, int catcher_id, int carrier_id);
@@ -65,6 +90,7 @@ public://get or set member variable
 	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
@@ -72,10 +98,10 @@ 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;					//空间锁, 总数
-
+	int													m_space_lock_rows;					//空间锁, 行		(默认11)
+	int													m_space_lock_columns;				//空间锁, 列		(默认15)
+	int													m_space_lock_total;					//空间锁, 总数	(默认165)
+	int 												m_liftway_width;					//电梯井道宽, 默认占有3列车位
 
 
 
@@ -135,9 +161,13 @@ public://member variable
 	int										m_passageway_terminal_number;		//通道口终端个数, 默认8
 	std::map<int, Passageway_functioning_pattern>	m_passageway_functioning_pattern_map;//出入口的功能模式
 
-	int										m_parkspace_id_min;			//车位id最小值, 默认1
-	int										m_parkspace_id_max;			//车位id最小值, 默认165
-	int										m_parkspace_id_total;			//车位id总数, 默认165
+	int										m_parkspace_id_min;					//车位id最小值, 默认1
+	int										m_parkspace_id_max;					//车位id最小值, 默认165
+	int										m_parkspace_id_total;				//车位id总数, 默认165
+
+	int										m_third_floor_parkspace_id_min;		//3楼车位id最小值, 默认19
+	int										m_third_floor_parkspace_id_max;		//3楼车位id最小值, 默认27
+	int										m_third_floor_parkspace_id_total;	//3楼车位id总数, 默认9
 
 	int										m_car_wheel_base_min;			//汽车轮距最小值, 默认1000
 	int										m_car_wheel_base_max;			//汽车轮距最大值, 默认4000

dispatch/dispatch_device_base.cpp

@@ -335,7 +335,7 @@ Error_manager Dispatch_device_base::cancel_task(std::shared_ptr<Task_Base> p_tas
 //判断是否为待机，如果已经准备好，则可以执行任务。
 bool Dispatch_device_base::is_ready()
 {
-	std::unique_lock<std::mutex> t_lock(m_lock);
+//	std::unique_lock<std::mutex> t_lock(m_lock);
 	if ( m_dispatch_device_status == DISPATCH_DEVICE_READY &&
 		 m_device_one_level_command_key == "" &&
 		 m_device_two_level_command_key == "" &&
@@ -352,7 +352,9 @@ bool Dispatch_device_base::is_ready()
 bool Dispatch_device_base::is_able_excute_store()
 {
 	std::unique_lock<std::mutex> t_lock(m_lock);
-	if ( m_device_one_level_command_key == "" )
+	if ( m_device_one_level_command_key == "" &&
+		 m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_OVER &&
+		 m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_WORK)
 	{
 		if ( m_dispatch_device_status == DISPATCH_DEVICE_READY ||
 			 m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_OVER ||
@@ -387,7 +389,9 @@ bool Dispatch_device_base::is_able_excute_store()
 bool Dispatch_device_base::is_able_excute_pickup()
 {
 	std::unique_lock<std::mutex> t_lock(m_lock);
-	if ( m_device_one_level_command_key == "" )
+	if ( m_device_one_level_command_key == "" &&
+		 m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_OVER &&
+		 m_dispatch_device_status != DISPATCH_DEVICE_ONE_LEVEL_WORK)
 	{
 		if ( m_dispatch_device_status == DISPATCH_DEVICE_READY ||
 			 m_dispatch_device_status == DISPATCH_DEVICE_TWO_LEVEL_OVER ||
@@ -418,6 +422,40 @@ bool Dispatch_device_base::is_able_excute_pickup()
 	}
 }
 
+//预约任务
+Error_manager Dispatch_device_base::appoint_task(std::string command_key, Common_data::Dispatch_process_type process_type, Dispatch_task_level dispatch_task_level)
+{
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	switch ( dispatch_task_level )
+	{
+		case DISPATCH_TASK_ONE_LEVEL:
+		{
+			m_device_one_level_command_key = command_key;
+			m_device_one_level_process_type = process_type;
+			break;
+		}
+		case DISPATCH_TASK_TWO_LEVEL:
+		{
+			m_device_two_level_command_key = command_key;
+			m_device_two_level_process_type = process_type;
+			break;
+		}
+		case DISPATCH_TASK_THREE_LEVEL:
+		{
+			m_device_three_level_command_key = command_key;
+			m_device_three_level_process_type = process_type;
+			break;
+		}
+		default:
+		{
+			return Error_manager(Error_code::PARAMETER_ERROR, Error_level::MINOR_ERROR,
+								 "  Dispatch_device_base::appoint_task PARAMETER_ERROR ");
+			break;
+		}
+	}
+	return Error_code::SUCCESS;
+}
+
 
 Dispatch_device_base::Dispatch_device_status Dispatch_device_base::get_dispatch_device_status()
 {

dispatch/dispatch_device_base.h

@@ -203,6 +203,8 @@ public://API functions
 	//判断是否可以执行取车任务。
 	virtual bool is_able_excute_pickup();
 
+	//预约任务
+	virtual Error_manager appoint_task(std::string command_key, Common_data::Dispatch_process_type process_type, Dispatch_task_level dispatch_task_level);
 public://get or set member variable
 	Dispatch_device_status get_dispatch_device_status();
 	//获取硬件设备的状态, 必须子类继承

dispatch/dispatch_manager.cpp

@@ -282,7 +282,7 @@ Error_manager Dispatch_manager::execute_for_dispatch_request_msg(message::Dispat
 		std::unique_lock<std::mutex> t_lock(m_lock);
 		//流程缓存到map
 		if (tp_dispatch_process->m_dispatch_process_type ==
-		Common_data::Dispatch_process_type::DISPATCH_PROCESS_STORE)
+			Common_data::Dispatch_process_type::DISPATCH_PROCESS_STORE)
 		{
 			m_process_store_list.push_back(tp_dispatch_process);
 			//这里就不查重了, 需要主控保证不会重复发送...
@@ -299,7 +299,7 @@ Error_manager Dispatch_manager::execute_for_dispatch_request_msg(message::Dispat
 //			}
 		}
 		else if (tp_dispatch_process->m_dispatch_process_type ==
-		Common_data::Dispatch_process_type::DISPATCH_PROCESS_PICKUP)
+				 Common_data::Dispatch_process_type::DISPATCH_PROCESS_PICKUP)
 		{
 			m_process_pickup_list.push_back(tp_dispatch_process);
 			//这里就不查重了, 需要主控保证不会重复发送...
@@ -649,6 +649,13 @@ void Dispatch_manager::resource_allocation()
 {
 	LOG(INFO) << " Dispatch_manager::resource_allocation() start " << this;
 	Error_manager t_error;
+	//分配资源的标记位, 保证每次大循环,只分配一个资源
+	//流程和搬运器 匹配上了, 就直接把t_allocation_flag改为true, 然后重新开始线程循环.
+	bool t_allocation_flag = false;
+
+	Carrier* tp_carrier_left = (Carrier*)m_carrier_map[0].get();
+	Carrier* tp_carrier_right = (Carrier*)m_carrier_map[1].get();
+	Carrier* tp_carrier_3rd = (Carrier*)m_carrier_map[2].get();
 
 	while (m_dispatch_manager_condition.is_alive())
 	{
@@ -660,21 +667,373 @@ void Dispatch_manager::resource_allocation()
 //			std::this_thread::sleep_for(std::chrono::seconds(1));
 			std::this_thread::yield();
 			std::unique_lock<std::mutex> t_lock(m_lock);
+			t_allocation_flag = false;
 
 			//本线程函数只负责分配搬运器的资源 给对应的流程
 			//然后拥有搬运器资源的流程, 自己去抢机器人的资源.
 			//注意了: 搬运器有3个, 需要合理安排路线, 尽量保证搬运器以存取存取的顺序执行任务, 搬运器最好不要空载运行.
 			//注意了: 机器人只有1个, 是调度系统最紧缺的资源, 尽量保证机器人无间断一直运行, 使效率最大化.
-
-
-			//优先做取车
-			for (auto iter = m_process_pickup_list.begin(); iter != m_process_pickup_list.end(); ++iter)
+			bool t_carrier_left_is_ready = m_carrier_map[0]->is_ready();
+			bool t_carrier_left_is_store = m_carrier_map[0]->is_able_excute_store();
+			bool t_carrier_left_is_pickup = m_carrier_map[0]->is_able_excute_pickup();
+			bool t_carrier_right_is_ready = m_carrier_map[1]->is_ready();
+			bool t_carrier_right_is_store = m_carrier_map[1]->is_able_excute_store();
+			bool t_carrier_right_is_pickup = m_carrier_map[1]->is_able_excute_pickup();
+			bool t_carrier_3rd_is_ready = m_carrier_map[2]->is_ready();
+			bool t_carrier_3rd_is_store = m_carrier_map[2]->is_able_excute_store();
+			bool t_carrier_3rd_is_pickup = m_carrier_map[2]->is_able_excute_pickup();
+
+			//判断是否 有搬运器空闲
+			if ( t_carrier_left_is_ready || t_carrier_right_is_ready || t_carrier_3rd_is_ready)
 			{
-
+				if ( !t_allocation_flag )
+				{
+					//优先做取车
+					for (auto iter = m_process_pickup_list.begin(); iter != m_process_pickup_list.end(); ++iter)
+					{
+						//判断是否有取车任务可以开始执行
+						if ( (*iter)->is_ready() )
+						{
+							//注意了:获取 取车的路线, 停车位作为唯一起点, 由坐标模块判断可行的路径
+							Dispatch_coordinates::Parkspace_path t_parkspace_path = Dispatch_coordinates::get_instance_references().get_pickup_path((*iter)->m_dispatch_source, (*iter)->m_dispatch_destination);
+							//分配合理的版搬运器
+							if ( t_carrier_left_is_ready && t_carrier_right_is_ready && t_parkspace_path == Dispatch_coordinates::Parkspace_path::DOUBLE_PATH)
+							{
+								//选最近的搬运器
+								if ( Dispatch_coordinates::get_instance_references().choice_nearest_carrier((*iter)->m_dispatch_source, tp_carrier_left->m_actual_coordinates_id, tp_carrier_right->m_actual_coordinates_id) )
+								{
+									m_carrier_map[0]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[0]);
+									t_allocation_flag = true;
+									break;
+								}
+								else
+								{
+									m_carrier_map[1]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[1]);
+									t_allocation_flag = true;
+									break;
+								}
+							}
+							else if ( t_carrier_left_is_ready &&
+									  (t_parkspace_path == Dispatch_coordinates::Parkspace_path::LEFT_PATH || t_parkspace_path == Dispatch_coordinates::Parkspace_path::DOUBLE_PATH) )
+							{
+								m_carrier_map[0]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+								(*iter)->set_main_carrier(m_carrier_map[0]);
+								t_allocation_flag = true;
+								break;
+							}
+							else if ( t_carrier_right_is_ready &&
+									  (t_parkspace_path == Dispatch_coordinates::Parkspace_path::RIGHT_PATH || t_parkspace_path == Dispatch_coordinates::Parkspace_path::DOUBLE_PATH) )
+							{
+								m_carrier_map[1]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+								(*iter)->set_main_carrier(m_carrier_map[1]);
+								t_allocation_flag = true;
+								break;
+							}
+							else if ( t_carrier_3rd_is_ready && t_parkspace_path == Dispatch_coordinates::Parkspace_path::THIRD_FLOOR_PATH)
+							{
+								m_carrier_map[2]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+								(*iter)->set_main_carrier(m_carrier_map[2]);
+								t_allocation_flag = true;
+								break;
+							}
+							else
+							{
+								//流程和搬运器没有匹配上, 就直接找下一个流程
+								continue;
+							}
+						}
+					}
+				}
+				if ( !t_allocation_flag )
+				{
+					//然后做存车
+					for (auto iter = m_process_store_list.begin(); iter != m_process_store_list.end(); ++iter)
+					{
+						//判断是否有取车任务可以开始执行
+						if ( (*iter)->is_ready() )
+						{
+							//注意了: 存车的路径由车位数据库模块来制定.
+							bool is_left_path = (*iter)->is_able_store_left_path();
+							bool is_right_path = (*iter)->is_able_store_right_path();
+							bool is_temporary_path = (*iter)->is_able_store_temporary_cache_path();
+							bool is_2nd_path = (*iter)->is_able_store_temporary_cache_path_2nd_floor();
+							bool is_3rd_path = (*iter)->is_able_store_temporary_cache_path_3rd_floor();
+
+							//如果只能存到缓存位, 那么也要执行, 修改标志位
+							if ( (!is_left_path) && (!is_right_path) && is_temporary_path)
+							{
+								(*iter)->m_temporary_cache_flag = true;
+							}
+							else
+							{
+								(*iter)->m_temporary_cache_flag = false;
+							}
+
+							//分配合理的版搬运器
+							if ( t_carrier_left_is_ready && t_carrier_right_is_ready)
+							{
+								if ( (is_left_path && is_right_path) ||
+									 ( (!is_left_path) && (!is_right_path) && is_2nd_path) )//如果只能存到2楼, 那么也要执行
+								{
+									//选最近的搬运器
+									if ( Dispatch_coordinates::get_instance_references().choice_nearest_carrier(
+									(*iter)->m_dispatch_source, tp_carrier_left->m_actual_coordinates_id,
+									tp_carrier_right->m_actual_coordinates_id) )
+									{
+										m_carrier_map[0]->appoint_task((*iter)->m_command_key,
+																	   (*iter)->m_dispatch_process_type,
+																	   Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+										(*iter)->set_main_carrier(m_carrier_map[0]);
+										t_allocation_flag = true;
+										break;
+									}
+									else
+									{
+										m_carrier_map[1]->appoint_task((*iter)->m_command_key,
+																	   (*iter)->m_dispatch_process_type,
+																	   Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+										(*iter)->set_main_carrier(m_carrier_map[1]);
+										t_allocation_flag = true;
+										break;
+									}
+								}
+							}
+							else if ( t_carrier_left_is_ready )
+							{
+								if ( is_left_path ||
+									 ( (!is_left_path) && (!is_right_path) && is_2nd_path) )//如果只能存到2楼, 那么也要执行
+								{
+									m_carrier_map[0]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[0]);
+									t_allocation_flag = true;
+									break;
+								}
+							}
+							else if ( t_carrier_right_is_ready )
+							{
+								if ( is_right_path ||
+									 ( (!is_left_path) && (!is_right_path) && is_2nd_path) )//如果只能存到2楼, 那么也要执行
+								{
+									m_carrier_map[1]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[1]);
+									t_allocation_flag = true;
+									break;
+								}
+							}
+							else if ( t_carrier_3rd_is_ready)
+							{
+								if ( (!is_left_path) && (!is_right_path) && is_3rd_path)
+								{
+									m_carrier_map[2]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[2]);
+									t_allocation_flag = true;
+									break;
+								}
+							}
+							else
+							{
+								continue;
+							}
+						}
+					}
+				}
 			}
 
+			//判断是否 有搬运器可以预约取车
+			if ( t_carrier_left_is_pickup || t_carrier_right_is_pickup || t_carrier_3rd_is_pickup)
+			{
+				if ( !t_allocation_flag )
+				{
+					//优先做取车
+					for (auto iter = m_process_pickup_list.begin(); iter != m_process_pickup_list.end(); ++iter)
+					{
+						//判断是否有取车任务可以开始执行
+						if ( (*iter)->is_ready() )
+						{
+							//注意了:获取 取车的路线, 停车位作为唯一起点, 由坐标模块判断可行的路径
+							Dispatch_coordinates::Parkspace_path t_parkspace_path = Dispatch_coordinates::get_instance_references().get_pickup_path((*iter)->m_dispatch_source, (*iter)->m_dispatch_destination);
+							//分配合理的版搬运器
+							if ( t_carrier_left_is_pickup && t_carrier_right_is_pickup && t_parkspace_path == Dispatch_coordinates::Parkspace_path::DOUBLE_PATH)
+							{
+								//注意了:这里需要根据3级存车任务来 选择一级取车任务
+								//对比2个搬运器的3级存车任务的状态, 来选择合适的搬运器, 后续可能会改道
+								if ( tp_carrier_left->m_redirect_flag && tp_carrier_right->m_redirect_flag &&
+									 (*iter)->m_car_type >= tp_carrier_left->m_redirect_store_car_type &&
+									 (*iter)->m_car_type >= tp_carrier_right->m_redirect_store_car_type)
+								{
+									//选最近的搬运器
+									if ( Dispatch_coordinates::get_instance_references().choice_nearest_carrier((*iter)->m_dispatch_source, tp_carrier_left->m_actual_coordinates_id, tp_carrier_right->m_actual_coordinates_id) )
+									{
+										m_carrier_map[0]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+										(*iter)->set_main_carrier(m_carrier_map[0]);
+										t_allocation_flag = true;
+										break;
+									}
+									else
+									{
+										m_carrier_map[1]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+										(*iter)->set_main_carrier(m_carrier_map[1]);
+										t_allocation_flag = true;
+										break;
+									}
+								}
+								else if ( tp_carrier_left->m_redirect_flag &&
+										  (*iter)->m_car_type >= tp_carrier_left->m_redirect_store_car_type )
+								{
+									m_carrier_map[0]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[0]);
+									t_allocation_flag = true;
+									break;
+								}
+								else //只要左库不能改道, 那么就把任务分给右库, 因为右库多一个7号出口.
+								{
+									m_carrier_map[1]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[1]);
+									t_allocation_flag = true;
+									break;
+								}
+
+							}
+							else if ( t_carrier_left_is_ready &&
+									  (t_parkspace_path == Dispatch_coordinates::Parkspace_path::LEFT_PATH || t_parkspace_path == Dispatch_coordinates::Parkspace_path::DOUBLE_PATH) )
+							{
+								m_carrier_map[0]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+								(*iter)->set_main_carrier(m_carrier_map[0]);
+								t_allocation_flag = true;
+								break;
+							}
+							else if ( t_carrier_right_is_ready &&
+									  (t_parkspace_path == Dispatch_coordinates::Parkspace_path::RIGHT_PATH || t_parkspace_path == Dispatch_coordinates::Parkspace_path::DOUBLE_PATH) )
+							{
+								m_carrier_map[1]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+								(*iter)->set_main_carrier(m_carrier_map[1]);
+								t_allocation_flag = true;
+								break;
+							}
+							else if ( t_carrier_3rd_is_ready && t_parkspace_path == Dispatch_coordinates::Parkspace_path::THIRD_FLOOR_PATH)
+							{
+								m_carrier_map[2]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+								(*iter)->set_main_carrier(m_carrier_map[2]);
+								t_allocation_flag = true;
+								break;
+							}
+							else
+							{
+								//流程和搬运器没有匹配上, 就直接找下一个流程
+								continue;
+							}
+						}
+					}
+				}
+			}
 
-
+			//判断是否 有搬运器可以预约取车
+			if ( t_carrier_left_is_store || t_carrier_right_is_store || t_carrier_3rd_is_store)
+			{
+				if ( !t_allocation_flag )
+				{
+					//然后做存车
+					for (auto iter = m_process_store_list.begin(); iter != m_process_store_list.end(); ++iter)
+					{
+						//判断是否有取车任务可以开始执行
+						if ( (*iter)->is_ready() )
+						{
+							//注意了: 存车的路径由车位数据库模块来制定.
+							bool is_left_path = (*iter)->is_able_store_left_path();
+							bool is_right_path = (*iter)->is_able_store_right_path();
+							bool is_temporary_path = (*iter)->is_able_store_temporary_cache_path();
+							bool is_2nd_path = (*iter)->is_able_store_temporary_cache_path_2nd_floor();
+							bool is_3rd_path = (*iter)->is_able_store_temporary_cache_path_3rd_floor();
+
+							//如果只能存到缓存位, 或者存车流程数量超限, 修改标志位
+							if ( ( (!is_left_path) && (!is_right_path) && is_temporary_path) ||
+								 (m_process_store_list.size() >= DISPATCH_MANAHER_STORE_LIST_SIZE_LIMIT && is_temporary_path) )
+							{
+								(*iter)->m_temporary_cache_flag = true;
+							}
+							else
+							{
+								(*iter)->m_temporary_cache_flag = false;
+							}
+							//分配合理的版搬运器
+							if ( t_carrier_left_is_ready && t_carrier_right_is_ready)
+							{
+								if ( (is_left_path && is_right_path) ||
+									 ( (!is_left_path) && (!is_right_path) && is_2nd_path) || //如果只能存到2楼, 那么也要执行
+									 (m_process_store_list.size() >= DISPATCH_MANAHER_STORE_LIST_SIZE_LIMIT && is_2nd_path) )	//存车流程数量超限
+								{
+									//选最近的搬运器
+									if ( Dispatch_coordinates::get_instance_references().choice_nearest_carrier(
+									(*iter)->m_dispatch_source, tp_carrier_left->m_actual_coordinates_id,
+									tp_carrier_right->m_actual_coordinates_id) )
+									{
+										m_carrier_map[0]->appoint_task((*iter)->m_command_key,
+																	   (*iter)->m_dispatch_process_type,
+																	   Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+										(*iter)->set_main_carrier(m_carrier_map[0]);
+										t_allocation_flag = true;
+										break;
+									}
+									else
+									{
+										m_carrier_map[1]->appoint_task((*iter)->m_command_key,
+																	   (*iter)->m_dispatch_process_type,
+																	   Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+										(*iter)->set_main_carrier(m_carrier_map[1]);
+										t_allocation_flag = true;
+										break;
+									}
+								}
+								else if (m_process_store_list.size() >= DISPATCH_MANAHER_STORE_LIST_SIZE_LIMIT && is_2nd_path)
+								{
+
+								}
+							}
+							else if ( t_carrier_left_is_ready )
+							{
+								if ( is_left_path ||
+									 ( (!is_left_path) && (!is_right_path) && is_2nd_path) || //如果只能存到2楼, 那么也要执行
+									 (m_process_store_list.size() >= DISPATCH_MANAHER_STORE_LIST_SIZE_LIMIT && is_2nd_path) )	//存车流程数量超限
+								{
+									m_carrier_map[0]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[0]);
+									t_allocation_flag = true;
+									break;
+								}
+							}
+							else if ( t_carrier_right_is_ready )
+							{
+								if ( is_right_path ||
+									 ( (!is_left_path) && (!is_right_path) && is_2nd_path) || //如果只能存到2楼, 那么也要执行
+									 (m_process_store_list.size() >= DISPATCH_MANAHER_STORE_LIST_SIZE_LIMIT && is_2nd_path) )	//存车流程数量超限
+								{
+									m_carrier_map[1]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[1]);
+									t_allocation_flag = true;
+									break;
+								}
+							}
+							else if ( t_carrier_3rd_is_ready)
+							{
+								if ( ( (!is_left_path) && (!is_right_path) && is_3rd_path) || //如果只能存到2楼, 那么也要执行
+								(m_process_store_list.size() >= DISPATCH_MANAHER_STORE_LIST_SIZE_LIMIT && is_3rd_path) )	//存车流程数量超限
+								{
+									m_carrier_map[2]->appoint_task((*iter)->m_command_key, (*iter)->m_dispatch_process_type, Dispatch_device_base::Dispatch_task_level::DISPATCH_TASK_ONE_LEVEL);
+									(*iter)->set_main_carrier(m_carrier_map[2]);
+									t_allocation_flag = true;
+									break;
+								}
+							}
+							else
+							{
+								continue;
+							}
+						}
+					}
+				}
+			}
 		}
 	}
 

dispatch/dispatch_manager.h

@@ -23,7 +23,7 @@
 
 #include <vector>
 #include <glog/logging.h>
-
+#include <atomic>
 
 
 //lacate测量结果结构体, 整车的信息,
@@ -50,6 +50,8 @@ class Dispatch_manager:public Singleton<Dispatch_manager>
 public:
 //调度设备参数
 #define DISPATCH_DEVICE_PARAMETER_PATH "../setting/dispatch_device.prototxt"
+//存车任务数量的限制, 大于等于限则, 则使用缓存位, 默认5个
+#define DISPATCH_MANAHER_STORE_LIST_SIZE_LIMIT		5
 
 
 	//调度管理 的状态

dispatch/dispatch_parameter.pb.cc

@@ -521,9 +521,11 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Parkspace_number, rows_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Parkspace_number, columns_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Parkspace_number, total_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Parkspace_number, liftway_width_),
   0,
   1,
   2,
+  3,
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, _has_bits_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, _internal_metadata_),
   ~0u,  // no _extensions_
@@ -566,6 +568,9 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, parkspace_id_min_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, parkspace_id_max_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, parkspace_id_total_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, third_floor_parkspace_id_min_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, third_floor_parkspace_id_max_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, third_floor_parkspace_id_total_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, car_wheel_base_min_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, car_wheel_base_max_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::Dispatch_proto::Dispatch_coordinates_parameter_all, parkspace_number_),
@@ -608,6 +613,9 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
   32,
   33,
   34,
+  35,
+  36,
+  37,
   2,
 };
 static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
@@ -622,8 +630,8 @@ static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROT
   { 96, 107, sizeof(::Dispatch_proto::Carrier_box_parameter)},
   { 113, 124, sizeof(::Dispatch_proto::Catcher_box_parameter)},
   { 130, 137, sizeof(::Dispatch_proto::Axis_range_parameter)},
-  { 139, 147, sizeof(::Dispatch_proto::Parkspace_number)},
-  { 150, 195, sizeof(::Dispatch_proto::Dispatch_coordinates_parameter_all)},
+  { 139, 148, sizeof(::Dispatch_proto::Parkspace_number)},
+  { 152, 200, sizeof(::Dispatch_proto::Dispatch_coordinates_parameter_all)},
 };
 
 static ::google::protobuf::Message const * const file_default_instances[] = {
@@ -695,58 +703,61 @@ void AddDescriptorsImpl() {
       "\026\n\005y_max\030\004 \001(\005:\0071000000\022\027\n\005z_min\030\005 \001(\005:\010"
       "-1000000\022\026\n\005z_max\030\006 \001(\005:\0071000000\"C\n\024Axis"
       "_range_parameter\022\025\n\003min\030\001 \001(\005:\010-1000000\022"
-      "\024\n\003max\030\002 \001(\005:\0071000000\"@\n\020Parkspace_numbe"
+      "\024\n\003max\030\002 \001(\005:\0071000000\"W\n\020Parkspace_numbe"
       "r\022\014\n\004rows\030\001 \002(\005\022\017\n\007columns\030\002 \002(\005\022\r\n\005tota"
-      "l\030\003 \002(\005\"\330\014\n\"Dispatch_coordinates_paramet"
-      "er_all\022Y\n packspace_coordinates_paramete"
-      "rs\030\001 \003(\0132/.Dispatch_proto.Packspace_coor"
-      "dinates_parameter\022[\n!passageway_coordina"
-      "tes_parameters\030\002 \003(\01320.Dispatch_proto.Pa"
-      "ssageway_coordinates_parameter\022U\n\036carrie"
-      "r_coordinates_parameters\030\003 \003(\0132-.Dispatc"
-      "h_proto.Carrier_coordinates_parameter\022U\n"
-      "\036catcher_coordinates_parameters\030\004 \003(\0132-."
-      "Dispatch_proto.Catcher_coordinates_param"
-      "eter\022E\n\026carrier_box_parameters\030\005 \001(\0132%.D"
-      "ispatch_proto.Carrier_box_parameter\022E\n\026c"
-      "atcher_box_parameters\030\006 \001(\0132%.Dispatch_p"
-      "roto.Catcher_box_parameter\022\025\n\rcatcher_b_"
-      "min\030\007 \001(\005\022\025\n\rcatcher_b_max\030\010 \001(\005\022\026\n\016catc"
-      "her_d1_min\030\t \001(\005\022\026\n\016catcher_d1_max\030\n \001(\005"
-      "\022\026\n\016catcher_d2_min\030\013 \001(\005\022\026\n\016catcher_d2_m"
-      "ax\030\014 \001(\005\022\031\n\021default_wheelbase\030\r \001(\005\022\033\n\023c"
-      "atcher_1th_floor_z\030\016 \001(\005\022\033\n\023catcher_2th_"
-      "floor_z\030\017 \001(\005\022\033\n\023catcher_3th_floor_z\030\020 \001"
-      "(\005\022\033\n\023catcher_4th_floor_z\030\021 \001(\005\022\033\n\023carri"
-      "er_1th_floor_z\030\022 \001(\005\022\033\n\023carrier_2th_floo"
-      "r_z\030\023 \001(\005\022\033\n\023carrier_3th_floor_z\030\024 \001(\005\022\033"
-      "\n\023carrier_4th_floor_z\030\025 \001(\005\022\036\n\026catcher_d"
-      "1_d2_distance\030\026 \001(\005\022 \n\030catcher_wheel_bas"
-      "e_limit\030\027 \001(\005\022\035\n\025carrier_y_y1_distance\030\030"
-      " \001(\005\022\037\n\027carrier_default_y1_back\030\031 \001(\005\022 \n"
-      "\030carrier_default_y1_leave\030\032 \001(\005\022\036\n\026carri"
-      "er_default_y_back\030\033 \001(\005\022\037\n\027carrier_defau"
-      "lt_y_leave\030\034 \001(\005\022\036\n\026carrier_default_x_le"
-      "ft\030\035 \001(\005\022\037\n\027carrier_default_x_right\030\036 \001("
-      "\005\022\"\n\032passageway_terminal_id_min\030\037 \001(\005\022\"\n"
-      "\032passageway_terminal_id_max\030  \001(\005\022\"\n\032pas"
-      "sageway_terminal_number\030! \001(\005\022W\n\037passage"
-      "way_functioning_patterns\030\" \003(\0162..Dispatc"
-      "h_proto.Passageway_functioning_pattern\022\030"
-      "\n\020parkspace_id_min\030# \001(\005\022\030\n\020parkspace_id"
-      "_max\030$ \001(\005\022\032\n\022parkspace_id_total\030% \001(\005\022\032"
-      "\n\022car_wheel_base_min\030& \001(\005\022\032\n\022car_wheel_"
-      "base_max\030\' \001(\005\022:\n\020parkspace_number\030( \002(\013"
-      "2 .Dispatch_proto.Parkspace_number*\321\001\n\036P"
-      "assageway_functioning_pattern\022*\n&PASSAGE"
-      "WAY_FUNCTIONING_PATTERN_UNKNOWN\020\000\022(\n$PAS"
-      "SAGEWAY_FUNCTIONING_PATTERN_INLET\020\001\022)\n%P"
-      "ASSAGEWAY_FUNCTIONING_PATTERN_OUTLET\020\002\022."
-      "\n*PASSAGEWAY_FUNCTIONING_PATTERN_BIDIREC"
-      "TION\020\003"
+      "l\030\003 \002(\005\022\025\n\rliftway_width\030\004 \002(\005\"\314\r\n\"Dispa"
+      "tch_coordinates_parameter_all\022Y\n packspa"
+      "ce_coordinates_parameters\030\001 \003(\0132/.Dispat"
+      "ch_proto.Packspace_coordinates_parameter"
+      "\022[\n!passageway_coordinates_parameters\030\002 "
+      "\003(\01320.Dispatch_proto.Passageway_coordina"
+      "tes_parameter\022U\n\036carrier_coordinates_par"
+      "ameters\030\003 \003(\0132-.Dispatch_proto.Carrier_c"
+      "oordinates_parameter\022U\n\036catcher_coordina"
+      "tes_parameters\030\004 \003(\0132-.Dispatch_proto.Ca"
+      "tcher_coordinates_parameter\022E\n\026carrier_b"
+      "ox_parameters\030\005 \001(\0132%.Dispatch_proto.Car"
+      "rier_box_parameter\022E\n\026catcher_box_parame"
+      "ters\030\006 \001(\0132%.Dispatch_proto.Catcher_box_"
+      "parameter\022\025\n\rcatcher_b_min\030\007 \001(\005\022\025\n\rcatc"
+      "her_b_max\030\010 \001(\005\022\026\n\016catcher_d1_min\030\t \001(\005\022"
+      "\026\n\016catcher_d1_max\030\n \001(\005\022\026\n\016catcher_d2_mi"
+      "n\030\013 \001(\005\022\026\n\016catcher_d2_max\030\014 \001(\005\022\031\n\021defau"
+      "lt_wheelbase\030\r \001(\005\022\033\n\023catcher_1th_floor_"
+      "z\030\016 \001(\005\022\033\n\023catcher_2th_floor_z\030\017 \001(\005\022\033\n\023"
+      "catcher_3th_floor_z\030\020 \001(\005\022\033\n\023catcher_4th"
+      "_floor_z\030\021 \001(\005\022\033\n\023carrier_1th_floor_z\030\022 "
+      "\001(\005\022\033\n\023carrier_2th_floor_z\030\023 \001(\005\022\033\n\023carr"
+      "ier_3th_floor_z\030\024 \001(\005\022\033\n\023carrier_4th_flo"
+      "or_z\030\025 \001(\005\022\036\n\026catcher_d1_d2_distance\030\026 \001"
+      "(\005\022 \n\030catcher_wheel_base_limit\030\027 \001(\005\022\035\n\025"
+      "carrier_y_y1_distance\030\030 \001(\005\022\037\n\027carrier_d"
+      "efault_y1_back\030\031 \001(\005\022 \n\030carrier_default_"
+      "y1_leave\030\032 \001(\005\022\036\n\026carrier_default_y_back"
+      "\030\033 \001(\005\022\037\n\027carrier_default_y_leave\030\034 \001(\005\022"
+      "\036\n\026carrier_default_x_left\030\035 \001(\005\022\037\n\027carri"
+      "er_default_x_right\030\036 \001(\005\022\"\n\032passageway_t"
+      "erminal_id_min\030\037 \001(\005\022\"\n\032passageway_termi"
+      "nal_id_max\030  \001(\005\022\"\n\032passageway_terminal_"
+      "number\030! \001(\005\022W\n\037passageway_functioning_p"
+      "atterns\030\" \003(\0162..Dispatch_proto.Passagewa"
+      "y_functioning_pattern\022\030\n\020parkspace_id_mi"
+      "n\030# \001(\005\022\030\n\020parkspace_id_max\030$ \001(\005\022\032\n\022par"
+      "kspace_id_total\030% \001(\005\022$\n\034third_floor_par"
+      "kspace_id_min\030& \001(\005\022$\n\034third_floor_parks"
+      "pace_id_max\030\' \001(\005\022&\n\036third_floor_parkspa"
+      "ce_id_total\030( \001(\005\022\032\n\022car_wheel_base_min\030"
+      ") \001(\005\022\032\n\022car_wheel_base_max\030* \001(\005\022:\n\020par"
+      "kspace_number\030+ \002(\0132 .Dispatch_proto.Par"
+      "kspace_number*\321\001\n\036Passageway_functioning"
+      "_pattern\022*\n&PASSAGEWAY_FUNCTIONING_PATTE"
+      "RN_UNKNOWN\020\000\022(\n$PASSAGEWAY_FUNCTIONING_P"
+      "ATTERN_INLET\020\001\022)\n%PASSAGEWAY_FUNCTIONING"
+      "_PATTERN_OUTLET\020\002\022.\n*PASSAGEWAY_FUNCTION"
+      "ING_PATTERN_BIDIRECTION\020\003"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 3166);
+      descriptor, 3305);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "dispatch_parameter.proto", &protobuf_RegisterTypes);
 }
@@ -4854,6 +4865,7 @@ void Parkspace_number::InitAsDefaultInstance() {
 const int Parkspace_number::kRowsFieldNumber;
 const int Parkspace_number::kColumnsFieldNumber;
 const int Parkspace_number::kTotalFieldNumber;
+const int Parkspace_number::kLiftwayWidthFieldNumber;
 #endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
 
 Parkspace_number::Parkspace_number()
@@ -4871,16 +4883,16 @@ Parkspace_number::Parkspace_number(const Parkspace_number& from)
       _cached_size_(0) {
   _internal_metadata_.MergeFrom(from._internal_metadata_);
   ::memcpy(&rows_, &from.rows_,
-    static_cast<size_t>(reinterpret_cast<char*>(&total_) -
-    reinterpret_cast<char*>(&rows_)) + sizeof(total_));
+    static_cast<size_t>(reinterpret_cast<char*>(&liftway_width_) -
+    reinterpret_cast<char*>(&rows_)) + sizeof(liftway_width_));
   // @@protoc_insertion_point(copy_constructor:Dispatch_proto.Parkspace_number)
 }
 
 void Parkspace_number::SharedCtor() {
   _cached_size_ = 0;
   ::memset(&rows_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&total_) -
-      reinterpret_cast<char*>(&rows_)) + sizeof(total_));
+      reinterpret_cast<char*>(&liftway_width_) -
+      reinterpret_cast<char*>(&rows_)) + sizeof(liftway_width_));
 }
 
 Parkspace_number::~Parkspace_number() {
@@ -4921,10 +4933,10 @@ void Parkspace_number::Clear() {
   (void) cached_has_bits;
 
   cached_has_bits = _has_bits_[0];
-  if (cached_has_bits & 7u) {
+  if (cached_has_bits & 15u) {
     ::memset(&rows_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&total_) -
-        reinterpret_cast<char*>(&rows_)) + sizeof(total_));
+        reinterpret_cast<char*>(&liftway_width_) -
+        reinterpret_cast<char*>(&rows_)) + sizeof(liftway_width_));
   }
   _has_bits_.Clear();
   _internal_metadata_.Clear();
@@ -4982,6 +4994,20 @@ bool Parkspace_number::MergePartialFromCodedStream(
         break;
       }
 
+      // required int32 liftway_width = 4;
+      case 4: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
+          set_has_liftway_width();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &liftway_width_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
       default: {
       handle_unusual:
         if (tag == 0) {
@@ -5024,6 +5050,11 @@ void Parkspace_number::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->total(), output);
   }
 
+  // required int32 liftway_width = 4;
+  if (cached_has_bits & 0x00000008u) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->liftway_width(), output);
+  }
+
   if (_internal_metadata_.have_unknown_fields()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         _internal_metadata_.unknown_fields(), output);
@@ -5054,6 +5085,11 @@ void Parkspace_number::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->total(), target);
   }
 
+  // required int32 liftway_width = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->liftway_width(), target);
+  }
+
   if (_internal_metadata_.have_unknown_fields()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields(), target);
@@ -5087,6 +5123,13 @@ size_t Parkspace_number::RequiredFieldsByteSizeFallback() const {
         this->total());
   }
 
+  if (has_liftway_width()) {
+    // required int32 liftway_width = 4;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->liftway_width());
+  }
+
   return total_size;
 }
 size_t Parkspace_number::ByteSizeLong() const {
@@ -5098,7 +5141,7 @@ size_t Parkspace_number::ByteSizeLong() const {
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
         _internal_metadata_.unknown_fields());
   }
-  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
+  if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) {  // All required fields are present.
     // required int32 rows = 1;
     total_size += 1 +
       ::google::protobuf::internal::WireFormatLite::Int32Size(
@@ -5114,6 +5157,11 @@ size_t Parkspace_number::ByteSizeLong() const {
       ::google::protobuf::internal::WireFormatLite::Int32Size(
         this->total());
 
+    // required int32 liftway_width = 4;
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::Int32Size(
+        this->liftway_width());
+
   } else {
     total_size += RequiredFieldsByteSizeFallback();
   }
@@ -5147,7 +5195,7 @@ void Parkspace_number::MergeFrom(const Parkspace_number& from) {
   (void) cached_has_bits;
 
   cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 7u) {
+  if (cached_has_bits & 15u) {
     if (cached_has_bits & 0x00000001u) {
       rows_ = from.rows_;
     }
@@ -5157,6 +5205,9 @@ void Parkspace_number::MergeFrom(const Parkspace_number& from) {
     if (cached_has_bits & 0x00000004u) {
       total_ = from.total_;
     }
+    if (cached_has_bits & 0x00000008u) {
+      liftway_width_ = from.liftway_width_;
+    }
     _has_bits_[0] |= cached_has_bits;
   }
 }
@@ -5176,7 +5227,7 @@ void Parkspace_number::CopyFrom(const Parkspace_number& from) {
 }
 
 bool Parkspace_number::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
   return true;
 }
 
@@ -5189,6 +5240,7 @@ void Parkspace_number::InternalSwap(Parkspace_number* other) {
   swap(rows_, other->rows_);
   swap(columns_, other->columns_);
   swap(total_, other->total_);
+  swap(liftway_width_, other->liftway_width_);
   swap(_has_bits_[0], other->_has_bits_[0]);
   _internal_metadata_.Swap(&other->_internal_metadata_);
   swap(_cached_size_, other->_cached_size_);
@@ -5248,6 +5300,9 @@ const int Dispatch_coordinates_parameter_all::kPassagewayFunctioningPatternsFiel
 const int Dispatch_coordinates_parameter_all::kParkspaceIdMinFieldNumber;
 const int Dispatch_coordinates_parameter_all::kParkspaceIdMaxFieldNumber;
 const int Dispatch_coordinates_parameter_all::kParkspaceIdTotalFieldNumber;
+const int Dispatch_coordinates_parameter_all::kThirdFloorParkspaceIdMinFieldNumber;
+const int Dispatch_coordinates_parameter_all::kThirdFloorParkspaceIdMaxFieldNumber;
+const int Dispatch_coordinates_parameter_all::kThirdFloorParkspaceIdTotalFieldNumber;
 const int Dispatch_coordinates_parameter_all::kCarWheelBaseMinFieldNumber;
 const int Dispatch_coordinates_parameter_all::kCarWheelBaseMaxFieldNumber;
 const int Dispatch_coordinates_parameter_all::kParkspaceNumberFieldNumber;
@@ -5381,7 +5436,7 @@ void Dispatch_coordinates_parameter_all::Clear() {
         reinterpret_cast<char*>(&carrier_default_y_leave_)) + sizeof(parkspace_id_max_));
   }
   cached_has_bits = _has_bits_[1];
-  if (cached_has_bits & 7u) {
+  if (cached_has_bits & 63u) {
     ::memset(&parkspace_id_total_, 0, static_cast<size_t>(
         reinterpret_cast<char*>(&car_wheel_base_max_) -
         reinterpret_cast<char*>(&parkspace_id_total_)) + sizeof(car_wheel_base_max_));
@@ -5917,24 +5972,66 @@ bool Dispatch_coordinates_parameter_all::MergePartialFromCodedStream(
         break;
       }
 
-      // optional int32 car_wheel_base_min = 38;
+      // optional int32 third_floor_parkspace_id_min = 38;
       case 38: {
         if (static_cast< ::google::protobuf::uint8>(tag) ==
             static_cast< ::google::protobuf::uint8>(48u /* 304 & 0xFF */)) {
-          set_has_car_wheel_base_min();
+          set_has_third_floor_parkspace_id_min();
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, &car_wheel_base_min_)));
+                 input, &third_floor_parkspace_id_min_)));
         } else {
           goto handle_unusual;
         }
         break;
       }
 
-      // optional int32 car_wheel_base_max = 39;
+      // optional int32 third_floor_parkspace_id_max = 39;
       case 39: {
         if (static_cast< ::google::protobuf::uint8>(tag) ==
             static_cast< ::google::protobuf::uint8>(56u /* 312 & 0xFF */)) {
+          set_has_third_floor_parkspace_id_max();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &third_floor_parkspace_id_max_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // optional int32 third_floor_parkspace_id_total = 40;
+      case 40: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(64u /* 320 & 0xFF */)) {
+          set_has_third_floor_parkspace_id_total();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &third_floor_parkspace_id_total_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // optional int32 car_wheel_base_min = 41;
+      case 41: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(72u /* 328 & 0xFF */)) {
+          set_has_car_wheel_base_min();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &car_wheel_base_min_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // optional int32 car_wheel_base_max = 42;
+      case 42: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(80u /* 336 & 0xFF */)) {
           set_has_car_wheel_base_max();
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
@@ -5945,10 +6042,10 @@ bool Dispatch_coordinates_parameter_all::MergePartialFromCodedStream(
         break;
       }
 
-      // required .Dispatch_proto.Parkspace_number parkspace_number = 40;
-      case 40: {
+      // required .Dispatch_proto.Parkspace_number parkspace_number = 43;
+      case 43: {
         if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(66u /* 322 & 0xFF */)) {
+            static_cast< ::google::protobuf::uint8>(90u /* 346 & 0xFF */)) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
                input, mutable_parkspace_number()));
         } else {
@@ -6181,21 +6278,36 @@ void Dispatch_coordinates_parameter_all::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(37, this->parkspace_id_total(), output);
   }
 
-  // optional int32 car_wheel_base_min = 38;
+  // optional int32 third_floor_parkspace_id_min = 38;
   if (cached_has_bits & 0x00000002u) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(38, this->car_wheel_base_min(), output);
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(38, this->third_floor_parkspace_id_min(), output);
   }
 
-  // optional int32 car_wheel_base_max = 39;
+  // optional int32 third_floor_parkspace_id_max = 39;
   if (cached_has_bits & 0x00000004u) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(39, this->car_wheel_base_max(), output);
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(39, this->third_floor_parkspace_id_max(), output);
+  }
+
+  // optional int32 third_floor_parkspace_id_total = 40;
+  if (cached_has_bits & 0x00000008u) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(40, this->third_floor_parkspace_id_total(), output);
+  }
+
+  // optional int32 car_wheel_base_min = 41;
+  if (cached_has_bits & 0x00000010u) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(41, this->car_wheel_base_min(), output);
+  }
+
+  // optional int32 car_wheel_base_max = 42;
+  if (cached_has_bits & 0x00000020u) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(42, this->car_wheel_base_max(), output);
   }
 
   cached_has_bits = _has_bits_[0];
-  // required .Dispatch_proto.Parkspace_number parkspace_number = 40;
+  // required .Dispatch_proto.Parkspace_number parkspace_number = 43;
   if (cached_has_bits & 0x00000004u) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      40, *this->parkspace_number_, output);
+      43, *this->parkspace_number_, output);
   }
 
   if (_internal_metadata_.have_unknown_fields()) {
@@ -6414,22 +6526,37 @@ void Dispatch_coordinates_parameter_all::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(37, this->parkspace_id_total(), target);
   }
 
-  // optional int32 car_wheel_base_min = 38;
+  // optional int32 third_floor_parkspace_id_min = 38;
   if (cached_has_bits & 0x00000002u) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(38, this->car_wheel_base_min(), target);
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(38, this->third_floor_parkspace_id_min(), target);
   }
 
-  // optional int32 car_wheel_base_max = 39;
+  // optional int32 third_floor_parkspace_id_max = 39;
   if (cached_has_bits & 0x00000004u) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(39, this->car_wheel_base_max(), target);
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(39, this->third_floor_parkspace_id_max(), target);
+  }
+
+  // optional int32 third_floor_parkspace_id_total = 40;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(40, this->third_floor_parkspace_id_total(), target);
+  }
+
+  // optional int32 car_wheel_base_min = 41;
+  if (cached_has_bits & 0x00000010u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(41, this->car_wheel_base_min(), target);
+  }
+
+  // optional int32 car_wheel_base_max = 42;
+  if (cached_has_bits & 0x00000020u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(42, this->car_wheel_base_max(), target);
   }
 
   cached_has_bits = _has_bits_[0];
-  // required .Dispatch_proto.Parkspace_number parkspace_number = 40;
+  // required .Dispatch_proto.Parkspace_number parkspace_number = 43;
   if (cached_has_bits & 0x00000004u) {
     target = ::google::protobuf::internal::WireFormatLite::
       InternalWriteMessageToArray(
-        40, *this->parkspace_number_, deterministic, target);
+        43, *this->parkspace_number_, deterministic, target);
   }
 
   if (_internal_metadata_.have_unknown_fields()) {
@@ -6449,7 +6576,7 @@ size_t Dispatch_coordinates_parameter_all::ByteSizeLong() const {
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
         _internal_metadata_.unknown_fields());
   }
-  // required .Dispatch_proto.Parkspace_number parkspace_number = 40;
+  // required .Dispatch_proto.Parkspace_number parkspace_number = 43;
   if (has_parkspace_number()) {
     total_size += 2 +
       ::google::protobuf::internal::WireFormatLite::MessageSize(
@@ -6736,7 +6863,7 @@ size_t Dispatch_coordinates_parameter_all::ByteSizeLong() const {
     }
 
   }
-  if (_has_bits_[32 / 32] & 7u) {
+  if (_has_bits_[32 / 32] & 63u) {
     // optional int32 parkspace_id_total = 37;
     if (has_parkspace_id_total()) {
       total_size += 2 +
@@ -6744,14 +6871,35 @@ size_t Dispatch_coordinates_parameter_all::ByteSizeLong() const {
           this->parkspace_id_total());
     }
 
-    // optional int32 car_wheel_base_min = 38;
+    // optional int32 third_floor_parkspace_id_min = 38;
+    if (has_third_floor_parkspace_id_min()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->third_floor_parkspace_id_min());
+    }
+
+    // optional int32 third_floor_parkspace_id_max = 39;
+    if (has_third_floor_parkspace_id_max()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->third_floor_parkspace_id_max());
+    }
+
+    // optional int32 third_floor_parkspace_id_total = 40;
+    if (has_third_floor_parkspace_id_total()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->third_floor_parkspace_id_total());
+    }
+
+    // optional int32 car_wheel_base_min = 41;
     if (has_car_wheel_base_min()) {
       total_size += 2 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
           this->car_wheel_base_min());
     }
 
-    // optional int32 car_wheel_base_max = 39;
+    // optional int32 car_wheel_base_max = 42;
     if (has_car_wheel_base_max()) {
       total_size += 2 +
         ::google::protobuf::internal::WireFormatLite::Int32Size(
@@ -6903,14 +7051,23 @@ void Dispatch_coordinates_parameter_all::MergeFrom(const Dispatch_coordinates_pa
     _has_bits_[0] |= cached_has_bits;
   }
   cached_has_bits = from._has_bits_[1];
-  if (cached_has_bits & 7u) {
+  if (cached_has_bits & 63u) {
     if (cached_has_bits & 0x00000001u) {
       parkspace_id_total_ = from.parkspace_id_total_;
     }
     if (cached_has_bits & 0x00000002u) {
-      car_wheel_base_min_ = from.car_wheel_base_min_;
+      third_floor_parkspace_id_min_ = from.third_floor_parkspace_id_min_;
     }
     if (cached_has_bits & 0x00000004u) {
+      third_floor_parkspace_id_max_ = from.third_floor_parkspace_id_max_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      third_floor_parkspace_id_total_ = from.third_floor_parkspace_id_total_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      car_wheel_base_min_ = from.car_wheel_base_min_;
+    }
+    if (cached_has_bits & 0x00000020u) {
       car_wheel_base_max_ = from.car_wheel_base_max_;
     }
     _has_bits_[1] |= cached_has_bits;
@@ -6983,6 +7140,9 @@ void Dispatch_coordinates_parameter_all::InternalSwap(Dispatch_coordinates_param
   swap(parkspace_id_min_, other->parkspace_id_min_);
   swap(parkspace_id_max_, other->parkspace_id_max_);
   swap(parkspace_id_total_, other->parkspace_id_total_);
+  swap(third_floor_parkspace_id_min_, other->third_floor_parkspace_id_min_);
+  swap(third_floor_parkspace_id_max_, other->third_floor_parkspace_id_max_);
+  swap(third_floor_parkspace_id_total_, other->third_floor_parkspace_id_total_);
   swap(car_wheel_base_min_, other->car_wheel_base_min_);
   swap(car_wheel_base_max_, other->car_wheel_base_max_);
   swap(_has_bits_[0], other->_has_bits_[0]);

dispatch/dispatch_parameter.pb.h

@@ -1802,6 +1802,13 @@ class Parkspace_number : public ::google::protobuf::Message /* @@protoc_insertio
   ::google::protobuf::int32 total() const;
   void set_total(::google::protobuf::int32 value);
 
+  // required int32 liftway_width = 4;
+  bool has_liftway_width() const;
+  void clear_liftway_width();
+  static const int kLiftwayWidthFieldNumber = 4;
+  ::google::protobuf::int32 liftway_width() const;
+  void set_liftway_width(::google::protobuf::int32 value);
+
   // @@protoc_insertion_point(class_scope:Dispatch_proto.Parkspace_number)
  private:
   void set_has_rows();
@@ -1810,6 +1817,8 @@ class Parkspace_number : public ::google::protobuf::Message /* @@protoc_insertio
   void clear_has_columns();
   void set_has_total();
   void clear_has_total();
+  void set_has_liftway_width();
+  void clear_has_liftway_width();
 
   // helper for ByteSizeLong()
   size_t RequiredFieldsByteSizeFallback() const;
@@ -1820,6 +1829,7 @@ class Parkspace_number : public ::google::protobuf::Message /* @@protoc_insertio
   ::google::protobuf::int32 rows_;
   ::google::protobuf::int32 columns_;
   ::google::protobuf::int32 total_;
+  ::google::protobuf::int32 liftway_width_;
   friend struct ::protobuf_dispatch_5fparameter_2eproto::TableStruct;
   friend void ::protobuf_dispatch_5fparameter_2eproto::InitDefaultsParkspace_numberImpl();
 };
@@ -1990,10 +2000,10 @@ class Dispatch_coordinates_parameter_all : public ::google::protobuf::Message /*
   ::Dispatch_proto::Catcher_box_parameter* mutable_catcher_box_parameters();
   void set_allocated_catcher_box_parameters(::Dispatch_proto::Catcher_box_parameter* catcher_box_parameters);
 
-  // required .Dispatch_proto.Parkspace_number parkspace_number = 40;
+  // required .Dispatch_proto.Parkspace_number parkspace_number = 43;
   bool has_parkspace_number() const;
   void clear_parkspace_number();
-  static const int kParkspaceNumberFieldNumber = 40;
+  static const int kParkspaceNumberFieldNumber = 43;
   const ::Dispatch_proto::Parkspace_number& parkspace_number() const;
   ::Dispatch_proto::Parkspace_number* release_parkspace_number();
   ::Dispatch_proto::Parkspace_number* mutable_parkspace_number();
@@ -2209,17 +2219,38 @@ class Dispatch_coordinates_parameter_all : public ::google::protobuf::Message /*
   ::google::protobuf::int32 parkspace_id_total() const;
   void set_parkspace_id_total(::google::protobuf::int32 value);
 
-  // optional int32 car_wheel_base_min = 38;
+  // optional int32 third_floor_parkspace_id_min = 38;
+  bool has_third_floor_parkspace_id_min() const;
+  void clear_third_floor_parkspace_id_min();
+  static const int kThirdFloorParkspaceIdMinFieldNumber = 38;
+  ::google::protobuf::int32 third_floor_parkspace_id_min() const;
+  void set_third_floor_parkspace_id_min(::google::protobuf::int32 value);
+
+  // optional int32 third_floor_parkspace_id_max = 39;
+  bool has_third_floor_parkspace_id_max() const;
+  void clear_third_floor_parkspace_id_max();
+  static const int kThirdFloorParkspaceIdMaxFieldNumber = 39;
+  ::google::protobuf::int32 third_floor_parkspace_id_max() const;
+  void set_third_floor_parkspace_id_max(::google::protobuf::int32 value);
+
+  // optional int32 third_floor_parkspace_id_total = 40;
+  bool has_third_floor_parkspace_id_total() const;
+  void clear_third_floor_parkspace_id_total();
+  static const int kThirdFloorParkspaceIdTotalFieldNumber = 40;
+  ::google::protobuf::int32 third_floor_parkspace_id_total() const;
+  void set_third_floor_parkspace_id_total(::google::protobuf::int32 value);
+
+  // optional int32 car_wheel_base_min = 41;
   bool has_car_wheel_base_min() const;
   void clear_car_wheel_base_min();
-  static const int kCarWheelBaseMinFieldNumber = 38;
+  static const int kCarWheelBaseMinFieldNumber = 41;
   ::google::protobuf::int32 car_wheel_base_min() const;
   void set_car_wheel_base_min(::google::protobuf::int32 value);
 
-  // optional int32 car_wheel_base_max = 39;
+  // optional int32 car_wheel_base_max = 42;
   bool has_car_wheel_base_max() const;
   void clear_car_wheel_base_max();
-  static const int kCarWheelBaseMaxFieldNumber = 39;
+  static const int kCarWheelBaseMaxFieldNumber = 42;
   ::google::protobuf::int32 car_wheel_base_max() const;
   void set_car_wheel_base_max(::google::protobuf::int32 value);
 
@@ -2289,6 +2320,12 @@ class Dispatch_coordinates_parameter_all : public ::google::protobuf::Message /*
   void clear_has_parkspace_id_max();
   void set_has_parkspace_id_total();
   void clear_has_parkspace_id_total();
+  void set_has_third_floor_parkspace_id_min();
+  void clear_has_third_floor_parkspace_id_min();
+  void set_has_third_floor_parkspace_id_max();
+  void clear_has_third_floor_parkspace_id_max();
+  void set_has_third_floor_parkspace_id_total();
+  void clear_has_third_floor_parkspace_id_total();
   void set_has_car_wheel_base_min();
   void clear_has_car_wheel_base_min();
   void set_has_car_wheel_base_max();
@@ -2336,6 +2373,9 @@ class Dispatch_coordinates_parameter_all : public ::google::protobuf::Message /*
   ::google::protobuf::int32 parkspace_id_min_;
   ::google::protobuf::int32 parkspace_id_max_;
   ::google::protobuf::int32 parkspace_id_total_;
+  ::google::protobuf::int32 third_floor_parkspace_id_min_;
+  ::google::protobuf::int32 third_floor_parkspace_id_max_;
+  ::google::protobuf::int32 third_floor_parkspace_id_total_;
   ::google::protobuf::int32 car_wheel_base_min_;
   ::google::protobuf::int32 car_wheel_base_max_;
   mutable int _cached_size_;
@@ -3495,6 +3535,30 @@ inline void Parkspace_number::set_total(::google::protobuf::int32 value) {
   // @@protoc_insertion_point(field_set:Dispatch_proto.Parkspace_number.total)
 }
 
+// required int32 liftway_width = 4;
+inline bool Parkspace_number::has_liftway_width() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Parkspace_number::set_has_liftway_width() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Parkspace_number::clear_has_liftway_width() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Parkspace_number::clear_liftway_width() {
+  liftway_width_ = 0;
+  clear_has_liftway_width();
+}
+inline ::google::protobuf::int32 Parkspace_number::liftway_width() const {
+  // @@protoc_insertion_point(field_get:Dispatch_proto.Parkspace_number.liftway_width)
+  return liftway_width_;
+}
+inline void Parkspace_number::set_liftway_width(::google::protobuf::int32 value) {
+  set_has_liftway_width();
+  liftway_width_ = value;
+  // @@protoc_insertion_point(field_set:Dispatch_proto.Parkspace_number.liftway_width)
+}
+
 // -------------------------------------------------------------------
 
 // Dispatch_coordinates_parameter_all
@@ -4479,16 +4543,88 @@ inline void Dispatch_coordinates_parameter_all::set_parkspace_id_total(::google:
   // @@protoc_insertion_point(field_set:Dispatch_proto.Dispatch_coordinates_parameter_all.parkspace_id_total)
 }
 
-// optional int32 car_wheel_base_min = 38;
-inline bool Dispatch_coordinates_parameter_all::has_car_wheel_base_min() const {
+// optional int32 third_floor_parkspace_id_min = 38;
+inline bool Dispatch_coordinates_parameter_all::has_third_floor_parkspace_id_min() const {
   return (_has_bits_[1] & 0x00000002u) != 0;
 }
-inline void Dispatch_coordinates_parameter_all::set_has_car_wheel_base_min() {
+inline void Dispatch_coordinates_parameter_all::set_has_third_floor_parkspace_id_min() {
   _has_bits_[1] |= 0x00000002u;
 }
-inline void Dispatch_coordinates_parameter_all::clear_has_car_wheel_base_min() {
+inline void Dispatch_coordinates_parameter_all::clear_has_third_floor_parkspace_id_min() {
   _has_bits_[1] &= ~0x00000002u;
 }
+inline void Dispatch_coordinates_parameter_all::clear_third_floor_parkspace_id_min() {
+  third_floor_parkspace_id_min_ = 0;
+  clear_has_third_floor_parkspace_id_min();
+}
+inline ::google::protobuf::int32 Dispatch_coordinates_parameter_all::third_floor_parkspace_id_min() const {
+  // @@protoc_insertion_point(field_get:Dispatch_proto.Dispatch_coordinates_parameter_all.third_floor_parkspace_id_min)
+  return third_floor_parkspace_id_min_;
+}
+inline void Dispatch_coordinates_parameter_all::set_third_floor_parkspace_id_min(::google::protobuf::int32 value) {
+  set_has_third_floor_parkspace_id_min();
+  third_floor_parkspace_id_min_ = value;
+  // @@protoc_insertion_point(field_set:Dispatch_proto.Dispatch_coordinates_parameter_all.third_floor_parkspace_id_min)
+}
+
+// optional int32 third_floor_parkspace_id_max = 39;
+inline bool Dispatch_coordinates_parameter_all::has_third_floor_parkspace_id_max() const {
+  return (_has_bits_[1] & 0x00000004u) != 0;
+}
+inline void Dispatch_coordinates_parameter_all::set_has_third_floor_parkspace_id_max() {
+  _has_bits_[1] |= 0x00000004u;
+}
+inline void Dispatch_coordinates_parameter_all::clear_has_third_floor_parkspace_id_max() {
+  _has_bits_[1] &= ~0x00000004u;
+}
+inline void Dispatch_coordinates_parameter_all::clear_third_floor_parkspace_id_max() {
+  third_floor_parkspace_id_max_ = 0;
+  clear_has_third_floor_parkspace_id_max();
+}
+inline ::google::protobuf::int32 Dispatch_coordinates_parameter_all::third_floor_parkspace_id_max() const {
+  // @@protoc_insertion_point(field_get:Dispatch_proto.Dispatch_coordinates_parameter_all.third_floor_parkspace_id_max)
+  return third_floor_parkspace_id_max_;
+}
+inline void Dispatch_coordinates_parameter_all::set_third_floor_parkspace_id_max(::google::protobuf::int32 value) {
+  set_has_third_floor_parkspace_id_max();
+  third_floor_parkspace_id_max_ = value;
+  // @@protoc_insertion_point(field_set:Dispatch_proto.Dispatch_coordinates_parameter_all.third_floor_parkspace_id_max)
+}
+
+// optional int32 third_floor_parkspace_id_total = 40;
+inline bool Dispatch_coordinates_parameter_all::has_third_floor_parkspace_id_total() const {
+  return (_has_bits_[1] & 0x00000008u) != 0;
+}
+inline void Dispatch_coordinates_parameter_all::set_has_third_floor_parkspace_id_total() {
+  _has_bits_[1] |= 0x00000008u;
+}
+inline void Dispatch_coordinates_parameter_all::clear_has_third_floor_parkspace_id_total() {
+  _has_bits_[1] &= ~0x00000008u;
+}
+inline void Dispatch_coordinates_parameter_all::clear_third_floor_parkspace_id_total() {
+  third_floor_parkspace_id_total_ = 0;
+  clear_has_third_floor_parkspace_id_total();
+}
+inline ::google::protobuf::int32 Dispatch_coordinates_parameter_all::third_floor_parkspace_id_total() const {
+  // @@protoc_insertion_point(field_get:Dispatch_proto.Dispatch_coordinates_parameter_all.third_floor_parkspace_id_total)
+  return third_floor_parkspace_id_total_;
+}
+inline void Dispatch_coordinates_parameter_all::set_third_floor_parkspace_id_total(::google::protobuf::int32 value) {
+  set_has_third_floor_parkspace_id_total();
+  third_floor_parkspace_id_total_ = value;
+  // @@protoc_insertion_point(field_set:Dispatch_proto.Dispatch_coordinates_parameter_all.third_floor_parkspace_id_total)
+}
+
+// optional int32 car_wheel_base_min = 41;
+inline bool Dispatch_coordinates_parameter_all::has_car_wheel_base_min() const {
+  return (_has_bits_[1] & 0x00000010u) != 0;
+}
+inline void Dispatch_coordinates_parameter_all::set_has_car_wheel_base_min() {
+  _has_bits_[1] |= 0x00000010u;
+}
+inline void Dispatch_coordinates_parameter_all::clear_has_car_wheel_base_min() {
+  _has_bits_[1] &= ~0x00000010u;
+}
 inline void Dispatch_coordinates_parameter_all::clear_car_wheel_base_min() {
   car_wheel_base_min_ = 0;
   clear_has_car_wheel_base_min();
@@ -4503,15 +4639,15 @@ inline void Dispatch_coordinates_parameter_all::set_car_wheel_base_min(::google:
   // @@protoc_insertion_point(field_set:Dispatch_proto.Dispatch_coordinates_parameter_all.car_wheel_base_min)
 }
 
-// optional int32 car_wheel_base_max = 39;
+// optional int32 car_wheel_base_max = 42;
 inline bool Dispatch_coordinates_parameter_all::has_car_wheel_base_max() const {
-  return (_has_bits_[1] & 0x00000004u) != 0;
+  return (_has_bits_[1] & 0x00000020u) != 0;
 }
 inline void Dispatch_coordinates_parameter_all::set_has_car_wheel_base_max() {
-  _has_bits_[1] |= 0x00000004u;
+  _has_bits_[1] |= 0x00000020u;
 }
 inline void Dispatch_coordinates_parameter_all::clear_has_car_wheel_base_max() {
-  _has_bits_[1] &= ~0x00000004u;
+  _has_bits_[1] &= ~0x00000020u;
 }
 inline void Dispatch_coordinates_parameter_all::clear_car_wheel_base_max() {
   car_wheel_base_max_ = 0;
@@ -4527,7 +4663,7 @@ inline void Dispatch_coordinates_parameter_all::set_car_wheel_base_max(::google:
   // @@protoc_insertion_point(field_set:Dispatch_proto.Dispatch_coordinates_parameter_all.car_wheel_base_max)
 }
 
-// required .Dispatch_proto.Parkspace_number parkspace_number = 40;
+// required .Dispatch_proto.Parkspace_number parkspace_number = 43;
 inline bool Dispatch_coordinates_parameter_all::has_parkspace_number() const {
   return (_has_bits_[0] & 0x00000004u) != 0;
 }

dispatch/dispatch_parameter.proto

@@ -143,6 +143,7 @@ message Parkspace_number
     required int32                  rows = 1;
     required int32                  columns = 2;
     required int32                  total = 3;
+    required int32                  liftway_width = 4;
 }
 
 message Dispatch_coordinates_parameter_all
@@ -197,9 +198,14 @@ message Dispatch_coordinates_parameter_all
     optional int32                                      parkspace_id_max = 36;
     optional int32                                      parkspace_id_total = 37;
 
+    optional int32                                      third_floor_parkspace_id_min = 38;
+    optional int32                                      third_floor_parkspace_id_max = 39;
+    optional int32                                      third_floor_parkspace_id_total = 40;
+
+    optional int32                                      car_wheel_base_min = 41;
+    optional int32                                      car_wheel_base_max = 42;
+
+    required Parkspace_number                           parkspace_number=43;
 
-    optional int32                                      car_wheel_base_min = 38;
-    optional int32                                      car_wheel_base_max = 39;
 
-    required Parkspace_number                           parkspace_number=40;
 }

dispatch/dispatch_process.cpp

@@ -59,6 +59,8 @@ Error_manager Dispatch_process::Dispatch_process_init(message::Dispatch_request_
 			return Error_manager(Error_code::DISPATCH_PROCESS_INIT_ERROR, Error_level::MINOR_ERROR,
 								 " dispatch_request_msg.parkspace_info_ex_size() is error ");
 		}
+
+
 		//检查定位信息
 		if ( dispatch_request_msg.has_locate_information() == false )
 		{
@@ -68,10 +70,31 @@ Error_manager Dispatch_process::Dispatch_process_init(message::Dispatch_request_
 
 		m_dispatch_process_type = Common_data::Dispatch_process_type::DISPATCH_PROCESS_STORE;
 		m_dispatch_source = dispatch_request_msg.terminal_id() + PASSAGEWAY_ID_BASE ;
-		//终点在运动过程中动态分配
+		//终点在运动过程中动态分配//存车需要在完全确定车位之后, 才能判断车位类型
 //		m_dispatch_destination = dispatch_request_msg.parkspace_info().parkingspace_index_id() + PARKSPACE_ID_BASE;
+
+		for (int i = 0; i < m_dispatch_request_msg.parkspace_info_ex_size(); ++i)
+		{
+			if(m_dispatch_request_msg.parkspace_info_ex(i).parkspace_path() == message::Parkspace_path::LEFT_PATH)
+			{
+				Common_data::copy_data(m_parkspace_information_left, dispatch_request_msg.parkspace_info_ex(i));
+				Common_data::scaling(m_parkspace_information_left, 1000);
+			}
+			if(m_dispatch_request_msg.parkspace_info_ex(i).parkspace_path() == message::Parkspace_path::RIGHT_PATH)
+			{
+				Common_data::copy_data(m_parkspace_information_right, dispatch_request_msg.parkspace_info_ex(i));
+				Common_data::scaling(m_parkspace_information_right, 1000);
+			}
+			if(m_dispatch_request_msg.parkspace_info_ex(i).parkspace_path() == message::Parkspace_path::TEMPORARY_CACHE_PATH)
+			{
+				Common_data::copy_data(m_parkspace_information_temporary, dispatch_request_msg.parkspace_info_ex(i));
+				Common_data::scaling(m_parkspace_information_temporary, 1000);
+			}
+		}
 //		Common_data::copy_data(m_parkspace_information, dispatch_request_msg.parkspace_info());
 //		Common_data::scaling(m_parkspace_information, 1000);
+
+
 		Common_data::copy_data(m_car_measure_information, dispatch_request_msg.locate_information());
 		Common_data::scaling(m_car_measure_information, 1000);
 		m_wheel_base = m_car_measure_information.car_wheel_base;
@@ -93,13 +116,16 @@ Error_manager Dispatch_process::Dispatch_process_init(message::Dispatch_request_
 		}
 
 		m_dispatch_process_type = Common_data::Dispatch_process_type::DISPATCH_PROCESS_PICKUP;
-		m_dispatch_source = dispatch_request_msg.parkspace_info().parkingspace_index_id() + PARKSPACE_ID_BASE;
+		m_dispatch_source = dispatch_request_msg.parkspace_info_ex(0).parkingspace_index_id() + PARKSPACE_ID_BASE;
+		m_parkspace_type = (Common_data::Parkspace_type)( dispatch_request_msg.parkspace_info_ex(0).parkingspace_type() );
+
 		//终点在运动过程中动态分配
 		//目前不控制门, 所以出口有主控决定. 如果后续控制门, 那么出口可以由调度决定.
+		//目前取车还是固定出口.
 		m_dispatch_destination = dispatch_request_msg.terminal_id() + PASSAGEWAY_ID_BASE ;
-		Common_data::copy_data(m_parkspace_information, dispatch_request_msg.parkspace_info_ex(0));
-		Common_data::scaling(m_parkspace_information, 1000);
-		m_wheel_base = m_parkspace_information.car_information.car_wheel_base;
+		Common_data::copy_data(m_parkspace_information_optimal, dispatch_request_msg.parkspace_info_ex(0));
+		Common_data::scaling(m_parkspace_information_optimal, 1000);
+		m_wheel_base = m_parkspace_information_optimal.car_information.car_wheel_base;
 	}
 	else
 	{
@@ -115,6 +141,9 @@ Error_manager Dispatch_process::Dispatch_process_init(message::Dispatch_request_
 		return Error_manager(Error_code::DISPATCH_PROCESS_INIT_ERROR, Error_level::MINOR_ERROR,
 							 "  m_wheel_base < 1000 ERROR ");
 	}
+
+	m_car_type = (Common_data::Car_type)( dispatch_request_msg.car_type() );
+	m_temporary_cache_flag = false;
 	m_dispatch_request_msg = dispatch_request_msg;
 	m_dispatch_process_status = DISPATCH_PROCESS_CREATED;
 	return Error_code::SUCCESS;
@@ -151,6 +180,73 @@ Error_manager Dispatch_process::check_process_ready()
 							 " Dispatch_process::check_process_ready() fun error ");
 	}
 }
+//判断是否为待机，
+bool Dispatch_process::is_ready()
+{
+//	std::unique_lock<std::mutex> t_lock(m_lock);
+	if ( m_dispatch_process_status == DISPATCH_PROCESS_READY && m_dispatch_carrier_node.mp_main_carrier.get() == NULL)
+	{
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+//能否在左侧路径存车
+bool Dispatch_process::is_able_store_left_path()
+{
+	if ( m_parkspace_information_left.parkingspace_index_id !=0 )
+	{
+	    return true;
+	}
+	return false;
+}
+//能否在右侧路径存车
+bool Dispatch_process::is_able_store_right_path()
+{
+	if ( m_parkspace_information_right.parkingspace_index_id !=0 )
+	{
+		return true;
+	}
+	return false;
+}
+//能否在3楼路径存车
+bool Dispatch_process::is_able_store_temporary_cache_path()
+{
+	if ( m_parkspace_information_temporary.parkingspace_index_id !=0 )
+	{
+		return true;
+	}
+	return false;
+}
+
+
+//能否在临时缓存位存车
+bool Dispatch_process::is_able_store_temporary_cache_path_2nd_floor()
+{
+	if ( m_parkspace_information_temporary.parkingspace_index_id >= 4 && m_parkspace_information_temporary.parkingspace_index_id <= 12 )
+	{
+		return true;
+	}
+	return false;
+}
+//能否在临时缓存位存车
+bool Dispatch_process::is_able_store_temporary_cache_path_3rd_floor()
+{
+	if ( m_parkspace_information_temporary.parkingspace_index_id >= 19 && m_parkspace_information_temporary.parkingspace_index_id <= 27 )
+	{
+		return true;
+	}
+	return false;
+}
+
+void Dispatch_process::set_main_carrier(std::shared_ptr<Dispatch_device_base> p_carrier)
+{
+	std::unique_lock<std::mutex> t_lock(m_lock);
+	m_dispatch_carrier_node.mp_main_carrier = p_carrier;
+}
 
 void Dispatch_process::Main()
 {

dispatch/dispatch_process.h

@@ -37,6 +37,7 @@
 #include "../message/dispatch_message.pb.h"
 #include "../message/dispatch_control.pb.h"
 #include "../tool/point3D_tool.h"
+#include <atomic>
 
 //调度流程 存车
 class Dispatch_process : public tq::BaseTask
@@ -111,11 +112,11 @@ public:
 	{
 		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;					//调度任务指针, 内存由本模块管理
+		std::shared_ptr<Dispatch_device_base>	mp_main_catcher;						//调度设备指针, 内存由Dispatch_manager来管理
+		std::shared_ptr<Task_Base>				mp_main_catcher_task;					//调度任务指针, 内存由本模块管理
 		//跟随搬运器, 3号搬运器
-		std::shared_ptr<Carrier>				mp_following_carrier;					//调度设备指针, 内存由Dispatch_manager来管理
-		std::shared_ptr<Carrier_task>			mp_following_carrier_task;				//调度任务指针, 内存由本模块管理
+		std::shared_ptr<Dispatch_device_base>	mp_following_carrier;					//调度设备指针, 内存由Dispatch_manager来管理
+		std::shared_ptr<Task_Base>				mp_following_carrier_task;				//调度任务指针, 内存由本模块管理
 		//目前没有让别人避让的功能
 	};
 
@@ -124,14 +125,15 @@ public:
 	{
 		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;				//调度任务指针, 内存由本模块管理
+		std::shared_ptr<Dispatch_device_base>	mp_main_carrier;					//调度设备指针, 内存由Dispatch_manager来管理
+		std::shared_ptr<Task_Base>				mp_main_carrier_task;				//调度任务指针, 内存由本模块管理
 		//给机器人发送避让指令, 2号机器人(可选)
-		std::shared_ptr<Catcher>				mp_avoid_catcher;						//调度设备指针, 内存由Dispatch_manager来管理
-		std::shared_ptr<Catcher_task>			mp_avoid_catcher_task;					//调度任务指针, 内存由本模块管理
+		std::shared_ptr<Dispatch_device_base>	mp_avoid_catcher;						//调度设备指针, 内存由Dispatch_manager来管理
+		std::shared_ptr<Task_Base>				mp_avoid_catcher_task;					//调度任务指针, 内存由本模块管理
 	};
 
 
+
 public:
 	Dispatch_process();
 	Dispatch_process(const Dispatch_process& other)= default;
@@ -145,8 +147,20 @@ public://API functions
 
 	//检查流程是否空闲待机
 	Error_manager check_process_ready();
+	//判断是否为待机，
+	virtual bool is_ready();
+	//能否在左侧路径存车
+	bool is_able_store_left_path();
+	//能否在右侧路径存车
+	bool is_able_store_right_path();
+	//能否在临时缓存位存车
+	bool is_able_store_temporary_cache_path();
+	//能否在临时缓存位存车
+	bool is_able_store_temporary_cache_path_2nd_floor();
+	//能否在临时缓存位存车
+	bool is_able_store_temporary_cache_path_3rd_floor();
 public://get or set member variable
-
+	void set_main_carrier(std::shared_ptr<Dispatch_device_base> p_carrier);
 protected://主流程
 
 	//主线程
@@ -251,7 +265,7 @@ protected://短流程
 	Error_manager carrier_adjust_wheel_base(Dispatch_control_node & dispatch_control_node, Carrier * tp_carrier, Carrier_task * tp_carrier_task, Dispatch_coordinates * tp_dispatch_coordinates);
 
 public://member variable
-	Dispatch_process_status					m_dispatch_process_status;	//调度流程的状态, 控制步骤
+	std::atomic<Dispatch_process_status>	m_dispatch_process_status;	//调度流程的状态, 控制步骤
 
 	//流程总规划数据, 外部指令
 	std::mutex                          	m_lock;
@@ -259,7 +273,13 @@ public://member variable
 	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;	//单个车位基本信息与状态信息,车位信息以及车位上的车辆信息
+	Common_data::Parkspace_information		m_parkspace_information_optimal;	//单个车位基本信息与状态信息,车位信息以及车位上的车辆信息
+	Common_data::Parkspace_information		m_parkspace_information_left;		//单个车位基本信息与状态信息,车位信息以及车位上的车辆信息
+	Common_data::Parkspace_information		m_parkspace_information_right;		//单个车位基本信息与状态信息,车位信息以及车位上的车辆信息
+	Common_data::Parkspace_information		m_parkspace_information_temporary;	//单个车位基本信息与状态信息,车位信息以及车位上的车辆信息
+	Common_data::Parkspace_type				m_parkspace_type;					//车位类型
+	Common_data::Car_type					m_car_type;							//车辆类型
+	bool 									m_temporary_cache_flag;				//是否使用临时缓存的标记位
 
 	std::string								m_command_key;						//任务唯一码, 索引
 	int 									m_timeout_ms;						//超时时间,单位ms

error_code/error_code.h

@@ -408,7 +408,9 @@ enum Error_code
 
 	//DISPATCH_COORDINATES module, 通信模块
 	DISPATCH_COORDINATES_ERROR_BASE					= 0x13060000,
-	DISPATCH_COORDINATES_READ_PROTOBUF_ERROR,				//模块，读取参数错误
+	DISPATCH_COORDINATES_READ_PROTOBUF_ERROR,				//调度坐标模块，读取参数错误
+	DISPATCH_COORDINATES_ID_ERROR,							//调度坐标模块，坐标id错误
+	DISPATCH_COORDINATES_PATH_ERROR,						//调度坐标模块，路径方向错误
 
 
 	//snap7 通信模块 错误码

main.cpp

@@ -53,9 +53,33 @@ GOOGLE_GLOG_DLL_DECL void shut_down_logging(const char* data, int size)
 #include <chrono>
 using namespace std;
 
+class AAA
+{
+public:
+	int a;
+
+};
+
+class BBB:public AAA
+{
+public:
+	int b;
+};
+
 
 int main(int argc,char* argv[])
 {
+//	std::shared_ptr<AAA> aaa(new BBB);
+//	aaa->a = 10;
+//	std::cout << " huli test :::: " << " aaa.size() = " << aaa.use_count()<< std::endl;
+//	std::cout << " huli test :::: " << " aaa->a = " << aaa->a<< std::endl;
+//
+//	BBB* bbb = (BBB*)aaa.get();
+//
+//
+//	return 0;
+
+
 	Error_manager t_error;
 
 	const char* logPath = "./";

message/dispatch_message.pb.cc

@@ -270,6 +270,7 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Dispatch_request_msg, parkspace_info_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Dispatch_request_msg, locate_information_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Dispatch_request_msg, parkspace_info_ex_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Dispatch_request_msg, car_type_),
   1,
   0,
   4,
@@ -277,6 +278,7 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
   2,
   3,
   ~0u,
+  6,
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Dispatch_response_msg, _has_bits_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Dispatch_response_msg, _internal_metadata_),
   ~0u,  // no _extensions_
@@ -442,13 +444,13 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
 };
 static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
   { 0, 9, sizeof(::message::Dispatch_terminal_status_msg)},
-  { 13, 25, sizeof(::message::Dispatch_request_msg)},
-  { 32, 42, sizeof(::message::Dispatch_response_msg)},
-  { 47, 71, sizeof(::message::Catcher_data)},
-  { 90, 114, sizeof(::message::Carrier_data)},
-  { 133, 155, sizeof(::message::Passageway_data)},
-  { 172, 183, sizeof(::message::Dispatch_manager_status_msg)},
-  { 189, 194, sizeof(::message::Dispatch_manager_data_msg)},
+  { 13, 26, sizeof(::message::Dispatch_request_msg)},
+  { 34, 44, sizeof(::message::Dispatch_response_msg)},
+  { 49, 73, sizeof(::message::Catcher_data)},
+  { 92, 116, sizeof(::message::Carrier_data)},
+  { 135, 157, sizeof(::message::Passageway_data)},
+  { 174, 185, sizeof(::message::Dispatch_manager_status_msg)},
+  { 191, 196, sizeof(::message::Dispatch_manager_data_msg)},
 };
 
 static ::google::protobuf::Message const * const file_default_instances[] = {
@@ -490,7 +492,7 @@ void AddDescriptorsImpl() {
       "_info\022\023\n\013terminal_id\030\002 \002(\005\0221\n\017terminal_s"
       "tatus\030\003 \002(\0162\030.message.Terminal_status\022;\n"
       "\024passageway_direction\030\004 \002(\0162\035.message.Pa"
-      "ssageway_direction\"\314\002\n\024Dispatch_request_"
+      "ssageway_direction\"\361\002\n\024Dispatch_request_"
       "msg\022%\n\tbase_info\030\001 \002(\0132\022.message.Base_in"
       "fo\022\023\n\013command_key\030\002 \002(\t\022E\n\031dispatch_moti"
       "on_direction\030\003 \002(\0162\".message.Dispatch_mo"
@@ -498,132 +500,133 @@ void AddDescriptorsImpl() {
       "arkspace_info\030\005 \001(\0132\027.message.Parkspace_"
       "info\0227\n\022locate_information\030\006 \001(\0132\033.messa"
       "ge.Locate_information\0222\n\021parkspace_info_"
-      "ex\030\007 \003(\0132\027.message.Parkspace_info\"\347\001\n\025Di"
-      "spatch_response_msg\022%\n\tbase_info\030\001 \002(\0132\022"
-      ".message.Base_info\022\023\n\013command_key\030\002 \002(\t\022"
-      "-\n\rerror_manager\030\003 \002(\0132\026.message.Error_m"
-      "anager\022/\n\016parkspace_info\030\004 \001(\0132\027.message"
-      ".Parkspace_info\0222\n\021parkspace_info_ex\030\005 \003"
-      "(\0132\027.message.Parkspace_info\"\313\005\n\014Catcher_"
-      "data\022;\n\024dispatch_device_type\030\001 \002(\0162\035.mes"
-      "sage.Dispatch_device_type\022\?\n\026dispatch_de"
-      "vice_status\030\002 \002(\0162\037.message.Dispatch_dev"
-      "ice_status\022\021\n\tdevice_id\030\003 \002(\005\022=\n\024actual_"
-      "device_status\030\004 \001(\0162\037.message.Hardware_d"
-      "evice_status\0220\n\022actual_load_status\030\005 \001(\016"
-      "2\024.message.Load_status\022\035\n\025actual_coordin"
-      "ates_id\030\006 \001(\005\022\020\n\010actual_x\030\007 \001(\002\022\020\n\010actua"
-      "l_y\030\010 \001(\002\022\020\n\010actual_b\030\t \001(\002\022\020\n\010actual_z\030"
-      "\n \001(\002\022\021\n\tactual_d1\030\013 \001(\002\022\021\n\tactual_d2\030\014 "
-      "\001(\002\0223\n\024actual_clamp_motion1\030\r \001(\0162\025.mess"
-      "age.Clamp_motion\0223\n\024actual_clamp_motion2"
-      "\030\016 \001(\0162\025.message.Clamp_motion\0223\n\024actual_"
-      "clamp_motion3\030\017 \001(\0162\025.message.Clamp_moti"
-      "on\0223\n\024actual_clamp_motion4\030\020 \001(\0162\025.messa"
-      "ge.Clamp_motion\022\031\n\021actual_error_code\030\021 \001"
-      "(\t\022\033\n\023actual_warning_code\030\022 \001(\t\022 \n\030actua"
-      "l_error_description\030\023 \001(\t\"\207\006\n\014Carrier_da"
-      "ta\022;\n\024dispatch_device_type\030\001 \002(\0162\035.messa"
-      "ge.Dispatch_device_type\022\?\n\026dispatch_devi"
-      "ce_status\030\002 \002(\0162\037.message.Dispatch_devic"
-      "e_status\022\021\n\tdevice_id\030\003 \002(\005\022=\n\024actual_de"
-      "vice_status\030\004 \001(\0162\037.message.Hardware_dev"
-      "ice_status\0220\n\022actual_load_status\030\005 \001(\0162\024"
-      ".message.Load_status\022\035\n\025actual_coordinat"
-      "es_id\030\006 \001(\005\022\020\n\010actual_x\030\007 \001(\002\022\020\n\010actual_"
-      "y\030\010 \001(\002\022\020\n\010actual_z\030\t \001(\002\022\021\n\tactual_y1\030\n"
-      " \001(\002\022\021\n\tactual_y2\030\013 \001(\002\0223\n\024actual_clamp_"
-      "motion1\030\014 \001(\0162\025.message.Clamp_motion\0223\n\024"
-      "actual_clamp_motion2\030\r \001(\0162\025.message.Cla"
-      "mp_motion\022H\n\036actual_small_sports_car_mot"
-      "ion\030\016 \001(\0162 .message.Small_sports_car_mot"
-      "ion\0225\n\026actual_joint_motion_x1\030\017 \001(\0162\025.me"
-      "ssage.Joint_motion\0225\n\026actual_joint_motio"
-      "n_x2\030\020 \001(\0162\025.message.Joint_motion\022\031\n\021act"
-      "ual_error_code\030\021 \001(\t\022\033\n\023actual_warning_c"
-      "ode\030\022 \001(\t\022 \n\030actual_error_description\030\023 "
-      "\001(\t\"\275\007\n\017Passageway_data\022;\n\024dispatch_devi"
-      "ce_type\030\001 \002(\0162\035.message.Dispatch_device_"
-      "type\022\?\n\026dispatch_device_status\030\002 \002(\0162\037.m"
-      "essage.Dispatch_device_status\022\021\n\tdevice_"
-      "id\030\003 \002(\005\022=\n\024actual_device_status\030\004 \001(\0162\037"
-      ".message.Hardware_device_status\0227\n\031actua"
-      "l_inside_load_status\030\005 \001(\0162\024.message.Loa"
-      "d_status\0228\n\032actual_outside_load_status\030\006"
-      " \001(\0162\024.message.Load_status\022J\n\"actual_fro"
-      "nt_overstep_the_boundary\030\007 \001(\0162\036.message"
-      ".Overstep_the_boundary\022I\n!actual_back_ov"
-      "erstep_the_boundary\030\010 \001(\0162\036.message.Over"
-      "step_the_boundary\022K\n#actual_height_overs"
-      "tep_the_boundary\030\t \001(\0162\036.message.Overste"
-      "p_the_boundary\0228\n\032actual_outside_door_se"
-      "nsor\030\n \001(\0162\024.message.Load_status\0227\n\031actu"
-      "al_inside_door_motion\030\013 \001(\0162\024.message.Do"
-      "or_motion\0228\n\032actual_outside_door_motion\030"
-      "\014 \001(\0162\024.message.Door_motion\022:\n\034actual_tu"
-      "rntable_load_status\030\r \001(\0162\024.message.Load"
-      "_status\022@\n\032actual_turntable_direction\030\016 "
-      "\001(\0162\034.message.Turntable_direction\022\031\n\021act"
-      "ual_error_code\030\017 \001(\t\022\033\n\023actual_warning_c"
-      "ode\030\020 \001(\t\022 \n\030actual_error_description\030\021 "
-      "\001(\t\"\265\002\n\033Dispatch_manager_status_msg\022%\n\tb"
-      "ase_info\030\001 \002(\0132\022.message.Base_info\022\023\n\013di"
-      "spatch_id\030\002 \002(\005\022A\n\027dispatch_manager_stat"
-      "us\030\003 \002(\0162 .message.Dispatch_manager_stat"
-      "us\022/\n\020catcher_data_map\030\004 \003(\0132\025.message.C"
-      "atcher_data\022/\n\020carrier_data_map\030\005 \003(\0132\025."
-      "message.Carrier_data\0225\n\023passageway_data_"
-      "map\030\006 \003(\0132\030.message.Passageway_data\"\033\n\031D"
-      "ispatch_manager_data_msg*\201\001\n\017Terminal_st"
-      "atus\022\025\n\021E_TERMINAL_UNKNOW\020\000\022\024\n\020E_TERMINA"
-      "L_READY\020\001\022\024\n\020E_TERMINAL_STORE\020\002\022\025\n\021E_TER"
-      "MINAL_PICKUP\020\003\022\024\n\020E_TERMINAL_FAULT\020\n*B\n\024"
-      "Passageway_direction\022\013\n\007E_INLET\020\000\022\014\n\010E_O"
-      "UTLET\020\001\022\017\n\013E_BILATERAL\020\002*>\n\031Dispatch_mot"
-      "ion_direction\022\017\n\013E_STORE_CAR\020\000\022\020\n\014E_PICK"
-      "UP_CAR\020\001*\261\001\n\027Dispatch_manager_status\022\035\n\031"
-      "E_DISPATCH_MANAGER_UNKNOW\020\000\022\034\n\030E_DISPATC"
-      "H_MANAGER_READY\020\001\022\034\n\030E_DISPATCH_MANAGER_"
-      "STORE\020\002\022\035\n\031E_DISPATCH_MANAGER_PICKUP\020\003\022\034"
-      "\n\030E_DISPATCH_MANAGER_FAULT\020d*\200\003\n\026Dispatc"
-      "h_device_status\022\032\n\026DISPATCH_DEVICE_UNKNO"
-      "W\020\000\022\031\n\025DISPATCH_DEVICE_READY\020\001\022\030\n\024DISPAT"
-      "CH_DEVICE_BUSY\020\002\022\"\n\036DISPATCH_DEVICE_ONE_"
-      "LEVEL_OVER\020\003\022\"\n\036DISPATCH_DEVICE_ONE_LEVE"
-      "L_WORK\020\004\022\"\n\036DISPATCH_DEVICE_TWO_LEVEL_OV"
-      "ER\020\005\022\"\n\036DISPATCH_DEVICE_TWO_LEVEL_WORK\020\006"
-      "\022$\n DISPATCH_DEVICE_THREE_LEVEL_OVER\020\007\022$"
-      "\n DISPATCH_DEVICE_THREE_LEVEL_WORK\020\010\022\031\n\025"
-      "DISPATCH_DEVICE_FAULT\020d\022\036\n\032DISPATCH_DEVI"
-      "CE_DISCONNECT\020e*n\n\023Dispatch_task_level\022\033"
-      "\n\027DISPATCH_TASK_ONE_LEVEL\020\001\022\033\n\027DISPATCH_"
-      "TASK_TWO_LEVEL\020\002\022\035\n\031DISPATCH_TASK_THREE_"
-      "LEVEL\020\003*K\n\014Clamp_motion\022\025\n\021E_CLAMP_NO_AC"
-      "TION\020\000\022\021\n\rE_CLAMP_TIGHT\020\001\022\021\n\rE_CLAMP_LOO"
-      "SE\020\002*R\n\014Joint_motion\022\025\n\021E_JOINT_NO_ACTIO"
-      "N\020\000\022\024\n\020E_JOINT_HOLD_OUT\020\001\022\025\n\021E_JOINT_TAK"
-      "E_BACK\020\002*y\n\027Small_sports_car_motion\022\034\n\030E"
-      "_SMALL_SPORTS_NO_ACTION\020\000\022\037\n\033E_SMALL_SPO"
-      "RTS_CAR_GET_AWAY\020\001\022\037\n\033E_SMALL_SPORTS_CAR"
-      "_GET_BACK\020\002*l\n\016Respons_status\022\023\n\017RESPONS"
-      "_WORKING\020\000\022\020\n\014RESPONS_OVER\020\001\022\027\n\023RESPONS_"
-      "MINOR_ERROR\020d\022\032\n\026RESPONS_CRITICAL_ERROR\020"
-      "e*\252\001\n\026Hardware_device_status\022\022\n\016DEVICE_U"
-      "NKNOWN\020\000\022\020\n\014DEVICE_READY\020\001\022\022\n\016DEVICE_WOR"
-      "KING\020\002\022\031\n\025DEVICE_EMERGENCY_STOP\020\003\022\023\n\017DEV"
-      "ICE_UNSAFETY\020\004\022\024\n\020DEVICE_COLLISION\020\005\022\020\n\014"
-      "DEVICE_FAULT\020\006*9\n\013Load_status\022\020\n\014LOAD_UN"
-      "KNOWN\020\000\022\014\n\010HAVE_CAR\020\001\022\n\n\006NO_CAR\020\002*w\n\023Tur"
-      "ntable_direction\022\037\n\033TURNTABLE_DIRECTION_"
-      "UNKNOWN\020\000\022\036\n\032TURNTABLE_DIRECTION_INSIDE\020"
-      "\001\022\037\n\033TURNTABLE_DIRECTION_OUTSIDE\020\002*N\n\013Do"
-      "or_motion\022\020\n\014DOOR_UNKNOWN\020\000\022\r\n\tDOOR_OPEN"
-      "\020\001\022\016\n\nDOOR_CLOSE\020\002\022\016\n\nDOOR_ERROR\020\003*C\n\025Ov"
-      "erstep_the_boundary\022\023\n\017BOUNDARY_NORMAL\020\000"
-      "\022\025\n\021BOUNDARY_OVERSTEP\020\001"
+      "ex\030\007 \003(\0132\027.message.Parkspace_info\022#\n\010car"
+      "_type\030\010 \001(\0162\021.message.Car_type\"\347\001\n\025Dispa"
+      "tch_response_msg\022%\n\tbase_info\030\001 \002(\0132\022.me"
+      "ssage.Base_info\022\023\n\013command_key\030\002 \002(\t\022-\n\r"
+      "error_manager\030\003 \002(\0132\026.message.Error_mana"
+      "ger\022/\n\016parkspace_info\030\004 \001(\0132\027.message.Pa"
+      "rkspace_info\0222\n\021parkspace_info_ex\030\005 \003(\0132"
+      "\027.message.Parkspace_info\"\313\005\n\014Catcher_dat"
+      "a\022;\n\024dispatch_device_type\030\001 \002(\0162\035.messag"
+      "e.Dispatch_device_type\022\?\n\026dispatch_devic"
+      "e_status\030\002 \002(\0162\037.message.Dispatch_device"
+      "_status\022\021\n\tdevice_id\030\003 \002(\005\022=\n\024actual_dev"
+      "ice_status\030\004 \001(\0162\037.message.Hardware_devi"
+      "ce_status\0220\n\022actual_load_status\030\005 \001(\0162\024."
+      "message.Load_status\022\035\n\025actual_coordinate"
+      "s_id\030\006 \001(\005\022\020\n\010actual_x\030\007 \001(\002\022\020\n\010actual_y"
+      "\030\010 \001(\002\022\020\n\010actual_b\030\t \001(\002\022\020\n\010actual_z\030\n \001"
+      "(\002\022\021\n\tactual_d1\030\013 \001(\002\022\021\n\tactual_d2\030\014 \001(\002"
+      "\0223\n\024actual_clamp_motion1\030\r \001(\0162\025.message"
+      ".Clamp_motion\0223\n\024actual_clamp_motion2\030\016 "
+      "\001(\0162\025.message.Clamp_motion\0223\n\024actual_cla"
+      "mp_motion3\030\017 \001(\0162\025.message.Clamp_motion\022"
+      "3\n\024actual_clamp_motion4\030\020 \001(\0162\025.message."
+      "Clamp_motion\022\031\n\021actual_error_code\030\021 \001(\t\022"
+      "\033\n\023actual_warning_code\030\022 \001(\t\022 \n\030actual_e"
+      "rror_description\030\023 \001(\t\"\207\006\n\014Carrier_data\022"
+      ";\n\024dispatch_device_type\030\001 \002(\0162\035.message."
+      "Dispatch_device_type\022\?\n\026dispatch_device_"
+      "status\030\002 \002(\0162\037.message.Dispatch_device_s"
+      "tatus\022\021\n\tdevice_id\030\003 \002(\005\022=\n\024actual_devic"
+      "e_status\030\004 \001(\0162\037.message.Hardware_device"
+      "_status\0220\n\022actual_load_status\030\005 \001(\0162\024.me"
+      "ssage.Load_status\022\035\n\025actual_coordinates_"
+      "id\030\006 \001(\005\022\020\n\010actual_x\030\007 \001(\002\022\020\n\010actual_y\030\010"
+      " \001(\002\022\020\n\010actual_z\030\t \001(\002\022\021\n\tactual_y1\030\n \001("
+      "\002\022\021\n\tactual_y2\030\013 \001(\002\0223\n\024actual_clamp_mot"
+      "ion1\030\014 \001(\0162\025.message.Clamp_motion\0223\n\024act"
+      "ual_clamp_motion2\030\r \001(\0162\025.message.Clamp_"
+      "motion\022H\n\036actual_small_sports_car_motion"
+      "\030\016 \001(\0162 .message.Small_sports_car_motion"
+      "\0225\n\026actual_joint_motion_x1\030\017 \001(\0162\025.messa"
+      "ge.Joint_motion\0225\n\026actual_joint_motion_x"
+      "2\030\020 \001(\0162\025.message.Joint_motion\022\031\n\021actual"
+      "_error_code\030\021 \001(\t\022\033\n\023actual_warning_code"
+      "\030\022 \001(\t\022 \n\030actual_error_description\030\023 \001(\t"
+      "\"\275\007\n\017Passageway_data\022;\n\024dispatch_device_"
+      "type\030\001 \002(\0162\035.message.Dispatch_device_typ"
+      "e\022\?\n\026dispatch_device_status\030\002 \002(\0162\037.mess"
+      "age.Dispatch_device_status\022\021\n\tdevice_id\030"
+      "\003 \002(\005\022=\n\024actual_device_status\030\004 \001(\0162\037.me"
+      "ssage.Hardware_device_status\0227\n\031actual_i"
+      "nside_load_status\030\005 \001(\0162\024.message.Load_s"
+      "tatus\0228\n\032actual_outside_load_status\030\006 \001("
+      "\0162\024.message.Load_status\022J\n\"actual_front_"
+      "overstep_the_boundary\030\007 \001(\0162\036.message.Ov"
+      "erstep_the_boundary\022I\n!actual_back_overs"
+      "tep_the_boundary\030\010 \001(\0162\036.message.Overste"
+      "p_the_boundary\022K\n#actual_height_overstep"
+      "_the_boundary\030\t \001(\0162\036.message.Overstep_t"
+      "he_boundary\0228\n\032actual_outside_door_senso"
+      "r\030\n \001(\0162\024.message.Load_status\0227\n\031actual_"
+      "inside_door_motion\030\013 \001(\0162\024.message.Door_"
+      "motion\0228\n\032actual_outside_door_motion\030\014 \001"
+      "(\0162\024.message.Door_motion\022:\n\034actual_turnt"
+      "able_load_status\030\r \001(\0162\024.message.Load_st"
+      "atus\022@\n\032actual_turntable_direction\030\016 \001(\016"
+      "2\034.message.Turntable_direction\022\031\n\021actual"
+      "_error_code\030\017 \001(\t\022\033\n\023actual_warning_code"
+      "\030\020 \001(\t\022 \n\030actual_error_description\030\021 \001(\t"
+      "\"\265\002\n\033Dispatch_manager_status_msg\022%\n\tbase"
+      "_info\030\001 \002(\0132\022.message.Base_info\022\023\n\013dispa"
+      "tch_id\030\002 \002(\005\022A\n\027dispatch_manager_status\030"
+      "\003 \002(\0162 .message.Dispatch_manager_status\022"
+      "/\n\020catcher_data_map\030\004 \003(\0132\025.message.Catc"
+      "her_data\022/\n\020carrier_data_map\030\005 \003(\0132\025.mes"
+      "sage.Carrier_data\0225\n\023passageway_data_map"
+      "\030\006 \003(\0132\030.message.Passageway_data\"\033\n\031Disp"
+      "atch_manager_data_msg*\201\001\n\017Terminal_statu"
+      "s\022\025\n\021E_TERMINAL_UNKNOW\020\000\022\024\n\020E_TERMINAL_R"
+      "EADY\020\001\022\024\n\020E_TERMINAL_STORE\020\002\022\025\n\021E_TERMIN"
+      "AL_PICKUP\020\003\022\024\n\020E_TERMINAL_FAULT\020\n*B\n\024Pas"
+      "sageway_direction\022\013\n\007E_INLET\020\000\022\014\n\010E_OUTL"
+      "ET\020\001\022\017\n\013E_BILATERAL\020\002*>\n\031Dispatch_motion"
+      "_direction\022\017\n\013E_STORE_CAR\020\000\022\020\n\014E_PICKUP_"
+      "CAR\020\001*\261\001\n\027Dispatch_manager_status\022\035\n\031E_D"
+      "ISPATCH_MANAGER_UNKNOW\020\000\022\034\n\030E_DISPATCH_M"
+      "ANAGER_READY\020\001\022\034\n\030E_DISPATCH_MANAGER_STO"
+      "RE\020\002\022\035\n\031E_DISPATCH_MANAGER_PICKUP\020\003\022\034\n\030E"
+      "_DISPATCH_MANAGER_FAULT\020d*\200\003\n\026Dispatch_d"
+      "evice_status\022\032\n\026DISPATCH_DEVICE_UNKNOW\020\000"
+      "\022\031\n\025DISPATCH_DEVICE_READY\020\001\022\030\n\024DISPATCH_"
+      "DEVICE_BUSY\020\002\022\"\n\036DISPATCH_DEVICE_ONE_LEV"
+      "EL_OVER\020\003\022\"\n\036DISPATCH_DEVICE_ONE_LEVEL_W"
+      "ORK\020\004\022\"\n\036DISPATCH_DEVICE_TWO_LEVEL_OVER\020"
+      "\005\022\"\n\036DISPATCH_DEVICE_TWO_LEVEL_WORK\020\006\022$\n"
+      " DISPATCH_DEVICE_THREE_LEVEL_OVER\020\007\022$\n D"
+      "ISPATCH_DEVICE_THREE_LEVEL_WORK\020\010\022\031\n\025DIS"
+      "PATCH_DEVICE_FAULT\020d\022\036\n\032DISPATCH_DEVICE_"
+      "DISCONNECT\020e*n\n\023Dispatch_task_level\022\033\n\027D"
+      "ISPATCH_TASK_ONE_LEVEL\020\001\022\033\n\027DISPATCH_TAS"
+      "K_TWO_LEVEL\020\002\022\035\n\031DISPATCH_TASK_THREE_LEV"
+      "EL\020\003*K\n\014Clamp_motion\022\025\n\021E_CLAMP_NO_ACTIO"
+      "N\020\000\022\021\n\rE_CLAMP_TIGHT\020\001\022\021\n\rE_CLAMP_LOOSE\020"
+      "\002*R\n\014Joint_motion\022\025\n\021E_JOINT_NO_ACTION\020\000"
+      "\022\024\n\020E_JOINT_HOLD_OUT\020\001\022\025\n\021E_JOINT_TAKE_B"
+      "ACK\020\002*y\n\027Small_sports_car_motion\022\034\n\030E_SM"
+      "ALL_SPORTS_NO_ACTION\020\000\022\037\n\033E_SMALL_SPORTS"
+      "_CAR_GET_AWAY\020\001\022\037\n\033E_SMALL_SPORTS_CAR_GE"
+      "T_BACK\020\002*l\n\016Respons_status\022\023\n\017RESPONS_WO"
+      "RKING\020\000\022\020\n\014RESPONS_OVER\020\001\022\027\n\023RESPONS_MIN"
+      "OR_ERROR\020d\022\032\n\026RESPONS_CRITICAL_ERROR\020e*\252"
+      "\001\n\026Hardware_device_status\022\022\n\016DEVICE_UNKN"
+      "OWN\020\000\022\020\n\014DEVICE_READY\020\001\022\022\n\016DEVICE_WORKIN"
+      "G\020\002\022\031\n\025DEVICE_EMERGENCY_STOP\020\003\022\023\n\017DEVICE"
+      "_UNSAFETY\020\004\022\024\n\020DEVICE_COLLISION\020\005\022\020\n\014DEV"
+      "ICE_FAULT\020\006*9\n\013Load_status\022\020\n\014LOAD_UNKNO"
+      "WN\020\000\022\014\n\010HAVE_CAR\020\001\022\n\n\006NO_CAR\020\002*w\n\023Turnta"
+      "ble_direction\022\037\n\033TURNTABLE_DIRECTION_UNK"
+      "NOWN\020\000\022\036\n\032TURNTABLE_DIRECTION_INSIDE\020\001\022\037"
+      "\n\033TURNTABLE_DIRECTION_OUTSIDE\020\002*N\n\013Door_"
+      "motion\022\020\n\014DOOR_UNKNOWN\020\000\022\r\n\tDOOR_OPEN\020\001\022"
+      "\016\n\nDOOR_CLOSE\020\002\022\016\n\nDOOR_ERROR\020\003*C\n\025Overs"
+      "tep_the_boundary\022\023\n\017BOUNDARY_NORMAL\020\000\022\025\n"
+      "\021BOUNDARY_OVERSTEP\020\001"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 5463);
+      descriptor, 5500);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "dispatch_message.proto", &protobuf_RegisterTypes);
   ::protobuf_message_5fbase_2eproto::AddDescriptors();
@@ -1343,6 +1346,7 @@ const int Dispatch_request_msg::kTerminalIdFieldNumber;
 const int Dispatch_request_msg::kParkspaceInfoFieldNumber;
 const int Dispatch_request_msg::kLocateInformationFieldNumber;
 const int Dispatch_request_msg::kParkspaceInfoExFieldNumber;
+const int Dispatch_request_msg::kCarTypeFieldNumber;
 #endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
 
 Dispatch_request_msg::Dispatch_request_msg()
@@ -1380,8 +1384,8 @@ Dispatch_request_msg::Dispatch_request_msg(const Dispatch_request_msg& from)
     locate_information_ = NULL;
   }
   ::memcpy(&dispatch_motion_direction_, &from.dispatch_motion_direction_,
-    static_cast<size_t>(reinterpret_cast<char*>(&terminal_id_) -
-    reinterpret_cast<char*>(&dispatch_motion_direction_)) + sizeof(terminal_id_));
+    static_cast<size_t>(reinterpret_cast<char*>(&car_type_) -
+    reinterpret_cast<char*>(&dispatch_motion_direction_)) + sizeof(car_type_));
   // @@protoc_insertion_point(copy_constructor:message.Dispatch_request_msg)
 }
 
@@ -1389,8 +1393,8 @@ void Dispatch_request_msg::SharedCtor() {
   _cached_size_ = 0;
   command_key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(&base_info_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&terminal_id_) -
-      reinterpret_cast<char*>(&base_info_)) + sizeof(terminal_id_));
+      reinterpret_cast<char*>(&car_type_) -
+      reinterpret_cast<char*>(&base_info_)) + sizeof(car_type_));
 }
 
 Dispatch_request_msg::~Dispatch_request_msg() {
@@ -1454,10 +1458,10 @@ void Dispatch_request_msg::Clear() {
       locate_information_->Clear();
     }
   }
-  if (cached_has_bits & 48u) {
+  if (cached_has_bits & 112u) {
     ::memset(&dispatch_motion_direction_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&terminal_id_) -
-        reinterpret_cast<char*>(&dispatch_motion_direction_)) + sizeof(terminal_id_));
+        reinterpret_cast<char*>(&car_type_) -
+        reinterpret_cast<char*>(&dispatch_motion_direction_)) + sizeof(car_type_));
   }
   _has_bits_.Clear();
   _internal_metadata_.Clear();
@@ -1570,6 +1574,26 @@ bool Dispatch_request_msg::MergePartialFromCodedStream(
         break;
       }
 
+      // optional .message.Car_type car_type = 8;
+      case 8: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::message::Car_type_IsValid(value)) {
+            set_car_type(static_cast< ::message::Car_type >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(
+                8, static_cast< ::google::protobuf::uint64>(value));
+          }
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
       default: {
       handle_unusual:
         if (tag == 0) {
@@ -1643,6 +1667,12 @@ void Dispatch_request_msg::SerializeWithCachedSizes(
       7, this->parkspace_info_ex(static_cast<int>(i)), output);
   }
 
+  // optional .message.Car_type car_type = 8;
+  if (cached_has_bits & 0x00000040u) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      8, this->car_type(), output);
+  }
+
   if (_internal_metadata_.have_unknown_fields()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         _internal_metadata_.unknown_fields(), output);
@@ -1709,6 +1739,12 @@ void Dispatch_request_msg::SerializeWithCachedSizes(
         7, this->parkspace_info_ex(static_cast<int>(i)), deterministic, target);
   }
 
+  // optional .message.Car_type car_type = 8;
+  if (cached_has_bits & 0x00000040u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      8, this->car_type(), target);
+  }
+
   if (_internal_metadata_.have_unknown_fields()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         _internal_metadata_.unknown_fields(), target);
@@ -1809,6 +1845,12 @@ size_t Dispatch_request_msg::ByteSizeLong() const {
     }
 
   }
+  // optional .message.Car_type car_type = 8;
+  if (has_car_type()) {
+    total_size += 1 +
+      ::google::protobuf::internal::WireFormatLite::EnumSize(this->car_type());
+  }
+
   int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = cached_size;
@@ -1840,7 +1882,7 @@ void Dispatch_request_msg::MergeFrom(const Dispatch_request_msg& from) {
 
   parkspace_info_ex_.MergeFrom(from.parkspace_info_ex_);
   cached_has_bits = from._has_bits_[0];
-  if (cached_has_bits & 63u) {
+  if (cached_has_bits & 127u) {
     if (cached_has_bits & 0x00000001u) {
       set_has_command_key();
       command_key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.command_key_);
@@ -1860,6 +1902,9 @@ void Dispatch_request_msg::MergeFrom(const Dispatch_request_msg& from) {
     if (cached_has_bits & 0x00000020u) {
       terminal_id_ = from.terminal_id_;
     }
+    if (cached_has_bits & 0x00000040u) {
+      car_type_ = from.car_type_;
+    }
     _has_bits_[0] |= cached_has_bits;
   }
 }
@@ -1899,6 +1944,7 @@ void Dispatch_request_msg::InternalSwap(Dispatch_request_msg* other) {
   swap(locate_information_, other->locate_information_);
   swap(dispatch_motion_direction_, other->dispatch_motion_direction_);
   swap(terminal_id_, other->terminal_id_);
+  swap(car_type_, other->car_type_);
   swap(_has_bits_[0], other->_has_bits_[0]);
   _internal_metadata_.Swap(&other->_internal_metadata_);
   swap(_cached_size_, other->_cached_size_);

message/dispatch_message.pb.h

@@ -719,6 +719,13 @@ class Dispatch_request_msg : public ::google::protobuf::Message /* @@protoc_inse
   ::google::protobuf::int32 terminal_id() const;
   void set_terminal_id(::google::protobuf::int32 value);
 
+  // optional .message.Car_type car_type = 8;
+  bool has_car_type() const;
+  void clear_car_type();
+  static const int kCarTypeFieldNumber = 8;
+  ::message::Car_type car_type() const;
+  void set_car_type(::message::Car_type value);
+
   // @@protoc_insertion_point(class_scope:message.Dispatch_request_msg)
  private:
   void set_has_base_info();
@@ -733,6 +740,8 @@ class Dispatch_request_msg : public ::google::protobuf::Message /* @@protoc_inse
   void clear_has_parkspace_info();
   void set_has_locate_information();
   void clear_has_locate_information();
+  void set_has_car_type();
+  void clear_has_car_type();
 
   // helper for ByteSizeLong()
   size_t RequiredFieldsByteSizeFallback() const;
@@ -747,6 +756,7 @@ class Dispatch_request_msg : public ::google::protobuf::Message /* @@protoc_inse
   ::message::Locate_information* locate_information_;
   int dispatch_motion_direction_;
   ::google::protobuf::int32 terminal_id_;
+  int car_type_;
   friend struct ::protobuf_dispatch_5fmessage_2eproto::TableStruct;
   friend void ::protobuf_dispatch_5fmessage_2eproto::InitDefaultsDispatch_request_msgImpl();
 };
@@ -2553,6 +2563,31 @@ Dispatch_request_msg::parkspace_info_ex() const {
   return parkspace_info_ex_;
 }
 
+// optional .message.Car_type car_type = 8;
+inline bool Dispatch_request_msg::has_car_type() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Dispatch_request_msg::set_has_car_type() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Dispatch_request_msg::clear_has_car_type() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Dispatch_request_msg::clear_car_type() {
+  car_type_ = 0;
+  clear_has_car_type();
+}
+inline ::message::Car_type Dispatch_request_msg::car_type() const {
+  // @@protoc_insertion_point(field_get:message.Dispatch_request_msg.car_type)
+  return static_cast< ::message::Car_type >(car_type_);
+}
+inline void Dispatch_request_msg::set_car_type(::message::Car_type value) {
+  assert(::message::Car_type_IsValid(value));
+  set_has_car_type();
+  car_type_ = value;
+  // @@protoc_insertion_point(field_set:message.Dispatch_request_msg.car_type)
+}
+
 // -------------------------------------------------------------------
 
 // Dispatch_response_msg

message/dispatch_message.proto

@@ -53,7 +53,7 @@ message Dispatch_request_msg
     optional Locate_information         locate_information=6;                   //汽车测量信息, 只有停车时有数据, 取车时没有数据.
 
     repeated Parkspace_info             parkspace_info_ex=7;                         //车位编号, 停车位(B方案, 分配3个停车位)
-
+    optional Car_type                   car_type=8;                             //汽车大小
 }
 
 //搬运动作执行完成后反馈结果(调度管理->主控)

message/message_base.pb.cc

@@ -181,7 +181,7 @@ void InitDefaultsParkspace_info() {
 }
 
 ::google::protobuf::Metadata file_level_metadata[6];
-const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[11];
+const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[12];
 
 const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Base_info, _has_bits_),
@@ -418,27 +418,28 @@ void AddDescriptorsImpl() {
       "\n\024TEMPORARY_CACHE_PATH\020\004*m\n\016Parkspace_ty"
       "pe\022\031\n\025UNKNOW_PARKSPACE_TYPE\020\000\022\024\n\020MIN_PAR"
       "KINGSPACE\020\001\022\024\n\020MID_PARKINGSPACE\020\002\022\024\n\020BIG"
-      "_PARKINGSPACE\020\003*\335\002\n\tStep_type\022\017\n\013eAlloc_"
-      "step\020\000\022\021\n\reMeasure_step\020\001\022\021\n\reCompare_st"
-      "ep\020\002\022\022\n\016eDispatch_step\020\003\022\021\n\reConfirm_ste"
-      "p\020\004\022\020\n\014eSearch_step\020\005\022\016\n\neWait_step\020\006\022\021\n"
-      "\reRelease_step\020\007\022\r\n\teComplete\020\010\022\025\n\021eBack"
-      "Confirm_step\020\t\022\026\n\022eBack_compare_step\020\n\022\025"
-      "\n\021eBackMeasure_step\020\013\022\023\n\017eBackAlloc_step"
-      "\020\014\022\022\n\016eBackWait_step\020\r\022\026\n\022eBackDispatch_"
-      "step\020\016\022\024\n\020eBackSearch_step\020\017\022\021\n\reBackCom"
-      "plete\020\020*C\n\nStep_statu\022\014\n\010eWaiting\020\000\022\014\n\010e"
-      "Working\020\001\022\n\n\006eError\020\002\022\r\n\teFinished\020\003*\370\001\n"
-      "\024Dispatch_device_type\022\013\n\007ROBOT_1\020e\022\013\n\007RO"
-      "BOT_2\020f\022\016\n\tCARRIER_1\020\310\001\022\016\n\tCARRIER_2\020\317\001\022"
-      "\016\n\tCARRIER_3\020\313\001\022\021\n\014PASSAGEWAY_0\020\254\002\022\021\n\014PA"
-      "SSAGEWAY_1\020\255\002\022\021\n\014PASSAGEWAY_2\020\256\002\022\021\n\014PASS"
-      "AGEWAY_3\020\257\002\022\021\n\014PASSAGEWAY_4\020\260\002\022\021\n\014PASSAG"
-      "EWAY_5\020\261\002\022\021\n\014PASSAGEWAY_6\020\262\002\022\021\n\014PASSAGEW"
-      "AY_7\020\263\002"
+      "_PARKINGSPACE\020\003*F\n\010Car_type\022\023\n\017UNKNOW_CA"
+      "R_TYPE\020\000\022\013\n\007MIN_CAR\020\001\022\013\n\007MID_CAR\020\002\022\013\n\007BI"
+      "G_CAR\020\003*\335\002\n\tStep_type\022\017\n\013eAlloc_step\020\000\022\021"
+      "\n\reMeasure_step\020\001\022\021\n\reCompare_step\020\002\022\022\n\016"
+      "eDispatch_step\020\003\022\021\n\reConfirm_step\020\004\022\020\n\014e"
+      "Search_step\020\005\022\016\n\neWait_step\020\006\022\021\n\reReleas"
+      "e_step\020\007\022\r\n\teComplete\020\010\022\025\n\021eBackConfirm_"
+      "step\020\t\022\026\n\022eBack_compare_step\020\n\022\025\n\021eBackM"
+      "easure_step\020\013\022\023\n\017eBackAlloc_step\020\014\022\022\n\016eB"
+      "ackWait_step\020\r\022\026\n\022eBackDispatch_step\020\016\022\024"
+      "\n\020eBackSearch_step\020\017\022\021\n\reBackComplete\020\020*"
+      "C\n\nStep_statu\022\014\n\010eWaiting\020\000\022\014\n\010eWorking\020"
+      "\001\022\n\n\006eError\020\002\022\r\n\teFinished\020\003*\370\001\n\024Dispatc"
+      "h_device_type\022\013\n\007ROBOT_1\020e\022\013\n\007ROBOT_2\020f\022"
+      "\016\n\tCARRIER_1\020\310\001\022\016\n\tCARRIER_2\020\317\001\022\016\n\tCARRI"
+      "ER_3\020\313\001\022\021\n\014PASSAGEWAY_0\020\254\002\022\021\n\014PASSAGEWAY"
+      "_1\020\255\002\022\021\n\014PASSAGEWAY_2\020\256\002\022\021\n\014PASSAGEWAY_3"
+      "\020\257\002\022\021\n\014PASSAGEWAY_4\020\260\002\022\021\n\014PASSAGEWAY_5\020\261"
+      "\002\022\021\n\014PASSAGEWAY_6\020\262\002\022\021\n\014PASSAGEWAY_7\020\263\002"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 4087);
+      descriptor, 4159);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "message_base.proto", &protobuf_RegisterTypes);
 }
@@ -621,10 +622,26 @@ bool Parkspace_type_IsValid(int value) {
   }
 }
 
-const ::google::protobuf::EnumDescriptor* Step_type_descriptor() {
+const ::google::protobuf::EnumDescriptor* Car_type_descriptor() {
   protobuf_message_5fbase_2eproto::protobuf_AssignDescriptorsOnce();
   return protobuf_message_5fbase_2eproto::file_level_enum_descriptors[8];
 }
+bool Car_type_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* Step_type_descriptor() {
+  protobuf_message_5fbase_2eproto::protobuf_AssignDescriptorsOnce();
+  return protobuf_message_5fbase_2eproto::file_level_enum_descriptors[9];
+}
 bool Step_type_IsValid(int value) {
   switch (value) {
     case 0:
@@ -652,7 +669,7 @@ bool Step_type_IsValid(int value) {
 
 const ::google::protobuf::EnumDescriptor* Step_statu_descriptor() {
   protobuf_message_5fbase_2eproto::protobuf_AssignDescriptorsOnce();
-  return protobuf_message_5fbase_2eproto::file_level_enum_descriptors[9];
+  return protobuf_message_5fbase_2eproto::file_level_enum_descriptors[10];
 }
 bool Step_statu_IsValid(int value) {
   switch (value) {
@@ -668,7 +685,7 @@ bool Step_statu_IsValid(int value) {
 
 const ::google::protobuf::EnumDescriptor* Dispatch_device_type_descriptor() {
   protobuf_message_5fbase_2eproto::protobuf_AssignDescriptorsOnce();
-  return protobuf_message_5fbase_2eproto::file_level_enum_descriptors[10];
+  return protobuf_message_5fbase_2eproto::file_level_enum_descriptors[11];
 }
 bool Dispatch_device_type_IsValid(int value) {
   switch (value) {

message/message_base.pb.h

@@ -292,6 +292,27 @@ inline bool Parkspace_type_Parse(
   return ::google::protobuf::internal::ParseNamedEnum<Parkspace_type>(
     Parkspace_type_descriptor(), name, value);
 }
+enum Car_type {
+  UNKNOW_CAR_TYPE = 0,
+  MIN_CAR = 1,
+  MID_CAR = 2,
+  BIG_CAR = 3
+};
+bool Car_type_IsValid(int value);
+const Car_type Car_type_MIN = UNKNOW_CAR_TYPE;
+const Car_type Car_type_MAX = BIG_CAR;
+const int Car_type_ARRAYSIZE = Car_type_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Car_type_descriptor();
+inline const ::std::string& Car_type_Name(Car_type value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Car_type_descriptor(), value);
+}
+inline bool Car_type_Parse(
+    const ::std::string& name, Car_type* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Car_type>(
+    Car_type_descriptor(), name, value);
+}
 enum Step_type {
   eAlloc_step = 0,
   eMeasure_step = 1,
@@ -2659,6 +2680,11 @@ template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::message::Parkspace_type>() {
   return ::message::Parkspace_type_descriptor();
 }
+template <> struct is_proto_enum< ::message::Car_type> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::message::Car_type>() {
+  return ::message::Car_type_descriptor();
+}
 template <> struct is_proto_enum< ::message::Step_type> : ::google::protobuf::internal::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::message::Step_type>() {

message/message_base.proto

@@ -177,8 +177,8 @@ enum Parkspace_path
     LEFT_PATH = 2;
     RIGHT_PATH = 3;
     TEMPORARY_CACHE_PATH = 4;
-
 }
+
 //车位类型
 enum Parkspace_type
 {
@@ -188,6 +188,15 @@ enum Parkspace_type
     BIG_PARKINGSPACE = 3;//大车位
 }
 
+//汽车类型
+enum Car_type
+{
+    UNKNOW_CAR_TYPE = 0;
+    MIN_CAR = 1;//小车
+    MID_CAR = 2;//中车
+    BIG_CAR = 3;//大车
+}
+
 //单个车位基本信息与状态信息,车位信息以及车位上的车辆信息
 message Parkspace_info
 {

setting/dispatch_coordinates.prototxt

@@ -2725,6 +2725,48 @@ carrier_coordinates_parameters
     z:1
 }
 carrier_coordinates_parameters
+{
+    id:1101
+    x:7755
+    y:3000
+    z:1
+}
+carrier_coordinates_parameters
+{
+    id:1102
+    x:11055
+    y:3000
+    z:1
+}
+carrier_coordinates_parameters
+{
+    id:1103
+    x:14655
+    y:3000
+    z:1
+}
+carrier_coordinates_parameters
+{
+    id:1104
+    x:17955
+    y:3000
+    z:1
+}
+carrier_coordinates_parameters
+{
+    id:1105
+    x:21555
+    y:3000
+    z:1
+}
+carrier_coordinates_parameters
+{
+    id:1106
+    x:24855
+    y:3000
+    z:1
+}
+carrier_coordinates_parameters
 {
     id:1107
     x:31600
@@ -3320,6 +3362,9 @@ parkspace_id_min:1
 parkspace_id_max:165
 parkspace_id_total:165
 
+third_floor_parkspace_id_min:19
+third_floor_parkspace_id_max:27
+third_floor_parkspace_id_total:9
 
 car_wheel_base_min:1000
 car_wheel_base_max:4000
@@ -3329,5 +3374,6 @@ parkspace_number
     rows:11
     columns:15
     total:165
+    liftway_width:3
 }
 

tool/common_data.h

@@ -95,7 +95,7 @@ public:
 		TEMPORARY_CACHE_PATH = 4,
 
 	};
-//车位类型
+	//车位类型
 	enum Parkspace_type
 	{
 		UNKNOW_PARKSPACE_TYPE = 0,
@@ -104,6 +104,15 @@ public:
 		BIG_PARKINGSPACE = 3,//大车位
 	};
 
+	//汽车类型
+	enum Car_type
+	{
+		UNKNOW_CAR_TYPE = 0,
+		MIN_CAR = 1,//小车
+		MID_CAR = 2,//中车
+		BIG_CAR = 3,//大车
+	};
+
 	//单个车位基本信息与状态信息,车位信息以及车位上的车辆信息
 	struct Parkspace_information
 	{