parkspace message changes. three requests has been tested.

communication/communication_message.h

@@ -36,6 +36,10 @@ public:
 		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,		//释放车位反馈消息
 	};
 
 	//通讯单元

message/message_base.pb.cc

@@ -236,20 +236,27 @@ void AddDescriptorsImpl() {
       "\030\004 \001(\002\022\024\n\014locate_width\030\005 \001(\002\022\025\n\rlocate_h"
       "eight\030\006 \001(\002\022\031\n\021locate_wheel_base\030\007 \001(\002\022\032"
       "\n\022locate_wheel_width\030\010 \001(\002\022\026\n\016locate_cor"
-      "rect\030\t \001(\010*\307\001\n\014Message_type\022\r\n\teBase_msg"
+      "rect\030\t \001(\010*\314\003\n\014Message_type\022\r\n\teBase_msg"
       "\020\000\022\020\n\014eCommand_msg\020\001\022\026\n\022eLocate_status_m"
       "sg\020\021\022\027\n\023eLocate_request_msg\020\022\022\030\n\024eLocate"
       "_response_msg\020\023\022\026\n\022eHarware_statu_msg\020!\022"
       "\030\n\024eExecute_request_msg\020\"\022\031\n\025eExecute_re"
-      "sponse_msg\020#*a\n\014Communicator\022\n\n\006eEmpty\020\000"
-      "\022\t\n\005eMain\020\001\022\016\n\teTerminor\020\200\002\022\013\n\006eTable\020\200\004"
-      "\022\016\n\teMeasurer\020\200\006\022\r\n\010eProcess\020\200\010*e\n\013Error"
-      "_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\016CR"
-      "ITICAL_ERROR\020\004"
+      "sponse_msg\020#\022$\n eParkspace_allocation_st"
+      "atus_msg\0201\022%\n!eParkspace_allocation_requ"
+      "est_msg\0202\022&\n\"eParkspace_allocation_respo"
+      "nse_msg\0203\022!\n\035eParkspace_search_request_m"
+      "sg\0204\022\"\n\036eParkspace_search_response_msg\0205"
+      "\022\"\n\036eParkspace_release_request_msg\0206\022#\n\037"
+      "eParkspace_release_response_msg\0207*o\n\014Com"
+      "municator\022\n\n\006eEmpty\020\000\022\t\n\005eMain\020\001\022\016\n\teTer"
+      "minor\020\200\002\022\031\n\024eParkspace_allocator\020\200\004\022\016\n\te"
+      "Measurer\020\200\006\022\r\n\010eProcess\020\200\010*e\n\013Error_leve"
+      "l\022\n\n\006NORMAL\020\000\022\024\n\020NEGLIGIBLE_ERROR\020\001\022\017\n\013M"
+      "INOR_ERROR\020\002\022\017\n\013MAJOR_ERROR\020\003\022\022\n\016CRITICA"
+      "L_ERROR\020\004"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 974);
+      descriptor, 1249);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "message_base.proto", &protobuf_RegisterTypes);
 }
@@ -280,6 +287,13 @@ bool Message_type_IsValid(int value) {
     case 33:
     case 34:
     case 35:
+    case 49:
+    case 50:
+    case 51:
+    case 52:
+    case 53:
+    case 54:
+    case 55:
       return true;
     default:
       return false;

message/message_base.pb.h

@@ -85,11 +85,15 @@ enum Message_type {
   eExecute_response_msg = 35,
   eParkspace_allocation_status_msg = 49,
   eParkspace_allocation_request_msg = 50,
-  eParkspace_allocation_response_msg = 51
+  eParkspace_allocation_response_msg = 51,
+  eParkspace_search_request_msg = 52,
+  eParkspace_search_response_msg = 53,
+  eParkspace_release_request_msg = 54,
+  eParkspace_release_response_msg = 55
 };
 bool Message_type_IsValid(int value);
 const Message_type Message_type_MIN = eBase_msg;
-const Message_type Message_type_MAX = eParkspace_allocation_response_msg;
+const Message_type Message_type_MAX = eParkspace_release_response_msg;
 const int Message_type_ARRAYSIZE = Message_type_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* Message_type_descriptor();

message/message_base.proto

@@ -20,6 +20,10 @@ enum Message_type
     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;		//释放车位反馈消息
 }
 
 //通讯单元

message/parkspace_allocation_message.proto

@@ -87,7 +87,6 @@ message Parkspace_release_request_msg
     required Base_info                  base_info=1;            //消息类型
     required int32                      command_id=2;           //指令唯一标识符id
     required Parkspace_info             release_space_info=3;   //待释放车位信息
-    required Car_info                   car_info=4;              //待释放车辆凭证号
 }
 
 //查询车辆位置反馈
@@ -96,6 +95,7 @@ message Parkspace_release_response_msg
     required Base_info                  base_info=1;            //消息类型
     required int32                      command_id=2;           //指令唯一标识符id
     required Error_manager              error_manager=3;        //分配成功与否标志
+    required Parkspace_info             release_space_info=4;   //待释放车位信息
 }
 
 // 车位心跳状态信息

parkspace_allocation/parkspace_allocation_communicator.cpp

@@ -14,7 +14,7 @@ Parkspace_allocation_communicator::~Parkspace_allocation_communicator()
 
 //************************************* 公有函数 ****************************************
 //外部调用发送分配车位结果
-Error_manager Parkspace_allocation_communicator::send_allocation_result(Communication_message *message)
+Error_manager Parkspace_allocation_communicator::send_response(Communication_message *message)
 {
     return encapsulate_msg(message);
 }
@@ -55,18 +55,28 @@ Error_manager Parkspace_allocation_communicator::encapsulate_msg(Communication_m
     {
         return Error_manager(POINTER_IS_NULL, NEGLIGIBLE_ERROR, "Parkspace_allocation_communicator::message null pointer");
     }
-    //记录请求
-    if (message->get_message_type() == Communication_message::eParkspace_allocation_response_msg)
+    //针对待发送的不同反馈消息，分别进行校核
+    switch(message->get_message_type())
     {
-        message::Parkspace_allocation_response_msg response;
-        bool result = response.ParseFromString(message->get_message_buf());
-        //可增加待发送分配车位反馈消息校核
-        
-    }
-    else
-    {
-        return Error_manager(PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR, NEGLIGIBLE_ERROR, "Parkspace_allocation_communicator::message response type error");
+        case Communication_message::eParkspace_allocation_response_msg:
+        {
+            message::Parkspace_allocation_response_msg response;
+            bool result = response.ParseFromString(message->get_message_buf());
+            //可增加待发送分配车位反馈消息校核
+            break;
+        }
+        case Communication_message::eParkspace_search_response_msg:
+        {
+            break;
+        }
+        case Communication_message::eParkspace_release_response_msg:
+        {
+            break;
+        }
+        default:
+            return Error_manager(PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR, NEGLIGIBLE_ERROR, "Parkspace_allocation_communicator::message response type error");
     }
+
     //发送请求
     return Communication_socket_base::encapsulate_msg(message);
 }
@@ -84,44 +94,127 @@ Error_manager Parkspace_allocation_communicator::execute_msg(Communication_messa
         {
             message::Parkspace_allocation_request_msg request;
             request.ParseFromString(p_msg->get_message_buf());
+            std::cout<<"allocation request, car license: "<<request.car_info().license()<<std::endl;
+
             //根据请求的信息反馈分配的车位,并封装发送
-            //此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试
-            Communication_message* response=new Communication_message();
+            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
             message::Parkspace_allocation_response_msg response_msg;
             message::Base_info t_response_header;
             message::Error_manager t_error;
+            message::Parkspace_info t_allocated_space;
             t_response_header.set_msg_type(message::Message_type::eParkspace_allocation_response_msg);
             t_response_header.set_timeout_ms(1000);
             t_response_header.set_sender(message::Communicator::eParkspace_allocator);
             t_response_header.set_receiver(message::Communicator::eMain);
-            t_error.set_error_code(0);
-            t_error.set_error_level(message::Error_level::NORMAL);
+            if(m_parkspace_status_msg.parkspace_info_size()>0)
+            {
+                t_error.set_error_code(0);
+                t_error.set_error_level(message::Error_level::NORMAL);
+                t_allocated_space.CopyFrom(m_parkspace_status_msg.parkspace_info(0));
+            } else{
+                t_error.set_error_code(1);
+                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+            }
             response_msg.mutable_base_info()->CopyFrom(t_response_header);
-            response_msg.mutable_error_manager()->CopyFrom(t_error);
             response_msg.set_command_id(request.command_id());
-            response_msg.set_allocated_space_id(33);
+            response_msg.mutable_error_manager()->CopyFrom(t_error);
+            response_msg.mutable_allocated_space_info()->CopyFrom(t_allocated_space);
+            Communication_message* response=new Communication_message();
             response->reset(t_response_header, response_msg.SerializeAsString());
-            return send_allocation_result(response);
+            return send_response(response);
             // return SUCCESS;
         }
+        case Communication_message::eParkspace_search_request_msg:
+        {
+            message::Parkspace_search_request_msg request;
+            request.ParseFromString(p_msg->get_message_buf());
+            std::cout<<"search request, car license: "<<request.car_info().license()<<std::endl;
+
+            //根据车辆凭证信息查询车辆位置
+            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
+            message::Parkspace_search_response_msg response_msg;
+            message::Base_info t_response_header;
+            message::Error_manager t_error;
+            message::Parkspace_info t_car_position;
+            t_response_header.set_msg_type(message::Message_type::eParkspace_search_response_msg);
+            t_response_header.set_timeout_ms(1000);
+            t_response_header.set_sender(message::Communicator::eParkspace_allocator);
+            t_response_header.set_receiver(message::Communicator::eMain);
+            if (m_parkspace_status_msg.parkspace_info_size() > 1)
+            {
+                t_error.set_error_code(0);
+                t_error.set_error_level(message::Error_level::NORMAL);
+                t_car_position.CopyFrom(m_parkspace_status_msg.parkspace_info(1));
+            }
+            else
+            {
+                t_error.set_error_code(1);
+                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+            }
+            response_msg.mutable_base_info()->CopyFrom(t_response_header);
+            response_msg.set_command_id(request.command_id());
+            response_msg.mutable_error_manager()->CopyFrom(t_error);
+            response_msg.mutable_car_position()->CopyFrom(t_car_position);
+            Communication_message* response=new Communication_message();
+            response->reset(t_response_header, response_msg.SerializeAsString());
+            return send_response(response);
+        }
+        case Communication_message::eParkspace_release_request_msg:
+        {
+            message::Parkspace_release_request_msg request;
+            request.ParseFromString(p_msg->get_message_buf());
+            std::cout<<"release request, parkspace id: "<<request.release_space_info().parkspace_id()<<std::endl;
+
+            //根据车位信息定位待释放车位位置，车辆凭证号用于校验
+            //!!!!!此处跳过外部处理与调用的过程，直接在内部调用，发送分配结果用于测试，目前一直发布第一个车位
+            message::Parkspace_release_response_msg response_msg;
+            message::Base_info t_response_header;
+            message::Error_manager t_error;
+            t_response_header.set_msg_type(message::Message_type::eParkspace_release_response_msg);
+            t_response_header.set_timeout_ms(1000);
+            t_response_header.set_sender(message::Communicator::eParkspace_allocator);
+            t_response_header.set_receiver(message::Communicator::eMain);
+            if (m_parkspace_status_msg.parkspace_info_size() > 0)
+            {
+                t_error.set_error_code(0);
+                t_error.set_error_level(message::Error_level::NORMAL);
+            }
+            else
+            {
+                t_error.set_error_code(1);
+                t_error.set_error_level(message::Error_level::MAJOR_ERROR);
+            }
+            response_msg.mutable_base_info()->CopyFrom(t_response_header);
+            response_msg.set_command_id(request.command_id());
+            response_msg.mutable_error_manager()->CopyFrom(t_error);
+            response_msg.mutable_release_space_info()->CopyFrom(request.release_space_info());
+            Communication_message* response=new Communication_message();
+            response->reset(t_response_header, response_msg.SerializeAsString());
+            return send_response(response);
+        }
     }
     return Error_manager(PARKSPACE_ALLOCATOR_MSG_RESPONSE_TYPE_ERROR, NEGLIGIBLE_ERROR, "parkspace allocation wrong request type");
 }
 
 //检查消息是否应由本模块接收
+//本模块接收车位分配请求、车位查询请求与车位释放请求
 Error_manager Parkspace_allocation_communicator::check_msg(Communication_message* p_msg)
 {
     //通过 p_msg->get_message_type() 和 p_msg->get_receiver() 判断这条消息是不是车位请求消息.
-	if ( p_msg->get_message_type() == Communication_message::Message_type::eParkspace_allocation_request_msg
-		 && p_msg->get_receiver() == Communication_message::Communicator::eParkspace_allocator)
-	{
-		return Error_code::SUCCESS;
-	}
-	else
-	{
-		//认为接受人
-		return Error_code::INVALID_MESSAGE;
-	}
+    if(p_msg->get_receiver() == Communication_message::Communicator::eParkspace_allocator)
+    {
+        switch(p_msg->get_message_type())
+        {
+            case Communication_message::Message_type::eParkspace_allocation_request_msg:
+                return Error_code::SUCCESS;
+            case Communication_message::Message_type::eParkspace_search_request_msg:
+                return Error_code::SUCCESS;
+            case Communication_message::Message_type::eParkspace_release_request_msg:
+                return Error_code::SUCCESS;
+            default:
+                return Error_code::INVALID_MESSAGE;
+        }
+    }
 }
 
 Error_manager Parkspace_allocation_communicator::check_executer(Communication_message*  p_msg)
@@ -147,7 +240,7 @@ Error_manager Parkspace_allocation_communicator::check_executer(Communication_me
 
 		if ( executer_is_ready )
 		{
-			std::cout << "executer_is_ready , " << std::endl;
+			// std::cout << "executer_is_ready , " << std::endl;
 			return Error_code::SUCCESS;
 		}
 		else

parkspace_allocation/parkspace_allocation_communicator.h

@@ -20,7 +20,7 @@ class Parkspace_allocation_communicator: public Singleton<Parkspace_allocation_c
 public:
     virtual ~Parkspace_allocation_communicator();
     //外部调用，反馈结果消息
-    Error_manager send_allocation_result(Communication_message* message);
+    Error_manager send_response(Communication_message* message);
     //更新所有车位状态，现有状态将被全部覆盖，车位数量可能变动
     Error_manager update_parkspace_status(message::Parkspace_allocation_status_msg message);
     //更新某个车位状态，不修改车位数量，车位按编号从1开始
@@ -35,7 +35,7 @@ protected:
     //解析车位分配请求消息具体内容，激活车位分配单例处理函数（不可阻塞），获得结果后由车位分配单例封装消息发送
     virtual Error_manager execute_msg(Communication_message* p_msg);
     //检查是否接收到本模块需要的消息，重载后父类自行调用判断
-    virtual Error_manager check_msg(Communication_message* p_msg); 
+    virtual Error_manager check_msg(Communication_message* p_msg);
     //重载检查执行者函数，判断执行者状态
     virtual Error_manager check_executer(Communication_message*  p_msg);
     //心跳与车位实时信息

test/parkspace_client.cpp

@@ -2,7 +2,7 @@
  * @Description: 模拟主程序发送车位分配请求，并监听状态信息
  * @Author: yct
  * @Date: 2020-07-08 15:44:43
- * @LastEditTime: 2020-07-08 18:03:59
+ * @LastEditTime: 2020-07-09 17:32:55
  * @LastEditors: yct
  */
 
@@ -14,58 +14,157 @@
 
 #include "parkspace_allocation_message.pb.h"
 #include <thread>
+
+std::string send_allocation_request(int n)
+{
+    // 发送车位分配请求
+    message::Error_manager error_code;
+    message::Base_info base_info;
+    message::Car_info car_info;
+    message::Parkspace_allocation_request_msg request;
+
+    base_info.set_msg_type(message::Message_type::eParkspace_allocation_request_msg);
+    base_info.set_sender(message::eMain);
+    base_info.set_receiver(message::eParkspace_allocator);
+    base_info.set_timeout_ms(2000);
+    car_info.set_car_height(1.0);
+    car_info.set_car_width(1.0);
+    car_info.set_license("鄂A12345");
+
+    request.mutable_base_info()->CopyFrom(base_info);
+    request.set_command_id(n);
+    request.set_terminal_id(1);
+    request.mutable_car_info()->CopyFrom(car_info);
+
+    // socket.send(request.SerializeAsString());
+    return request.SerializeAsString();
+}
+
+std::string send_search_requests(int n)
+{
+    // 发送车位查询请求
+    message::Error_manager error_code;
+    message::Base_info base_info;
+    message::Car_info car_info;
+    message::Parkspace_search_request_msg request;
+
+    base_info.set_msg_type(message::Message_type::eParkspace_search_request_msg);
+    base_info.set_sender(message::eMain);
+    base_info.set_receiver(message::eParkspace_allocator);
+    base_info.set_timeout_ms(2000);
+    car_info.set_car_height(2.0);
+    car_info.set_car_width(2.0);
+    car_info.set_license("鄂A23456");
+
+    request.mutable_base_info()->CopyFrom(base_info);
+    request.set_command_id(n);
+    request.mutable_car_info()->CopyFrom(car_info);
+
+    // socket.send(request.SerializeAsString());
+    return request.SerializeAsString();
+}
+
+std::string send_release_request(int n)
+{
+    // 发送车位释放请求
+    message::Error_manager error_code;
+    message::Base_info base_info;
+    message::Car_info car_info;
+    message::Parkspace_info space_info;
+    message::Parkspace_release_request_msg request;
+
+    base_info.set_msg_type(message::Message_type::eParkspace_release_request_msg);
+    base_info.set_sender(message::eMain);
+    base_info.set_receiver(message::eParkspace_allocator);
+    base_info.set_timeout_ms(2000);
+    car_info.set_car_height(1.5);
+    car_info.set_car_width(1.85);
+    car_info.set_license("鄂A34567");
+    space_info.set_parkspace_id(1);
+    space_info.set_index(1);
+    space_info.set_direction(message::Direction::eForward);
+    space_info.set_floor(33);
+    space_info.set_width(1.5);
+    space_info.set_height(1.5);
+    space_info.set_parkspace_status(message::Parkspace_status::eParkspace_occupied);
+
+    request.mutable_base_info()->CopyFrom(base_info);
+    request.set_command_id(n);
+    request.mutable_release_space_info()->CopyFrom(space_info);
+
+    // socket.send(request.SerializeAsString());
+    return request.SerializeAsString();
+}
+
 int main()
 {
     nnxx::socket socket{nnxx::SP, nnxx::BUS};
-    socket.bind("tcp://127.0.0.1:7000");
+    // socket.bind("tcp://127.0.0.1:7000");
     socket.connect("tcp://127.0.0.1:7001");
     int n = 0;
-    message::Parkspace_allocation_status_msg parkspace_status;
-    message::Parkspace_allocation_response_msg response;
-    message::Base_info base_info;
+    message::Base_msg base_msg;
+
+    usleep(1000*3000);
+
     while (1)
     {
-        // 发送车位分配请求
-        message::Error_manager error_code;
-        message::Base_info base_msg;
-        message::Parkspace_allocation_request_msg request;
-
-        base_msg.set_msg_type(message::Message_type::eParkspace_allocation_request_msg);
-        base_msg.set_sender(message::eMain);
-        base_msg.set_receiver(message::eParkspace_allocator);
-        base_msg.set_timeout_ms(2000);
-
-        request.mutable_base_info()->CopyFrom(base_msg);
-        request.set_command_id(n);
-        request.set_car_length(4500);
-        request.set_car_width(1800);
-        request.set_car_height(1500);
-
-        socket.send(request.SerializeAsString());
-
-        // 接收消息
-        std::string t_receive_string = socket.recv<std::string>(1);
-        if (t_receive_string.length() > 0)
+        // std::string alloc_req = send_allocation_request(n);
+        // std::string search_req = send_search_requests(n);
+
+        std::string alloc_req = send_allocation_request(n);
+        socket.send(alloc_req);
+        usleep(1000*2000);
+        std::string search_req = send_search_requests(n);
+        socket.send(search_req);
+        usleep(1000*2000);
+        std::string release_req = send_release_request(n);
+        socket.send(release_req);
+        usleep(1000*2000);
+
+        for (size_t i = 0; i < 5; i++)
         {
-            base_info.ParseFromString(t_receive_string);
-            // 接收并打印车位状态信息
-            std::cout << "====================================================" << std::endl;
-            std::cout << "cycle " << n << std::endl;
-            if(base_info.msg_type() == message::Message_type::eParkspace_allocation_status_msg)
+            // 接收消息
+            std::string t_receive_string = socket.recv<std::string>(1);
+            if (t_receive_string.length() > 0)
             {
-                parkspace_status.ParseFromString(t_receive_string);
-                std::cout << parkspace_status.DebugString() << std::endl;
-                // continue;
-            }
-            else
-            {
-                response.ParseFromString(t_receive_string);
-                std::cout<< "----------------- 分配车位结果 -----------------" << std::endl;
-                std::cout << response.DebugString() << std::endl;
+                bool result = base_msg.ParseFromString(t_receive_string);
+                // 接收并打印车位状态信息
+                std::cout << "========================" << result << "============================" << std::endl;
+                std::cout << "cycle " << n << std::endl;
+                if (base_msg.base_info().msg_type() == message::Message_type::eParkspace_allocation_status_msg)
+                {
+                    message::Parkspace_allocation_status_msg parkspace_status;
+                    std::cout << "----------------- 车位状态 -----------------" << std::endl;
+                    parkspace_status.ParseFromString(t_receive_string);
+                    std::cout << parkspace_status.DebugString() << std::endl;
+                    // continue;
+                }
+                else if (base_msg.base_info().msg_type() == message::Message_type::eParkspace_allocation_response_msg)
+                {
+                    message::Parkspace_allocation_response_msg response;
+                    response.ParseFromString(t_receive_string);
+                    std::cout << "----------------- 分配车位结果 -----------------" << std::endl;
+                    std::cout << response.DebugString() << std::endl;
+                }
+                else if (base_msg.base_info().msg_type() == message::Message_type::eParkspace_search_response_msg)
+                {
+                    message::Parkspace_search_response_msg response;
+                    response.ParseFromString(t_receive_string);
+                    std::cout << "----------------- 查询车辆位置结果 -----------------" << std::endl;
+                    std::cout << response.DebugString() << std::endl;
+                }
+                else if (base_msg.base_info().msg_type() == message::Message_type::eParkspace_release_response_msg)
+                {
+                    message::Parkspace_release_response_msg response;
+                    response.ParseFromString(t_receive_string);
+                    std::cout << "----------------- 释放车位结果 -----------------" << std::endl;
+                    std::cout << response.DebugString() << std::endl;
+                }
             }
         }
+
         // std::this_thread::yield();
         n++;
-        usleep(1000*1000);
+        usleep(1000 * 5000);
     }
 }

test/test_parkspace_sample.cpp

@@ -2,27 +2,33 @@
  * @Description: 测试车位分配模块通信情况
  * @Author: yct
  * @Date: 2020-07-08 15:51:46
- * @LastEditTime: 2020-07-08 17:38:21
+ * @LastEditTime: 2020-07-09 17:24:24
  * @LastEditors: yct
  */ 
 #include "../parkspace_allocation/parkspace_allocation_communicator.h"
 
 int main()
 {
+    google::InitGoogleLogging("parkspace_allocator");
+    google::SetStderrLogging(google::INFO);
+    google::InstallFailureSignalHandler();
+    FLAGS_colorlogtostderr = true; 
+
     Parkspace_allocation_communicator *p_parkspace_allocator = Parkspace_allocation_communicator::get_instance_pointer();
     
     p_parkspace_allocator->communication_bind("tcp://127.0.0.1:7001");
-    p_parkspace_allocator->communication_connect("tcp://127.0.0.1:7000");
+    // p_parkspace_allocator->communication_connect("tcp://127.0.0.1:7000");
     p_parkspace_allocator->communication_run();
 
+    // 初始化车位，创建三个车位
     message::Parkspace_allocation_status_msg parkspace_status;
     for (size_t i = 1; i < 4; i++)
     {
         message::Parkspace_info* space = parkspace_status.add_parkspace_info();
         space->set_parkspace_id(i);
-        space->set_x_coordinate(i*100);
-        space->set_y_coordinate(i*200);
-        space->set_z_coordinate(i*300);
+        space->set_index(i);
+        space->set_direction(message::Direction::eForward);
+        space->set_floor(2+i);
         space->set_length(5500);
         space->set_width(2200);
         space->set_height(1750);
@@ -44,9 +50,9 @@ int main()
     while(1) {
         message::Parkspace_info space;
         space.set_parkspace_id(3);
-        space.set_x_coordinate(k*100);
-        space.set_y_coordinate(k*200);
-        space.set_z_coordinate(k*300);
+        space.set_index(k);
+        space.set_direction(message::Direction::eForward);
+        space.set_floor(k*3);
         space.set_length(5500);
         space.set_width(2200);
         space.set_height(k*400);