浏览代码

增加节点状态监控,车位占用请求.

zx 4 年之前
父节点
当前提交
f4784d1c06

+ 4 - 0
communication/communication_message.h

@@ -40,6 +40,10 @@ public:
         eParkspace_search_response_msg = 0x35,    //查询车位反馈消息
         eParkspace_release_request_msg = 0x36,    //释放车位请求消息
         eParkspace_release_response_msg = 0x37,    //释放车位反馈消息
+        eParkspace_force_update_request_msg = 0x38,	//手动修改车位消息
+        eParkspace_force_update_response_msg = 0x39,//手动修改车位反馈消息
+        eParkspace_confirm_alloc_request_msg = 0x3A,//确认分配车位请求消息
+        eParkspace_confirm_alloc_response_msg = 0x3B,//确认分配车位反馈消息
 
         eStore_command_request_msg=0x41,        //终端停车请求消息
         eStore_command_response_msg=0x42,       //停车请求反馈消息

+ 9 - 17
communication/communication_socket_base.cpp

@@ -107,7 +107,7 @@ Error_manager Communication_socket_base::communication_bind(std::string bind_str
 		return Error_manager(Error_code::COMMUNICATION_BIND_ERROR, Error_level::MINOR_ERROR,
 							 " m_socket.bind error ");
 	}
-	LOG(INFO) << " ---Communication_socket_base::communication_bind() bind::  "<< bind_string << "  " << this;
+	//LOG(INFO) << " ---Communication_socket_base::communication_bind() bind::  "<< bind_string << "  " << this;
 
 	return Error_code::SUCCESS;
 }
@@ -231,7 +231,7 @@ Error_manager Communication_socket_base::communication_uninit()
 //receive_data_thread 内部线程负责接受消息
 void Communication_socket_base::receive_data_thread(Communication_socket_base* communicator)
 {
-	LOG(INFO) << " Communication_socket_base::receive_data_thread start "<< communicator;
+	//LOG(INFO) << " Communication_socket_base::receive_data_thread start "<< communicator;
 
 	//通信接受线程, 负责接受socket消息, 并存入 m_receive_data_list
 	while (communicator->m_receive_condition.is_alive())
@@ -286,7 +286,7 @@ void Communication_socket_base::receive_data_thread(Communication_socket_base* c
 		}
 	}
 
-	LOG(INFO) << " Communication_socket_base::receive_data_thread end "<< communicator;
+	//LOG(INFO) << " Communication_socket_base::receive_data_thread end "<< communicator;
 	return;
 }
 
@@ -311,7 +311,7 @@ Error_manager Communication_socket_base::check_msg(Communication_message*  p_msg
 //analysis_data_thread 内部线程负责解析消息
 void Communication_socket_base::analysis_data_thread()
 {
-	LOG(INFO) << " Communication_socket_base::analysis_data_thread start "<< this;
+	//LOG(INFO) << " Communication_socket_base::analysis_data_thread start "<< this;
 
 	//通信解析线程, 负责巡检m_receive_data_list, 并解析和处理消息
 	while (m_analysis_data_condition.is_alive())
@@ -334,7 +334,7 @@ void Communication_socket_base::analysis_data_thread()
 		}
 	}
 
-	LOG(INFO) << " Communication_socket_base::analysis_data_thread end "<< this;
+	//LOG(INFO) << " Communication_socket_base::analysis_data_thread end "<< this;
 	return;
 }
 
@@ -412,9 +412,6 @@ Error_manager Communication_socket_base::check_executer(Communication_message*
 
 	if ( p_msg->is_over_time() )
 	{
-		std::cout << "Communication_socket_base::check_msg  p_buf =  " << p_msg->get_message_buf() << std::endl;
-		std::cout << "Communication_socket_base::check_msg   size =  " << p_msg->get_message_buf().size() << std::endl;
-		std::cout << "COMMUNICATION_ANALYSIS_TIME_OUT , " << std::endl;
 		return Error_code::COMMUNICATION_ANALYSIS_TIME_OUT;
 	}
 	else
@@ -424,9 +421,6 @@ Error_manager Communication_socket_base::check_executer(Communication_message*
 		//这里子类重载时, 增加判断逻辑, 以后再写.
 //		executer_is_ready = true;
 
-		std::cout << "Communication_socket_base::check_msg  p_buf =  " << p_msg->get_message_buf() << std::endl;
-		std::cout << "Communication_socket_base::check_msg   size =  " << p_msg->get_message_buf().size() << std::endl;
-
 		if ( executer_is_ready )
 		{
 			std::cout << "executer_is_ready , " << std::endl;
@@ -456,8 +450,6 @@ Error_manager Communication_socket_base::execute_msg(Communication_message*  p_m
 	//这里不应该长时间阻塞或者处理复杂的逻辑,
 	//请执行者另开线程来处理任务.
 
-	std::cout << "Communication_socket_base::excute_msg  p_buf =  " << p_msg->get_message_buf() << std::endl;
-	std::cout << "Communication_socket_base::excute_msg   size =  " << p_msg->get_message_buf().size() << std::endl;
 	return Error_code::SUCCESS;
 }
 
@@ -465,7 +457,7 @@ Error_manager Communication_socket_base::execute_msg(Communication_message*  p_m
 //send_data_thread 内部线程负责发送消息
 void Communication_socket_base::send_data_thread(Communication_socket_base* communicator)
 {
-	LOG(INFO) << " Communication_socket_base::send_data_thread start "<< communicator;
+	//LOG(INFO) << " Communication_socket_base::send_data_thread start "<< communicator;
 
 	//通信发送线程, 负责巡检m_send_data_list, 并发送消息
 	while (communicator->m_send_data_condition.is_alive())
@@ -501,7 +493,7 @@ void Communication_socket_base::send_data_thread(Communication_socket_base* comm
 		}
 	}
 
-	LOG(INFO) << " Communication_socket_base::send_data_thread end "<< communicator;
+	//LOG(INFO) << " Communication_socket_base::send_data_thread end "<< communicator;
 	return;
 }
 
@@ -509,7 +501,7 @@ void Communication_socket_base::send_data_thread(Communication_socket_base* comm
 //encapsulate_data_thread 内部线程负责封装消息
 void Communication_socket_base::encapsulate_data_thread()
 {
-	LOG(INFO) << " Communication_socket_base::encapsulate_data_thread start "<< this;
+	//LOG(INFO) << " Communication_socket_base::encapsulate_data_thread start "<< this;
 
 	//通信封装线程, 负责定时封装消息, 并存入 m_send_data_list
 	while (m_encapsulate_data_condition.is_alive())
@@ -532,7 +524,7 @@ void Communication_socket_base::encapsulate_data_thread()
 		}
 	}
 
-	LOG(INFO) << " Communication_socket_base::encapsulate_data_thread end "<< this;
+	//LOG(INFO) << " Communication_socket_base::encapsulate_data_thread end "<< this;
 	return;
 }
 

+ 23 - 1
dispatch/dispatch_communicator.cpp

@@ -98,7 +98,25 @@ Error_manager Dispatch_communicator::cancel_request(message::Dispatch_request_ms
 }
 Error_manager Dispatch_communicator::check_statu()
 {
+
+    std::chrono::system_clock::time_point time_now=std::chrono::system_clock::now();
+    auto durantion=time_now-m_dispatch_statu_time;
+    if(m_dispatch_statu_msg.has_base_info()== false
+       || durantion>std::chrono::seconds(5))
+    {
+        return Error_manager(ERROR,MINOR_ERROR,"调度节点通讯断开");
+    }
+    if(m_dispatch_statu_msg.dispatch_manager_status()==message::E_DISPATCH_MANAGER_FAULT)
+    {
+        return Error_manager(ERROR,MINOR_ERROR,"调度节点故障");
+    }
+    if(m_dispatch_statu_msg.dispatch_manager_status()==message::E_DISPATCH_MANAGER_UNKNOW)
+    {
+        return Error_manager(ERROR,MINOR_ERROR,"调度节点状态未知");
+    }
+
     return SUCCESS;
+
 }
 
 
@@ -159,7 +177,11 @@ Error_manager Dispatch_communicator::execute_msg(Communication_message* p_msg)
             ///测量系统状态
         case Communication_message::eDispatch_status_msg:
         {
-            //m_measure_statu_msg=*p_msg;
+            if(m_dispatch_statu_msg.ParseFromString(p_msg->get_message_buf())==false)
+            {
+                return Error_manager(ERROR,CRITICAL_ERROR,"调度模块状态消息解析失败");
+            }
+            m_dispatch_statu_time=std::chrono::system_clock::now();
             break;
         }
     }

+ 4 - 0
dispatch/dispatch_communicator.h

@@ -51,6 +51,10 @@ protected:
 
 private:
     thread_safe_map<message::Dispatch_request_msg,message::Dispatch_response_msg>          m_response_table;
+
+    //调度模块状态
+    message::Dispatch_status_msg                                                            m_dispatch_statu_msg;
+    std::chrono::system_clock::time_point                                                   m_dispatch_statu_time;
 };
 
 

+ 22 - 1
lidar_locate/Locate_communicator.cpp

@@ -122,6 +122,25 @@ Error_manager Locate_communicator::check_executer(Communication_message* p_msg)
 
 Error_manager Locate_communicator::check_statu()
 {
+    std::chrono::system_clock::time_point time_now=std::chrono::system_clock::now();
+    auto durantion=time_now-m_statu_recv_time;
+    if(m_measure_statu_msg.has_base_info()== false
+        || durantion>std::chrono::seconds(5))
+    {
+        return Error_manager(ERROR,MINOR_ERROR,"测量节点通讯断开");
+    }
+    if(m_measure_statu_msg.laser_manager_status()==message::LASER_MANAGER_FAULT)
+    {
+        return Error_manager(ERROR,MINOR_ERROR,"测量模块扫描控制故障");
+    }
+    for(int i=0;i<m_measure_statu_msg.laser_statu_vector_size();++i)
+    {
+        message::Laser_statu laser_statu=m_measure_statu_msg.laser_statu_vector(i);
+        if(laser_statu==message::LASER_FAULT || laser_statu==message::LASER_DISCONNECT)
+        {
+            return Error_manager(ERROR,MINOR_ERROR,"测量模块雷达故障或者断线");
+        }
+    }
     return SUCCESS;
 }
 
@@ -173,7 +192,9 @@ Error_manager Locate_communicator::execute_msg(Communication_message* p_msg)
         ///测量系统状态
         case Communication_message::eLocate_status_msg:
         {
-            m_measure_statu_msg=*p_msg;
+            if(m_measure_statu_msg.ParseFromString(p_msg->get_message_buf())==false)
+                return Error_manager(ERROR,CRITICAL_ERROR,"measure statu msg parse failed, CRITICAL_ERROR");
+            m_statu_recv_time=std::chrono::system_clock::now();
             break;
         }
     }

+ 5 - 1
lidar_locate/Locate_communicator.h

@@ -35,6 +35,7 @@ public:
     Error_manager check_statu();
 
 
+
 protected:
     Locate_communicator();
     virtual Error_manager encapsulate_msg(Communication_message* message);
@@ -58,7 +59,10 @@ protected:
 protected:
 
     thread_safe_map<message::Measure_request_msg,message::Measure_response_msg>          m_response_table;
-    Communication_message                                       m_measure_statu_msg;
+
+
+    message::Measure_status_msg                                       m_measure_statu_msg;
+    std::chrono::system_clock::time_point		                    m_statu_recv_time;
 };
 
 

+ 40 - 5
main.cpp

@@ -38,6 +38,7 @@ int main(int argc,char* argv[])
 	if(code!=SUCCESS)
     {
 	    LOG(ERROR)<<code.to_string();
+	    return 0;
     }
 
 	getchar();
@@ -48,6 +49,7 @@ int main(int argc,char* argv[])
 
 Error_manager init_communicators()
 {
+    LOG(INFO)<<"初始化通讯子节点......";
     Error_manager code;
     /*
      * 初始化各个通讯模块,
@@ -55,7 +57,7 @@ Error_manager init_communicators()
 
     if(Locate_communicator::get_instance_pointer()== nullptr)
         return FAILED;
-    code=Locate_communicator::get_instance_pointer()->communication_connect("tcp://127.0.0.1:4444");
+    code=Locate_communicator::get_instance_pointer()->communication_connect("tcp://192.168.2.192:4444");
     if(code!=SUCCESS)
     {
         return code;
@@ -78,13 +80,45 @@ Error_manager init_communicators()
     Dispatch_communicator::get_instance_pointer()->communication_connect("tcp://192.168.2.192:5555");
     Dispatch_communicator::get_instance_pointer()->communication_run();
 
-
-
     /*
-     *
      * 此处添加等待各个通讯模块正常代码
-     *
      */
+    std::chrono::system_clock::time_point t_start=std::chrono::system_clock::now();
+    std::chrono::system_clock::time_point t_end=std::chrono::system_clock::now();
+    Error_manager locate_code=ERROR,parkspace_code=ERROR,dispatch_code=ERROR;
+    do{
+        if(locate_code!=SUCCESS) {
+            locate_code = Locate_communicator::get_instance_pointer()->check_statu();
+            if (locate_code == SUCCESS) {
+                LOG(INFO) << "测量模块初始化完成!!!";
+            }
+        }
+
+        if(parkspace_code!=SUCCESS) {
+            parkspace_code = Parkspace_communicator::get_instance_pointer()->check_statu();
+            if (parkspace_code == SUCCESS) {
+                LOG(INFO) << "车位管理模块初始化完成!!!";
+            }
+        }
+
+        if(dispatch_code!=SUCCESS) {
+            dispatch_code = Dispatch_communicator::get_instance_pointer()->check_statu();
+            if (dispatch_code == SUCCESS) {
+                LOG(INFO) << "调度模块初始化完成!!!";
+            }
+        }
+
+        if(locate_code==SUCCESS && parkspace_code==SUCCESS && dispatch_code==SUCCESS)
+            break;
+        t_end=std::chrono::system_clock::now();
+        usleep(1000*200);
+    }while(t_end-t_start<std::chrono::seconds(60));
+
+    if(!(locate_code==SUCCESS && parkspace_code==SUCCESS && dispatch_code==SUCCESS))
+    {
+        LOG(INFO)<<"初始化通讯子节点超时!!!";
+        return Error_manager(ERROR,MAJOR_ERROR,"通讯节点初始化超时");
+    }
 
 
     ///最后初始化与终端通讯的对象
@@ -106,6 +140,7 @@ Error_manager init_communicators()
     }
 
     usleep(1000*3000);
+    LOG(INFO)<<"系统初始化完成 --------------------------------------------- !!!";
     return SUCCESS;
 }
 

+ 0 - 1
message/dispatch_message.proto

@@ -37,7 +37,6 @@ message Carrier_position
 message Dispatch_status_msg
 {
     required Base_info                  base_info=1;                    //消息类型
-
     required Dispatch_manager_status    dispatch_manager_status = 2;    //调度管理 的状态
  //   repeated Carrier_status             carrier_status = 3;             //搬运器状态, 楚天有3套AGV系统
 

+ 24 - 16
message/message_base.pb.cc

@@ -342,7 +342,7 @@ void AddDescriptorsImpl() {
       "\016\n\006height\030\007 \001(\002\0223\n\020parkspace_status\030\010 \001("
       "\0162\031.message.Parkspace_status\022#\n\010car_info"
       "\030\t \001(\0132\021.message.Car_info\022\022\n\nentry_time\030"
-      "\n \001(\t\022\022\n\nleave_time\030\013 \001(\t*\355\004\n\014Message_ty"
+      "\n \001(\t\022\022\n\nleave_time\030\013 \001(\t*\225\006\n\014Message_ty"
       "pe\022\r\n\teBase_msg\020\000\022\020\n\014eCommand_msg\020\001\022\026\n\022e"
       "Locate_status_msg\020\021\022\027\n\023eLocate_request_m"
       "sg\020\022\022\030\n\024eLocate_response_msg\020\023\022\030\n\024eDispa"
@@ -354,23 +354,27 @@ void AddDescriptorsImpl() {
       "ce_search_request_msg\0204\022\"\n\036eParkspace_se"
       "arch_response_msg\0205\022\"\n\036eParkspace_releas"
       "e_request_msg\0206\022#\n\037eParkspace_release_re"
-      "sponse_msg\0207\022\036\n\032eStore_command_request_m"
-      "sg\020A\022\037\n\033eStore_command_response_msg\020B\022\037\n"
-      "\033ePickup_command_request_msg\020C\022 \n\034ePicku"
-      "p_command_response_msg\020D\022\027\n\023eEntrance_st"
-      "atu_msg\020Q*f\n\014Communicator\022\n\n\006eEmpty\020\000\022\t\n"
-      "\005eMain\020\001\022\016\n\teTerminor\020\200\002\022\017\n\neParkspace\020\200"
-      "\004\022\016\n\teMeasurer\020\200\006\022\016\n\teDispatch\020\200\010*e\n\013Err"
-      "or_level\022\n\n\006NORMAL\020\000\022\024\n\020NEGLIGIBLE_ERROR"
-      "\020\001\022\017\n\013MINOR_ERROR\020\002\022\017\n\013MAJOR_ERROR\020\003\022\022\n\016"
-      "CRITICAL_ERROR\020\004*q\n\020Parkspace_status\022\024\n\020"
-      "eParkspace_empty\020\000\022\027\n\023eParkspace_occupie"
-      "d\020\001\022\030\n\024eParkspace_reserverd\020\002\022\024\n\020eParksp"
-      "ace_error\020\003*(\n\tDirection\022\014\n\010eForward\020\001\022\r"
-      "\n\teBackward\020\002"
+      "sponse_msg\0207\022\'\n#eParkspace_force_update_"
+      "request_msg\0208\022(\n$eParkspace_force_update"
+      "_response_msg\0209\022(\n$eParkspace_confirm_al"
+      "loc_request_msg\020:\022)\n%eParkspace_confirm_"
+      "alloc_response_msg\020;\022\036\n\032eStore_command_r"
+      "equest_msg\020A\022\037\n\033eStore_command_response_"
+      "msg\020B\022\037\n\033ePickup_command_request_msg\020C\022 "
+      "\n\034ePickup_command_response_msg\020D\022\027\n\023eEnt"
+      "rance_statu_msg\020Q*f\n\014Communicator\022\n\n\006eEm"
+      "pty\020\000\022\t\n\005eMain\020\001\022\016\n\teTerminor\020\200\002\022\017\n\nePar"
+      "kspace\020\200\004\022\016\n\teMeasurer\020\200\006\022\016\n\teDispatch\020\200"
+      "\010*e\n\013Error_level\022\n\n\006NORMAL\020\000\022\024\n\020NEGLIGIB"
+      "LE_ERROR\020\001\022\017\n\013MINOR_ERROR\020\002\022\017\n\013MAJOR_ERR"
+      "OR\020\003\022\022\n\016CRITICAL_ERROR\020\004*q\n\020Parkspace_st"
+      "atus\022\024\n\020eParkspace_empty\020\000\022\027\n\023eParkspace"
+      "_occupied\020\001\022\030\n\024eParkspace_reserverd\020\002\022\024\n"
+      "\020eParkspace_error\020\003*(\n\tDirection\022\014\n\010eFor"
+      "ward\020\001\022\r\n\teBackward\020\002"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 1933);
+      descriptor, 2101);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "message_base.proto", &protobuf_RegisterTypes);
 }
@@ -408,6 +412,10 @@ bool Message_type_IsValid(int value) {
     case 53:
     case 54:
     case 55:
+    case 56:
+    case 57:
+    case 58:
+    case 59:
     case 65:
     case 66:
     case 67:

+ 4 - 0
message/message_base.pb.h

@@ -102,6 +102,10 @@ enum Message_type {
   eParkspace_search_response_msg = 53,
   eParkspace_release_request_msg = 54,
   eParkspace_release_response_msg = 55,
+  eParkspace_force_update_request_msg = 56,
+  eParkspace_force_update_response_msg = 57,
+  eParkspace_confirm_alloc_request_msg = 58,
+  eParkspace_confirm_alloc_response_msg = 59,
   eStore_command_request_msg = 65,
   eStore_command_response_msg = 66,
   ePickup_command_request_msg = 67,

+ 11 - 7
message/message_base.proto

@@ -17,13 +17,17 @@ enum Message_type
     eDispatch_request_msg=0x22;              //请求调度消息
     eDispatch_response_msg=0x23;             //调度结果反馈消息
 
-    eParkspace_allocation_status_msg = 0x31;   //车位分配模块状态消息,包括车位信息
-    eParkspace_allocation_request_msg = 0x32;  //请求分配车位消息
-    eParkspace_allocation_response_msg = 0x33; //分配车位结果反馈消息
-    eParkspace_search_request_msg = 0x34;    //查询车位请求消息
-    eParkspace_search_response_msg = 0x35;    //查询车位反馈消息
-    eParkspace_release_request_msg = 0x36;    //释放车位请求消息
-    eParkspace_release_response_msg = 0x37;    //释放车位反馈消息
+    eParkspace_allocation_status_msg=0x31;  //车位分配模块状态消息,包括车位信息
+    eParkspace_allocation_request_msg=0x32; //请求分配车位消息
+    eParkspace_allocation_response_msg=0x33;//分配车位结果反馈消息
+    eParkspace_search_request_msg = 0x34;		//查询车位请求消息
+    eParkspace_search_response_msg = 0x35;		//查询车位反馈消息
+    eParkspace_release_request_msg = 0x36;		//释放车位请求消息
+    eParkspace_release_response_msg = 0x37;		//释放车位反馈消息
+    eParkspace_force_update_request_msg = 0x38;	//手动修改车位消息
+    eParkspace_force_update_response_msg = 0x39;//手动修改车位反馈消息
+    eParkspace_confirm_alloc_request_msg = 0x3A;//确认分配车位请求消息
+    eParkspace_confirm_alloc_response_msg = 0x3B;//确认分配车位反馈消息
 
 
     eStore_command_request_msg=0x41;        //终端停车请求消息

文件差异内容过多而无法显示
+ 945 - 10
message/parkspace_allocation_message.pb.cc


+ 610 - 2
message/parkspace_allocation_message.pb.h

@@ -37,7 +37,7 @@ namespace protobuf_parkspace_5fallocation_5fmessage_2eproto {
 struct TableStruct {
   static const ::google::protobuf::internal::ParseTableField entries[];
   static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
-  static const ::google::protobuf::internal::ParseTable schema[7];
+  static const ::google::protobuf::internal::ParseTable schema[9];
   static const ::google::protobuf::internal::FieldMetadata field_metadata[];
   static const ::google::protobuf::internal::SerializationTable serialization_table[];
   static const ::google::protobuf::uint32 offsets[];
@@ -55,6 +55,10 @@ void InitDefaultsParkspace_release_request_msgImpl();
 void InitDefaultsParkspace_release_request_msg();
 void InitDefaultsParkspace_release_response_msgImpl();
 void InitDefaultsParkspace_release_response_msg();
+void InitDefaultsParkspace_confirm_alloc_request_msgImpl();
+void InitDefaultsParkspace_confirm_alloc_request_msg();
+void InitDefaultsParkspace_confirm_alloc_response_msgImpl();
+void InitDefaultsParkspace_confirm_alloc_response_msg();
 void InitDefaultsParkspace_allocation_status_msgImpl();
 void InitDefaultsParkspace_allocation_status_msg();
 inline void InitDefaults() {
@@ -64,6 +68,8 @@ inline void InitDefaults() {
   InitDefaultsParkspace_search_response_msg();
   InitDefaultsParkspace_release_request_msg();
   InitDefaultsParkspace_release_response_msg();
+  InitDefaultsParkspace_confirm_alloc_request_msg();
+  InitDefaultsParkspace_confirm_alloc_response_msg();
   InitDefaultsParkspace_allocation_status_msg();
 }
 }  // namespace protobuf_parkspace_5fallocation_5fmessage_2eproto
@@ -77,6 +83,12 @@ extern Parkspace_allocation_response_msgDefaultTypeInternal _Parkspace_allocatio
 class Parkspace_allocation_status_msg;
 class Parkspace_allocation_status_msgDefaultTypeInternal;
 extern Parkspace_allocation_status_msgDefaultTypeInternal _Parkspace_allocation_status_msg_default_instance_;
+class Parkspace_confirm_alloc_request_msg;
+class Parkspace_confirm_alloc_request_msgDefaultTypeInternal;
+extern Parkspace_confirm_alloc_request_msgDefaultTypeInternal _Parkspace_confirm_alloc_request_msg_default_instance_;
+class Parkspace_confirm_alloc_response_msg;
+class Parkspace_confirm_alloc_response_msgDefaultTypeInternal;
+extern Parkspace_confirm_alloc_response_msgDefaultTypeInternal _Parkspace_confirm_alloc_response_msg_default_instance_;
 class Parkspace_release_request_msg;
 class Parkspace_release_request_msgDefaultTypeInternal;
 extern Parkspace_release_request_msgDefaultTypeInternal _Parkspace_release_request_msg_default_instance_;
@@ -962,6 +974,292 @@ class Parkspace_release_response_msg : public ::google::protobuf::Message /* @@p
 };
 // -------------------------------------------------------------------
 
+class Parkspace_confirm_alloc_request_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_confirm_alloc_request_msg) */ {
+ public:
+  Parkspace_confirm_alloc_request_msg();
+  virtual ~Parkspace_confirm_alloc_request_msg();
+
+  Parkspace_confirm_alloc_request_msg(const Parkspace_confirm_alloc_request_msg& from);
+
+  inline Parkspace_confirm_alloc_request_msg& operator=(const Parkspace_confirm_alloc_request_msg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Parkspace_confirm_alloc_request_msg(Parkspace_confirm_alloc_request_msg&& from) noexcept
+    : Parkspace_confirm_alloc_request_msg() {
+    *this = ::std::move(from);
+  }
+
+  inline Parkspace_confirm_alloc_request_msg& operator=(Parkspace_confirm_alloc_request_msg&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Parkspace_confirm_alloc_request_msg& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Parkspace_confirm_alloc_request_msg* internal_default_instance() {
+    return reinterpret_cast<const Parkspace_confirm_alloc_request_msg*>(
+               &_Parkspace_confirm_alloc_request_msg_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(Parkspace_confirm_alloc_request_msg* other);
+  friend void swap(Parkspace_confirm_alloc_request_msg& a, Parkspace_confirm_alloc_request_msg& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Parkspace_confirm_alloc_request_msg* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Parkspace_confirm_alloc_request_msg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Parkspace_confirm_alloc_request_msg& from);
+  void MergeFrom(const Parkspace_confirm_alloc_request_msg& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Parkspace_confirm_alloc_request_msg* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .message.Base_info base_info = 1;
+  bool has_base_info() const;
+  void clear_base_info();
+  static const int kBaseInfoFieldNumber = 1;
+  const ::message::Base_info& base_info() const;
+  ::message::Base_info* release_base_info();
+  ::message::Base_info* mutable_base_info();
+  void set_allocated_base_info(::message::Base_info* base_info);
+
+  // required .message.Parkspace_info confirm_space_info = 3;
+  bool has_confirm_space_info() const;
+  void clear_confirm_space_info();
+  static const int kConfirmSpaceInfoFieldNumber = 3;
+  const ::message::Parkspace_info& confirm_space_info() const;
+  ::message::Parkspace_info* release_confirm_space_info();
+  ::message::Parkspace_info* mutable_confirm_space_info();
+  void set_allocated_confirm_space_info(::message::Parkspace_info* confirm_space_info);
+
+  // required int32 command_id = 2;
+  bool has_command_id() const;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 2;
+  ::google::protobuf::int32 command_id() const;
+  void set_command_id(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:message.Parkspace_confirm_alloc_request_msg)
+ private:
+  void set_has_base_info();
+  void clear_has_base_info();
+  void set_has_command_id();
+  void clear_has_command_id();
+  void set_has_confirm_space_info();
+  void clear_has_confirm_space_info();
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::message::Base_info* base_info_;
+  ::message::Parkspace_info* confirm_space_info_;
+  ::google::protobuf::int32 command_id_;
+  friend struct ::protobuf_parkspace_5fallocation_5fmessage_2eproto::TableStruct;
+  friend void ::protobuf_parkspace_5fallocation_5fmessage_2eproto::InitDefaultsParkspace_confirm_alloc_request_msgImpl();
+};
+// -------------------------------------------------------------------
+
+class Parkspace_confirm_alloc_response_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_confirm_alloc_response_msg) */ {
+ public:
+  Parkspace_confirm_alloc_response_msg();
+  virtual ~Parkspace_confirm_alloc_response_msg();
+
+  Parkspace_confirm_alloc_response_msg(const Parkspace_confirm_alloc_response_msg& from);
+
+  inline Parkspace_confirm_alloc_response_msg& operator=(const Parkspace_confirm_alloc_response_msg& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Parkspace_confirm_alloc_response_msg(Parkspace_confirm_alloc_response_msg&& from) noexcept
+    : Parkspace_confirm_alloc_response_msg() {
+    *this = ::std::move(from);
+  }
+
+  inline Parkspace_confirm_alloc_response_msg& operator=(Parkspace_confirm_alloc_response_msg&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Parkspace_confirm_alloc_response_msg& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Parkspace_confirm_alloc_response_msg* internal_default_instance() {
+    return reinterpret_cast<const Parkspace_confirm_alloc_response_msg*>(
+               &_Parkspace_confirm_alloc_response_msg_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(Parkspace_confirm_alloc_response_msg* other);
+  friend void swap(Parkspace_confirm_alloc_response_msg& a, Parkspace_confirm_alloc_response_msg& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Parkspace_confirm_alloc_response_msg* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Parkspace_confirm_alloc_response_msg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Parkspace_confirm_alloc_response_msg& from);
+  void MergeFrom(const Parkspace_confirm_alloc_response_msg& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Parkspace_confirm_alloc_response_msg* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required .message.Base_info base_info = 1;
+  bool has_base_info() const;
+  void clear_base_info();
+  static const int kBaseInfoFieldNumber = 1;
+  const ::message::Base_info& base_info() const;
+  ::message::Base_info* release_base_info();
+  ::message::Base_info* mutable_base_info();
+  void set_allocated_base_info(::message::Base_info* base_info);
+
+  // required .message.Error_manager error_manager = 3;
+  bool has_error_manager() const;
+  void clear_error_manager();
+  static const int kErrorManagerFieldNumber = 3;
+  const ::message::Error_manager& error_manager() const;
+  ::message::Error_manager* release_error_manager();
+  ::message::Error_manager* mutable_error_manager();
+  void set_allocated_error_manager(::message::Error_manager* error_manager);
+
+  // required .message.Parkspace_info confirm_alloc_space_info = 4;
+  bool has_confirm_alloc_space_info() const;
+  void clear_confirm_alloc_space_info();
+  static const int kConfirmAllocSpaceInfoFieldNumber = 4;
+  const ::message::Parkspace_info& confirm_alloc_space_info() const;
+  ::message::Parkspace_info* release_confirm_alloc_space_info();
+  ::message::Parkspace_info* mutable_confirm_alloc_space_info();
+  void set_allocated_confirm_alloc_space_info(::message::Parkspace_info* confirm_alloc_space_info);
+
+  // required int32 command_id = 2;
+  bool has_command_id() const;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 2;
+  ::google::protobuf::int32 command_id() const;
+  void set_command_id(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:message.Parkspace_confirm_alloc_response_msg)
+ private:
+  void set_has_base_info();
+  void clear_has_base_info();
+  void set_has_command_id();
+  void clear_has_command_id();
+  void set_has_error_manager();
+  void clear_has_error_manager();
+  void set_has_confirm_alloc_space_info();
+  void clear_has_confirm_alloc_space_info();
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::message::Base_info* base_info_;
+  ::message::Error_manager* error_manager_;
+  ::message::Parkspace_info* confirm_alloc_space_info_;
+  ::google::protobuf::int32 command_id_;
+  friend struct ::protobuf_parkspace_5fallocation_5fmessage_2eproto::TableStruct;
+  friend void ::protobuf_parkspace_5fallocation_5fmessage_2eproto::InitDefaultsParkspace_confirm_alloc_response_msgImpl();
+};
+// -------------------------------------------------------------------
+
 class Parkspace_allocation_status_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Parkspace_allocation_status_msg) */ {
  public:
   Parkspace_allocation_status_msg();
@@ -1004,7 +1302,7 @@ class Parkspace_allocation_status_msg : public ::google::protobuf::Message /* @@
                &_Parkspace_allocation_status_msg_default_instance_);
   }
   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
-    6;
+    8;
 
   void Swap(Parkspace_allocation_status_msg* other);
   friend void swap(Parkspace_allocation_status_msg& a, Parkspace_allocation_status_msg& b) {
@@ -2051,6 +2349,312 @@ inline void Parkspace_release_response_msg::set_allocated_release_space_info(::m
 
 // -------------------------------------------------------------------
 
+// Parkspace_confirm_alloc_request_msg
+
+// required .message.Base_info base_info = 1;
+inline bool Parkspace_confirm_alloc_request_msg::has_base_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Parkspace_confirm_alloc_request_msg::set_has_base_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Parkspace_confirm_alloc_request_msg::clear_has_base_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::message::Base_info& Parkspace_confirm_alloc_request_msg::base_info() const {
+  const ::message::Base_info* p = base_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_confirm_alloc_request_msg.base_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
+      &::message::_Base_info_default_instance_);
+}
+inline ::message::Base_info* Parkspace_confirm_alloc_request_msg::release_base_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_confirm_alloc_request_msg.base_info)
+  clear_has_base_info();
+  ::message::Base_info* temp = base_info_;
+  base_info_ = NULL;
+  return temp;
+}
+inline ::message::Base_info* Parkspace_confirm_alloc_request_msg::mutable_base_info() {
+  set_has_base_info();
+  if (base_info_ == NULL) {
+    base_info_ = new ::message::Base_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_confirm_alloc_request_msg.base_info)
+  return base_info_;
+}
+inline void Parkspace_confirm_alloc_request_msg::set_allocated_base_info(::message::Base_info* base_info) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(base_info_);
+  }
+  if (base_info) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      base_info = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, base_info, submessage_arena);
+    }
+    set_has_base_info();
+  } else {
+    clear_has_base_info();
+  }
+  base_info_ = base_info;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_confirm_alloc_request_msg.base_info)
+}
+
+// required int32 command_id = 2;
+inline bool Parkspace_confirm_alloc_request_msg::has_command_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Parkspace_confirm_alloc_request_msg::set_has_command_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Parkspace_confirm_alloc_request_msg::clear_has_command_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Parkspace_confirm_alloc_request_msg::clear_command_id() {
+  command_id_ = 0;
+  clear_has_command_id();
+}
+inline ::google::protobuf::int32 Parkspace_confirm_alloc_request_msg::command_id() const {
+  // @@protoc_insertion_point(field_get:message.Parkspace_confirm_alloc_request_msg.command_id)
+  return command_id_;
+}
+inline void Parkspace_confirm_alloc_request_msg::set_command_id(::google::protobuf::int32 value) {
+  set_has_command_id();
+  command_id_ = value;
+  // @@protoc_insertion_point(field_set:message.Parkspace_confirm_alloc_request_msg.command_id)
+}
+
+// required .message.Parkspace_info confirm_space_info = 3;
+inline bool Parkspace_confirm_alloc_request_msg::has_confirm_space_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Parkspace_confirm_alloc_request_msg::set_has_confirm_space_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Parkspace_confirm_alloc_request_msg::clear_has_confirm_space_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::message::Parkspace_info& Parkspace_confirm_alloc_request_msg::confirm_space_info() const {
+  const ::message::Parkspace_info* p = confirm_space_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_confirm_alloc_request_msg.confirm_space_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Parkspace_info*>(
+      &::message::_Parkspace_info_default_instance_);
+}
+inline ::message::Parkspace_info* Parkspace_confirm_alloc_request_msg::release_confirm_space_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_confirm_alloc_request_msg.confirm_space_info)
+  clear_has_confirm_space_info();
+  ::message::Parkspace_info* temp = confirm_space_info_;
+  confirm_space_info_ = NULL;
+  return temp;
+}
+inline ::message::Parkspace_info* Parkspace_confirm_alloc_request_msg::mutable_confirm_space_info() {
+  set_has_confirm_space_info();
+  if (confirm_space_info_ == NULL) {
+    confirm_space_info_ = new ::message::Parkspace_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_confirm_alloc_request_msg.confirm_space_info)
+  return confirm_space_info_;
+}
+inline void Parkspace_confirm_alloc_request_msg::set_allocated_confirm_space_info(::message::Parkspace_info* confirm_space_info) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(confirm_space_info_);
+  }
+  if (confirm_space_info) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      confirm_space_info = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, confirm_space_info, submessage_arena);
+    }
+    set_has_confirm_space_info();
+  } else {
+    clear_has_confirm_space_info();
+  }
+  confirm_space_info_ = confirm_space_info;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_confirm_alloc_request_msg.confirm_space_info)
+}
+
+// -------------------------------------------------------------------
+
+// Parkspace_confirm_alloc_response_msg
+
+// required .message.Base_info base_info = 1;
+inline bool Parkspace_confirm_alloc_response_msg::has_base_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Parkspace_confirm_alloc_response_msg::set_has_base_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Parkspace_confirm_alloc_response_msg::clear_has_base_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::message::Base_info& Parkspace_confirm_alloc_response_msg::base_info() const {
+  const ::message::Base_info* p = base_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_confirm_alloc_response_msg.base_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Base_info*>(
+      &::message::_Base_info_default_instance_);
+}
+inline ::message::Base_info* Parkspace_confirm_alloc_response_msg::release_base_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_confirm_alloc_response_msg.base_info)
+  clear_has_base_info();
+  ::message::Base_info* temp = base_info_;
+  base_info_ = NULL;
+  return temp;
+}
+inline ::message::Base_info* Parkspace_confirm_alloc_response_msg::mutable_base_info() {
+  set_has_base_info();
+  if (base_info_ == NULL) {
+    base_info_ = new ::message::Base_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_confirm_alloc_response_msg.base_info)
+  return base_info_;
+}
+inline void Parkspace_confirm_alloc_response_msg::set_allocated_base_info(::message::Base_info* base_info) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(base_info_);
+  }
+  if (base_info) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      base_info = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, base_info, submessage_arena);
+    }
+    set_has_base_info();
+  } else {
+    clear_has_base_info();
+  }
+  base_info_ = base_info;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_confirm_alloc_response_msg.base_info)
+}
+
+// required int32 command_id = 2;
+inline bool Parkspace_confirm_alloc_response_msg::has_command_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Parkspace_confirm_alloc_response_msg::set_has_command_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Parkspace_confirm_alloc_response_msg::clear_has_command_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Parkspace_confirm_alloc_response_msg::clear_command_id() {
+  command_id_ = 0;
+  clear_has_command_id();
+}
+inline ::google::protobuf::int32 Parkspace_confirm_alloc_response_msg::command_id() const {
+  // @@protoc_insertion_point(field_get:message.Parkspace_confirm_alloc_response_msg.command_id)
+  return command_id_;
+}
+inline void Parkspace_confirm_alloc_response_msg::set_command_id(::google::protobuf::int32 value) {
+  set_has_command_id();
+  command_id_ = value;
+  // @@protoc_insertion_point(field_set:message.Parkspace_confirm_alloc_response_msg.command_id)
+}
+
+// required .message.Error_manager error_manager = 3;
+inline bool Parkspace_confirm_alloc_response_msg::has_error_manager() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Parkspace_confirm_alloc_response_msg::set_has_error_manager() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Parkspace_confirm_alloc_response_msg::clear_has_error_manager() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::message::Error_manager& Parkspace_confirm_alloc_response_msg::error_manager() const {
+  const ::message::Error_manager* p = error_manager_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_confirm_alloc_response_msg.error_manager)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Error_manager*>(
+      &::message::_Error_manager_default_instance_);
+}
+inline ::message::Error_manager* Parkspace_confirm_alloc_response_msg::release_error_manager() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_confirm_alloc_response_msg.error_manager)
+  clear_has_error_manager();
+  ::message::Error_manager* temp = error_manager_;
+  error_manager_ = NULL;
+  return temp;
+}
+inline ::message::Error_manager* Parkspace_confirm_alloc_response_msg::mutable_error_manager() {
+  set_has_error_manager();
+  if (error_manager_ == NULL) {
+    error_manager_ = new ::message::Error_manager;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_confirm_alloc_response_msg.error_manager)
+  return error_manager_;
+}
+inline void Parkspace_confirm_alloc_response_msg::set_allocated_error_manager(::message::Error_manager* error_manager) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(error_manager_);
+  }
+  if (error_manager) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      error_manager = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, error_manager, submessage_arena);
+    }
+    set_has_error_manager();
+  } else {
+    clear_has_error_manager();
+  }
+  error_manager_ = error_manager;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_confirm_alloc_response_msg.error_manager)
+}
+
+// required .message.Parkspace_info confirm_alloc_space_info = 4;
+inline bool Parkspace_confirm_alloc_response_msg::has_confirm_alloc_space_info() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Parkspace_confirm_alloc_response_msg::set_has_confirm_alloc_space_info() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Parkspace_confirm_alloc_response_msg::clear_has_confirm_alloc_space_info() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::message::Parkspace_info& Parkspace_confirm_alloc_response_msg::confirm_alloc_space_info() const {
+  const ::message::Parkspace_info* p = confirm_alloc_space_info_;
+  // @@protoc_insertion_point(field_get:message.Parkspace_confirm_alloc_response_msg.confirm_alloc_space_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::message::Parkspace_info*>(
+      &::message::_Parkspace_info_default_instance_);
+}
+inline ::message::Parkspace_info* Parkspace_confirm_alloc_response_msg::release_confirm_alloc_space_info() {
+  // @@protoc_insertion_point(field_release:message.Parkspace_confirm_alloc_response_msg.confirm_alloc_space_info)
+  clear_has_confirm_alloc_space_info();
+  ::message::Parkspace_info* temp = confirm_alloc_space_info_;
+  confirm_alloc_space_info_ = NULL;
+  return temp;
+}
+inline ::message::Parkspace_info* Parkspace_confirm_alloc_response_msg::mutable_confirm_alloc_space_info() {
+  set_has_confirm_alloc_space_info();
+  if (confirm_alloc_space_info_ == NULL) {
+    confirm_alloc_space_info_ = new ::message::Parkspace_info;
+  }
+  // @@protoc_insertion_point(field_mutable:message.Parkspace_confirm_alloc_response_msg.confirm_alloc_space_info)
+  return confirm_alloc_space_info_;
+}
+inline void Parkspace_confirm_alloc_response_msg::set_allocated_confirm_alloc_space_info(::message::Parkspace_info* confirm_alloc_space_info) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(confirm_alloc_space_info_);
+  }
+  if (confirm_alloc_space_info) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      confirm_alloc_space_info = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, confirm_alloc_space_info, submessage_arena);
+    }
+    set_has_confirm_alloc_space_info();
+  } else {
+    clear_has_confirm_alloc_space_info();
+  }
+  confirm_alloc_space_info_ = confirm_alloc_space_info;
+  // @@protoc_insertion_point(field_set_allocated:message.Parkspace_confirm_alloc_response_msg.confirm_alloc_space_info)
+}
+
+// -------------------------------------------------------------------
+
 // Parkspace_allocation_status_msg
 
 // required .message.Base_info base_info = 1;
@@ -2195,6 +2799,10 @@ Parkspace_allocation_status_msg::parkspace_info() const {
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 

+ 16 - 0
message/parkspace_allocation_message.proto

@@ -54,6 +54,22 @@ message Parkspace_release_response_msg
     required Parkspace_info             release_space_info=4;   //待释放车位信息
 }
 
+// 5.确定占用车位请求消息
+message Parkspace_confirm_alloc_request_msg
+{
+    required Base_info                  base_info=1;            //消息类型
+    required int32                      command_id=2;           //指令唯一标识符id
+    required Parkspace_info             confirm_space_info=3;    //已修改后的车位信息
+}
+//确定占用车位反馈消息
+message Parkspace_confirm_alloc_response_msg
+{
+    required Base_info                  base_info=1;            //消息类型
+    required int32                      command_id=2;           //指令唯一标识符id
+    required Error_manager              error_manager=3;        //分配成功与否标志
+    required Parkspace_info             confirm_alloc_space_info=4;    //已修改后的车位信息
+}
+
 // 车位心跳状态信息
 message Parkspace_allocation_status_msg
 {

+ 135 - 8
parkspace/Parkspace_communicator.cpp

@@ -15,10 +15,10 @@ Error_manager Parkspace_communicator::alloc_request(message::Parkspace_allocatio
      * 检查request合法性,以及模块状态
      */
     if(request.base_info().sender()!=message::eMain||request.base_info().receiver()!=message::eParkspace)
-        return Error_manager(PARKSPACE_ALLOC_REQUEST_INVALID,MINOR_ERROR,"parkspace alloc request invalid");
+        return Error_manager(PARKSPACE_ALLOC_REQUEST_INVALID,MINOR_ERROR,"车位分配请求信息错误!!!");
 
     if(m_alloc_table.find(request)==true)
-        return Error_manager(PARKSPACE_ALLOC_REQUEST_REPEATED,MAJOR_ERROR," parkspace alloc request repeated");
+        return Error_manager(PARKSPACE_ALLOC_REQUEST_REPEATED,MINOR_ERROR,"车位分配请求已经存在,重复!!!");
     //设置超时,若没有设置,默认1000
     int timeout=request.base_info().has_timeout_ms()?request.base_info().timeout_ms():1000;
     //向测量节点发送测量请求,并记录请求
@@ -51,14 +51,14 @@ Error_manager Parkspace_communicator::alloc_request(message::Parkspace_allocatio
                 message::Base_info response_base = response.base_info();
                 //检查类型是否匹配
                 if (response_base.msg_type() != message::eParkspace_allocation_response_msg) {
-                    return Error_manager(PARKSPACE_ALLOC_RESPONSE_TYPE_ERROR, MAJOR_ERROR,
+                    return Error_manager(PARKSPACE_ALLOC_RESPONSE_TYPE_ERROR, MINOR_ERROR,
                                          "parkspace alloc response msg type error");
                 }
                 //检查基本信息是否匹配
                 if (response_base.sender() != message::eParkspace ||
                     response_base.receiver() != message::eMain ||
                     response.command_id() != request.command_id()) {
-                    return Error_manager(PARKSPACE_ALLOC_RESPONSE_INFO_ERROR, MAJOR_ERROR,
+                    return Error_manager(PARKSPACE_ALLOC_RESPONSE_INFO_ERROR, MINOR_ERROR,
                                          "parkspace alloc response msg info error");
                 }
                 result = response;
@@ -71,7 +71,7 @@ Error_manager Parkspace_communicator::alloc_request(message::Parkspace_allocatio
         else
         {
             //未查询到记录,任务已经被提前取消,记录被删除
-            return Error_manager(PARKSPACE_ALLOC_REQUEST_CANCELED,MINOR_ERROR,"parkspace alloc request canceled");
+            return Error_manager(PARKSPACE_ALLOC_REQUEST_CANCELED,MINOR_ERROR,"分配车位请求提前取消!!!");
         }
 
         auto end_time=std::chrono::system_clock::now();
@@ -250,9 +250,91 @@ Error_manager Parkspace_communicator::release_request(message::Parkspace_release
     return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"parkspace release request timeout");
 }
 
+/*
+     * 确认占用车位消息
+     */
+Error_manager Parkspace_communicator::confirm_request(message::Parkspace_confirm_alloc_request_msg& request,
+        message::Parkspace_confirm_alloc_response_msg& result)
+{
+    /*
+    * 检查request合法性,以及模块状态
+    */
+    if(request.base_info().sender()!=message::eMain||request.base_info().receiver()!=message::eParkspace)
+        return Error_manager(FAILED,MINOR_ERROR,"parkspace confirm request invalid");
+
+    if(m_confirm_table.find(request)==true)
+        return Error_manager(FAILED,MAJOR_ERROR," parkspace confirm request repeated");
+    //设置超时,若没有设置,默认1000
+    int timeout=request.base_info().has_timeout_ms()?request.base_info().timeout_ms():1000;
+    //向测量节点发送测量请求,并记录请求
+
+    Error_manager code;
+    Communication_message message;
+    message.reset(request.base_info(),request.SerializeAsString());
+
+    code=encapsulate_msg(&message);
+    if(code!=SUCCESS)
+        return code;
+    //循环查询请求是否被处理
+    auto start_time=std::chrono::system_clock::now();
+    double time=0;
+    do{
+        //查询到记录
+        message::Parkspace_confirm_alloc_response_msg response;
+        ///查询是否存在,并且删除该记录,
+        if(m_confirm_table.find(request,response))
+        {
+            //判断是否接收到回应,若回应信息被赋值则证明有回应
+            if (response.has_base_info() && response.has_command_id())
+            {
+                message::Base_info response_base = response.base_info();
+                //检查类型是否匹配
+                if (response_base.msg_type() != message::eParkspace_confirm_alloc_response_msg) {
+                    return Error_manager(PARKSPACE_RELEASE_RESPONSE_TYPE_ERROR, MAJOR_ERROR,
+                                         "parkspace confirm response msg type error");
+                }
+                //检查基本信息是否匹配
+                if (response_base.sender() != message::eParkspace ||
+                    response_base.receiver() != message::eMain ||
+                    response.command_id() != request.command_id()) {
+                    return Error_manager(PARKSPACE_RELEASE_RESPONSE_INFO_ERROR, MAJOR_ERROR,
+                                         "parkspace confirm response msg info error");
+                }
+                result = response;
+                m_confirm_table.erase(request);
+
+                return SUCCESS;
+
+            }
+        }
+        else
+        {
+            //未查询到记录,任务已经被提前取消,记录被删除
+            return Error_manager(FAILED,MINOR_ERROR,"parkspace confirm request canceled");
+        }
+
+        auto end_time=std::chrono::system_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
+        time=1000.0*double(duration.count()) * std::chrono::microseconds::period::num / std::chrono::microseconds::period::den;
+        std::this_thread::yield();
+        usleep(1000);
+    }while(time<double(timeout));
+    //超时,删除记录,返回错误
+    m_confirm_table.erase(request);
+    return Error_manager(RESPONSE_TIMEOUT,MINOR_ERROR,"parkspace confirm request timeout");
+}
 
 Error_manager Parkspace_communicator::check_statu()
 {
+    //return SUCCESS;
+    std::chrono::system_clock::time_point time_now=std::chrono::system_clock::now();
+    auto durantion=time_now-m_parkspace_statu_time;
+    if(m_parkspace_status_msg.has_base_info()== false
+       || durantion>std::chrono::seconds(2))
+    {
+        return Error_manager(ERROR,MINOR_ERROR,"车位管理节点通讯断开");
+    }
+
     return SUCCESS;
 }
 
@@ -307,8 +389,22 @@ Error_manager Parkspace_communicator::encapsulate_msg(Communication_message* mes
             }
             break;
         }
+        case Communication_message::eParkspace_confirm_alloc_request_msg:
+        {
+            message::Parkspace_confirm_alloc_request_msg request;
+            request.ParseFromString(message->get_message_buf());
+            //记录数据
+            m_confirm_table[request]=message::Parkspace_confirm_alloc_response_msg();
+            //发送请求
+            code= Communication_socket_base::encapsulate_msg(message);
+            if(code!=SUCCESS)
+            {
+                m_confirm_table.erase(request);
+            }
+            break;
+        }
         default:
-            code= Error_manager(PARKSPACE_REQUEST_MSG_TYPE_ERROR,NEGLIGIBLE_ERROR,"parkspace message table is not exist");
+            code= Error_manager(PARKSPACE_REQUEST_MSG_TYPE_ERROR,NEGLIGIBLE_ERROR,"不存在该类型消息的发送处理!!!");
     }
     return code;
 
@@ -363,10 +459,27 @@ Error_manager Parkspace_communicator::execute_msg(Communication_message* p_msg)
             }
             break;
         }
+
+        case Communication_message::eParkspace_confirm_alloc_response_msg:
+        {
+            message::Parkspace_confirm_alloc_response_msg response;
+            response.ParseFromString(p_msg->get_message_buf());
+            message::Parkspace_confirm_alloc_request_msg request=create_request_by_response(response);
+            ///查询请求表是否存在,并且更新
+            if(m_confirm_table.find_update(request,response)==true)
+            {
+                return SUCCESS;
+            }
+            break;
+        }
             ///测量系统状态
         case Communication_message::eParkspace_allocation_status_msg:
         {
-            m_parkspace_status_msg=*p_msg;
+            if(m_parkspace_status_msg.ParseFromString(p_msg->get_message_buf())==false)
+            {
+                return Error_manager(ERROR,CRITICAL_ERROR,"车位管理模块状态消息解析失败");
+            }
+            m_parkspace_statu_time=std::chrono::system_clock::now();
             break;
         }
     }
@@ -383,7 +496,8 @@ Error_manager Parkspace_communicator::check_msg(Communication_message* p_msg)
     if ( (p_msg->get_message_type() == Communication_message::Message_type::eParkspace_allocation_response_msg
         ||p_msg->get_message_type() == Communication_message::Message_type::eParkspace_search_response_msg
         ||p_msg->get_message_type() == Communication_message::Message_type::eParkspace_release_response_msg
-        ||p_msg->get_message_type() == Communication_message::Message_type::eParkspace_allocation_status_msg)
+        ||p_msg->get_message_type() == Communication_message::Message_type::eParkspace_allocation_status_msg
+        ||p_msg->get_message_type()==Communication_message::eParkspace_confirm_alloc_response_msg)
          && p_msg->get_receiver() == Communication_message::Communicator::eMain
          && p_msg->get_sender() == Communication_message::Communicator::eTable)
     {
@@ -452,4 +566,17 @@ Parkspace_communicator::create_request_by_response(message::Parkspace_release_re
     request.mutable_base_info()->CopyFrom(baseInfo);
     request.set_command_id(response.command_id());
     return request;
+}
+
+message::Parkspace_confirm_alloc_request_msg
+Parkspace_communicator::create_request_by_response(message::Parkspace_confirm_alloc_response_msg& response)
+{
+    message::Parkspace_confirm_alloc_request_msg request;
+    message::Base_info baseInfo;
+    baseInfo.set_msg_type(message::eParkspace_confirm_alloc_request_msg);
+    baseInfo.set_sender(response.base_info().sender());
+    baseInfo.set_receiver(response.base_info().receiver());
+    request.mutable_base_info()->CopyFrom(baseInfo);
+    request.set_command_id(response.command_id());
+    return request;
 }

+ 11 - 1
parkspace/Parkspace_communicator.h

@@ -18,6 +18,7 @@
 RegistoryCompare(message,message::Parkspace_allocation_request_msg);
 RegistoryCompare(message,message::Parkspace_search_request_msg)
 RegistoryCompare(message,message::Parkspace_release_request_msg)
+RegistoryCompare(message,Parkspace_confirm_alloc_request_msg)
 
 
 class Parkspace_communicator :public Singleton<Parkspace_communicator>, public Communication_socket_base
@@ -40,6 +41,11 @@ public:
      */
     Error_manager release_request(message::Parkspace_release_request_msg& request,message::Parkspace_release_response_msg& response);
 
+    /*
+     * 确认占用车位消息
+     */
+    Error_manager confirm_request(message::Parkspace_confirm_alloc_request_msg& request,message::Parkspace_confirm_alloc_response_msg& response);
+
     Error_manager check_statu();
 
 protected:
@@ -63,14 +69,18 @@ protected:
     message::Parkspace_allocation_request_msg create_request_by_response(message::Parkspace_allocation_response_msg& msg);
     message::Parkspace_search_request_msg create_request_by_response(message::Parkspace_search_response_msg& msg);
     message::Parkspace_release_request_msg create_request_by_response(message::Parkspace_release_response_msg& msg);
+    message::Parkspace_confirm_alloc_request_msg create_request_by_response(message::Parkspace_confirm_alloc_response_msg& msg);
+
 
 
 protected:
     thread_safe_map<message::Parkspace_allocation_request_msg,message::Parkspace_allocation_response_msg>       m_alloc_table;
     thread_safe_map<message::Parkspace_search_request_msg,message::Parkspace_search_response_msg>               m_search_table;
     thread_safe_map<message::Parkspace_release_request_msg,message::Parkspace_release_response_msg>             m_release_table;
+    thread_safe_map<message::Parkspace_confirm_alloc_request_msg,message::Parkspace_confirm_alloc_response_msg>     m_confirm_table;
 
-    Communication_message                               m_parkspace_status_msg;
+    message::Parkspace_allocation_status_msg                                                                    m_parkspace_status_msg;
+    std::chrono::system_clock::time_point                                                                       m_parkspace_statu_time;
 };
 
 

+ 21 - 2
system/PickupProcessTask.cpp

@@ -32,10 +32,18 @@ Error_manager PickupProcessTask::search_space()
         return Error_manager(INVALID_MESSAGE,CRITICAL_ERROR,"查询车位请求汽车信息错误");
     }
 
+    /*
+     * 检查车位管理模块是否正常
+     */
+    Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
+    if(code!=SUCCESS)
+        return code;
+
     message::Base_info base_info;
     base_info.set_msg_type(message::eParkspace_search_request_msg);
     base_info.set_sender(message::eMain);
     base_info.set_receiver(message::eParkspace);
+    base_info.set_timeout_ms(1000);
 
     message::Parkspace_search_request_msg request;
     request.set_command_id(m_command_id);
@@ -110,6 +118,11 @@ Error_manager PickupProcessTask::pickup_step()
         return Error_manager(FAILED,MINOR_ERROR," 取车流程释放车位请求缺少车位信息");
     }
 
+    //2,判断调度节点状态
+    Error_manager code=Dispatch_communicator::get_instance_pointer()->check_statu();
+    if(code!=SUCCESS)
+        return code;
+
     message::Dispatch_request_msg request;
     message::Base_info base_info;
     base_info.set_msg_type(message::eDispatch_request_msg);
@@ -126,7 +139,7 @@ Error_manager PickupProcessTask::pickup_step()
 
 
     message::Dispatch_response_msg response;
-    Error_manager code=Dispatch_communicator::get_instance_pointer()->dispatch_request(request,response);
+    code=Dispatch_communicator::get_instance_pointer()->dispatch_request(request,response);
     if(code!=SUCCESS)
         return code;
 
@@ -158,6 +171,12 @@ Error_manager PickupProcessTask::release_space_step()
     {
         return Error_manager(FAILED,MINOR_ERROR," 取车流程释放车位请求缺少车位信息");
     }
+    /*
+     * 检查车位管理模块是否正常
+     */
+    Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
+    if(code!=SUCCESS)
+        return code;
 
     message::Parkspace_release_request_msg request;
     message::Base_info base_info;
@@ -174,7 +193,7 @@ Error_manager PickupProcessTask::release_space_step()
 
 
     message::Parkspace_release_response_msg release_response;
-    Error_manager code=Parkspace_communicator::get_instance_pointer()->release_request(request,release_response);
+    code=Parkspace_communicator::get_instance_pointer()->release_request(request,release_response);
     if(code!=SUCCESS)
         return code;
 

+ 97 - 6
system/StoreProcessTask.cpp

@@ -32,6 +32,12 @@ Error_manager StoreProcessTask::init_task(unsigned int command_id, unsigned int
 }
 
 Error_manager StoreProcessTask::locate_step() {
+    Error_manager code;
+    //检查测量模块状态
+    code=Locate_communicator::get_instance_pointer()->check_statu();
+    if(code!=SUCCESS)
+        return code;
+
     message::Measure_request_msg request;
     message::Base_info base_info;
     base_info.set_msg_type(message::eLocate_request_msg);
@@ -43,7 +49,7 @@ Error_manager StoreProcessTask::locate_step() {
     request.set_command_id(m_command_id);
     request.set_terminal_id(m_terminor_id);
 
-    Error_manager code=Locate_communicator::get_instance_pointer()->locate_request(request,m_measure_response_msg);
+    code=Locate_communicator::get_instance_pointer()->locate_request(request,m_measure_response_msg);
     if(code!=SUCCESS)
         return code;
 
@@ -60,6 +66,7 @@ Error_manager StoreProcessTask::locate_step() {
 */
 Error_manager StoreProcessTask::dispatch_step()
 {
+    Error_manager code;
     /*
      * 判断调度所需的数据是否都正常
      */
@@ -72,6 +79,11 @@ Error_manager StoreProcessTask::dispatch_step()
         return Error_manager(ERROR,MAJOR_ERROR,"调度所需的前置数据(测量,车位)不存在");
     }
 
+    //2,判断调度节点状态
+    code=Dispatch_communicator::get_instance_pointer()->check_statu();
+    if(code!=SUCCESS)
+        return code;
+
     message::Dispatch_request_msg request;
     message::Base_info base_info;
     base_info.set_msg_type(message::eDispatch_request_msg);
@@ -85,7 +97,7 @@ Error_manager StoreProcessTask::dispatch_step()
     request.set_dispatch_motion_direction(message::E_STORE_CAR);
     request.set_parkspace_id(m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id());
 
-    Error_manager code=Dispatch_communicator::get_instance_pointer()->dispatch_request(request,m_dispatch_response_msg);
+    code=Dispatch_communicator::get_instance_pointer()->dispatch_request(request,m_dispatch_response_msg);
     if(code!=SUCCESS)
         return code;
 
@@ -106,8 +118,14 @@ Error_manager StoreProcessTask::alloc_space()
      */
     if(m_locate_info.has_locate_height()==false||m_locate_info.has_locate_width()==false)
     {
-        return Error_manager(FAILED,MINOR_ERROR," parkspace alloc request without measure info");
+        return Error_manager(FAILED,MINOR_ERROR,"停车请求缺少车辆高度和宽度信息");
     }
+    /*
+     * 检查车位管理模块是否正常
+     */
+    Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
+    if(code!=SUCCESS)
+        return code;
 
     message::Parkspace_allocation_request_msg request;
     message::Base_info base_info;
@@ -122,7 +140,7 @@ Error_manager StoreProcessTask::alloc_space()
     request.set_command_id(m_command_id);
     request.set_terminal_id(m_terminor_id);
 
-    Error_manager code=Parkspace_communicator::get_instance_pointer()->alloc_request(request,m_parcspace_alloc_response_msg);
+    code=Parkspace_communicator::get_instance_pointer()->alloc_request(request,m_parcspace_alloc_response_msg);
     if(code!=SUCCESS)
         return code;
 
@@ -139,6 +157,62 @@ Error_manager StoreProcessTask::alloc_space()
         return Error_manager(FAILED,MINOR_ERROR,"parkspace alloc response error_code error");
 }
 
+/*
+ * 车位占用确认
+ */
+Error_manager StoreProcessTask::confirm_space_step()
+{
+    /*
+    * 检查是否曾经分配过车位
+    */
+    if(m_parcspace_alloc_response_msg.has_allocated_space_info()==false)
+    {
+        return Error_manager(FAILED,MINOR_ERROR," parkspace confirm request without space info");
+    }
+
+    /*
+     * 检查车位管理模块是否正常
+     */
+    Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
+    if(code!=SUCCESS)
+        return code;
+
+    message::Parkspace_confirm_alloc_request_msg request;
+    message::Base_info base_info;
+    base_info.set_msg_type(message::eParkspace_confirm_alloc_request_msg);
+    base_info.set_sender(message::eMain);
+    base_info.set_receiver(message::eParkspace);
+    base_info.set_timeout_ms(1000); //测量超时1s
+    request.mutable_base_info()->CopyFrom(base_info);
+
+    message::Parkspace_info space_info=m_parcspace_alloc_response_msg.allocated_space_info();
+    request.mutable_confirm_space_info()->CopyFrom(space_info);
+    request.set_command_id(m_command_id);
+
+
+    message::Parkspace_confirm_alloc_response_msg confirm_response;
+    code=Parkspace_communicator::get_instance_pointer()->confirm_request(request,confirm_response);
+    if(code!=SUCCESS)
+        return code;
+
+    if(m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id()!=
+            confirm_response.confirm_alloc_space_info().parkspace_id())
+    {
+        return Error_manager(ERROR,MINOR_ERROR,"占用车位与分配车位不一致");
+    }
+
+    if(confirm_response.error_manager().error_code()==0) {
+        LOG(INFO)<<"停车流程正常,确认占用车位成功,停车终端:"<<m_terminor_id
+                    <<", 指令id:"<<m_command_id
+                    <<", 车位楼层:"<<confirm_response.confirm_alloc_space_info().floor()
+                    <<", 车位序号:"<<confirm_response.confirm_alloc_space_info().index()
+                    <<", 车牌号:"<<confirm_response.confirm_alloc_space_info().car_info().license();
+        return SUCCESS;
+    }
+    else
+        return Error_manager(FAILED,MINOR_ERROR,"parkspace confirm response error_code error");
+}
+
 /*
  * 车位解锁,当停车失败时需要车位解锁
  */
@@ -152,6 +226,13 @@ Error_manager StoreProcessTask::release_space_step()
         return Error_manager(FAILED,MINOR_ERROR," parkspace release request without space info");
     }
 
+    /*
+     * 检查车位管理模块是否正常
+     */
+    Error_manager code=Parkspace_communicator::get_instance_pointer()->check_statu();
+    if(code!=SUCCESS)
+        return code;
+
     message::Parkspace_release_request_msg request;
     message::Base_info base_info;
     base_info.set_msg_type(message::eParkspace_release_request_msg);
@@ -167,12 +248,12 @@ Error_manager StoreProcessTask::release_space_step()
 
 
     message::Parkspace_release_response_msg release_response;
-    Error_manager code=Parkspace_communicator::get_instance_pointer()->release_request(request,release_response);
+    code=Parkspace_communicator::get_instance_pointer()->release_request(request,release_response);
     if(code!=SUCCESS)
         return code;
 
     if(release_response.error_manager().error_code()==0) {
-        LOG(ERROR)<<"停车流程异常,释放车位成功,停车终端:"<<m_terminor_id
+        LOG(WARNING)<<"停车流程异常,释放车位成功,停车终端:"<<m_terminor_id
                  <<", 指令id:"<<m_command_id
                  <<", 车位楼层:"<<m_parcspace_alloc_response_msg.allocated_space_info().floor()
                  <<", 车位序号:"<<m_parcspace_alloc_response_msg.allocated_space_info().index()
@@ -218,6 +299,16 @@ void StoreProcessTask::Main()
         case 2:
         {
             ////
+            code=confirm_space_step();
+            if(code!=SUCCESS)
+            {
+                LOG(ERROR)<<"停车流程:"<<code.to_string();
+                break;
+            }
+        }
+        //第四步,更新状态
+        case 3:
+        {
             Command_manager::get_instance_pointer()->updata_store_entrance_statu(m_terminor_id,message::eReady);
             LOG(INFO)<<"停车成功,停车终端:"<<m_terminor_id<<"指令id:"<<m_command_id
                      <<", 车位id:"<<m_parcspace_alloc_response_msg.allocated_space_info().parkspace_id()

+ 5 - 0
system/StoreProcessTask.h

@@ -36,6 +36,11 @@ protected:
      */
     Error_manager dispatch_step();
 
+    /*
+     * 车位占用确认
+     */
+    Error_manager confirm_space_step();
+
    /*
     * 车位解锁,当停车失败时需要车位解锁
     */

+ 2 - 2
test/terminal_client.cpp

@@ -85,7 +85,7 @@ int main() {
     threadsafe_queue<message::Car_info> input_queue;
     threadsafe_queue<message::Car_info> output_queue;
 
-    const int n_input=2;
+    const int n_input=1;
     const int n_output=2;
     std::vector<store_terminal*> input_terminals;
     std::vector<pickup_terminal*> output_terminals;
@@ -123,7 +123,7 @@ int main() {
         int out_count=output_queue.size();
 
         //暂停 5-15s 代替
-        int delay=in_count*200;
+        int delay=10*1000;//in_count*200;
         usleep(1000*delay+1);
         std::this_thread::yield();
     }