修改中控状态消息格式

dispatch/dispatch_excutor.cpp

@@ -118,7 +118,7 @@ Error_manager Dispatch_excutor::check_entrance_statu(int terminal_id)
     if(m_storing_dispatch_statu_msg_map[terminal_id].has_base_info()== false
        || durantion>std::chrono::seconds(5))
     {
-        return Error_manager(ERROR,MINOR_ERROR,"调度节点通讯断开");
+        return Error_manager(DISCONNECT,MINOR_ERROR,"调度节点通讯断开");
     }
     if(m_storing_dispatch_statu_msg_map[terminal_id].terminal_status()==message::E_TERMINAL_FAULT)
     {
@@ -126,7 +126,7 @@ Error_manager Dispatch_excutor::check_entrance_statu(int terminal_id)
     }
     if(m_storing_dispatch_statu_msg_map[terminal_id].terminal_status()==message::E_TERMINAL_UNKNOW)
     {
-        return Error_manager(ERROR,MINOR_ERROR,"调度节点状态未知");
+        return Error_manager(UNKNOW_STATU,MINOR_ERROR,"调度节点状态未知");
     }
 
     return SUCCESS;

error_code/error_code.h

@@ -60,6 +60,9 @@ enum Error_code
     PAUSE                           = 0x00000013,   //急停
     TASK_CANCEL                     = 0x00000014,   //任务取消
 
+    DISCONNECT                      = 0x00000020,   //通讯中断/断开连接
+    UNKNOW_STATU                    = 0x00000021,   //未知状态
+
     POINTER_IS_NULL                 = 0x00000101,//空指针
     PARAMETER_ERROR                 = 0x00000102,//参数错误，传入参数不符合规范时，
     POINTER_MALLOC_FAIL             = 0x00000103,//手动分配内存失败

exception/exception_solver.cpp

@@ -72,12 +72,12 @@ Error_manager Exception_solver::consume_msg(Communication_message* p_msg)
             {
                 case message::eStoring:
                 {
-                    Command_manager::get_instance_pointer()->enable_entrance(msg.terminal_id(),(Command_manager::Entrance_statu)msg.entrance_statu());
+                    Command_manager::get_instance_pointer()->pause_entrance(msg.terminal_id(),msg.paused());
                     break;
                 }
                 case message::ePicking:
                 {
-                    Command_manager::get_instance_pointer()->enable_export(msg.terminal_id(),(Command_manager::Entrance_statu)msg.entrance_statu());
+                    Command_manager::get_instance_pointer()->pause_export(msg.terminal_id(),msg.paused());
                     break;
                 }
             }
@@ -131,7 +131,7 @@ Error_manager Exception_solver::solve_exception(Error_manager code,Process_task*
         //四级故障,任务未完成, 且模块未能回退并恢复到初始待机状态
         //关闭出入口
         if(task->GetCategory()==message::eStoring) {
-            Command_manager::get_instance_pointer()->enable_entrance(task->terminal_id(),Command_manager::Entrance_statu::Disable);
+            Command_manager::get_instance_pointer()->pause_entrance(task->terminal_id(),true);
             LOG(ERROR)<<"关闭入口:"<<task->terminal_id()<<"   故障  !!!!!!  等待手动操作 ... ";
             message::Process_manual_operation_msg operate_msg;
             code_operate=waitfor_manual_operate_msg(task,operate_msg);
@@ -162,7 +162,7 @@ Error_manager Exception_solver::solve_exception(Error_manager code,Process_task*
 
         }
         if(task->GetCategory()==message::ePicking) {
-            Command_manager::get_instance_pointer()->enable_export(task->terminal_id(),Command_manager::Entrance_statu::Disable);
+            Command_manager::get_instance_pointer()->pause_export(task->terminal_id(),true);
             LOG(ERROR)<<"关闭出口:"<<task->terminal_id()<<"   四级故障  !!!!!!  等待手动操作 ...";
             message::Process_manual_operation_msg operate_msg;
             code_operate=waitfor_manual_operate_msg(task,operate_msg);

lidar_locate/measure_excutor.cpp

@@ -104,7 +104,7 @@ Error_manager Measure_excutor::check_statu(int terminal_id)
     if(m_measure_statu_msg_map[terminal_id].has_base_info()== false
         || durantion>std::chrono::seconds(5))
     {
-        return Error_manager(ERROR,MINOR_ERROR,"测量节点通讯断开");
+        return Error_manager(DISCONNECT,MINOR_ERROR,"测量节点通讯断开");
     }
     if(m_measure_statu_msg_map[terminal_id].laser_manager_status()==message::LASER_MANAGER_FAULT)
     {
@@ -113,9 +113,13 @@ Error_manager Measure_excutor::check_statu(int terminal_id)
     for(int i=0;i<m_measure_statu_msg_map[terminal_id].laser_statu_vector_size();++i)
     {
         message::Laser_statu laser_statu=m_measure_statu_msg_map[terminal_id].laser_statu_vector(i);
-        if(laser_statu==message::LASER_FAULT || laser_statu==message::LASER_DISCONNECT)
+        if(laser_statu==message::LASER_FAULT )
         {
-            return Error_manager(ERROR,MINOR_ERROR,"测量模块雷达故障或者断线");
+            return Error_manager(ERROR,MINOR_ERROR,"测量模块雷达故障");
+        }
+        if(laser_statu==message::LASER_DISCONNECT)
+        {
+            return Error_manager(DISCONNECT,MINOR_ERROR,"测量模块雷达断线");
         }
     }
     return SUCCESS;

message/central_control_message.pb.cc

@@ -20,6 +20,11 @@
 #endif
 // @@protoc_insertion_point(includes)
 namespace message {
+class Entrance_statuDefaultTypeInternal {
+ public:
+  ::google::protobuf::internal::ExplicitlyConstructed<Entrance_statu>
+      _instance;
+} _Entrance_statu_default_instance_;
 class Central_controller_statu_msgDefaultTypeInternal {
  public:
   ::google::protobuf::internal::ExplicitlyConstructed<Central_controller_statu_msg>
@@ -37,6 +42,27 @@ class Process_manual_operation_msgDefaultTypeInternal {
 } _Process_manual_operation_msg_default_instance_;
 }  // namespace message
 namespace protobuf_central_5fcontrol_5fmessage_2eproto {
+void InitDefaultsEntrance_statuImpl() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
+#else
+  ::google::protobuf::internal::InitProtobufDefaults();
+#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
+  {
+    void* ptr = &::message::_Entrance_statu_default_instance_;
+    new (ptr) ::message::Entrance_statu();
+    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::message::Entrance_statu::InitAsDefaultInstance();
+}
+
+void InitDefaultsEntrance_statu() {
+  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
+  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsEntrance_statuImpl);
+}
+
 void InitDefaultsCentral_controller_statu_msgImpl() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
@@ -46,6 +72,7 @@ void InitDefaultsCentral_controller_statu_msgImpl() {
   ::google::protobuf::internal::InitProtobufDefaults();
 #endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
   protobuf_message_5fbase_2eproto::InitDefaultsBase_info();
+  protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsEntrance_statu();
   {
     void* ptr = &::message::_Central_controller_statu_msg_default_instance_;
     new (ptr) ::message::Central_controller_statu_msg();
@@ -103,10 +130,23 @@ void InitDefaultsProcess_manual_operation_msg() {
   ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsProcess_manual_operation_msgImpl);
 }
 
-::google::protobuf::Metadata file_level_metadata[3];
+::google::protobuf::Metadata file_level_metadata[4];
 const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[2];
 
 const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_statu, _has_bits_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_statu, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_statu, paused_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_statu, parkspace_statu_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_statu, measure_statu_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_statu, dispatch_statu_),
+  0,
+  1,
+  2,
+  3,
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Central_controller_statu_msg, _has_bits_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Central_controller_statu_msg, _internal_metadata_),
   ~0u,  // no _extensions_
@@ -126,7 +166,7 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_manual_operation_msg, base_info_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_manual_operation_msg, terminal_id_),
   GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_manual_operation_msg, process_type_),
-  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_manual_operation_msg, entrance_statu_),
+  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::message::Entrance_manual_operation_msg, paused_),
   0,
   1,
   3,
@@ -146,12 +186,14 @@ const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUT
   3,
 };
 static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
-  { 0, 8, sizeof(::message::Central_controller_statu_msg)},
-  { 11, 20, sizeof(::message::Entrance_manual_operation_msg)},
-  { 24, 33, sizeof(::message::Process_manual_operation_msg)},
+  { 0, 9, sizeof(::message::Entrance_statu)},
+  { 13, 21, sizeof(::message::Central_controller_statu_msg)},
+  { 24, 33, sizeof(::message::Entrance_manual_operation_msg)},
+  { 37, 46, sizeof(::message::Process_manual_operation_msg)},
 };
 
 static ::google::protobuf::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Entrance_statu_default_instance_),
   reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Central_controller_statu_msg_default_instance_),
   reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Entrance_manual_operation_msg_default_instance_),
   reinterpret_cast<const ::google::protobuf::Message*>(&::message::_Process_manual_operation_msg_default_instance_),
@@ -173,34 +215,38 @@ void protobuf_AssignDescriptorsOnce() {
 void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
 void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 3);
+  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 4);
 }
 
 void AddDescriptorsImpl() {
   InitDefaults();
   static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
       "\n\035central_control_message.proto\022\007message"
-      "\032\022message_base.proto\"\263\001\n\034Central_control"
-      "ler_statu_msg\022%\n\tbase_info\030\001 \002(\0132\022.messa"
-      "ge.Base_info\0226\n\025entrance_statu_vector\030\002 "
-      "\003(\0162\027.message.Entrance_statu\0224\n\023export_s"
-      "tatu_vector\030\003 \003(\0162\027.message.Entrance_sta"
-      "tu\"\271\001\n\035Entrance_manual_operation_msg\022%\n\t"
-      "base_info\030\001 \002(\0132\022.message.Base_info\022\023\n\013t"
-      "erminal_id\030\002 \002(\005\022+\n\014process_type\030\003 \002(\0162\025"
-      ".message.Process_type\022/\n\016entrance_statu\030"
-      "\004 \002(\0162\027.message.Entrance_statu\"\264\001\n\034Proce"
-      "ss_manual_operation_msg\022%\n\tbase_info\030\001 \002"
-      "(\0132\022.message.Base_info\022\017\n\007license\030\002 \002(\t\022"
-      "%\n\tstep_type\030\003 \002(\0162\022.message.Step_type\0225"
-      "\n\014operate_type\030\004 \002(\0162\037.message.Process_o"
-      "peration_type*8\n\016Entrance_statu\022\013\n\007eEnab"
-      "le\020\000\022\014\n\010eDisable\020\001\022\013\n\007ePaused\020\002*S\n\026Proce"
-      "ss_operation_type\022\022\n\016eManual_cancel\020\000\022\021\n"
-      "\reManual_retry\020\001\022\022\n\016eManual_ignore\020\002"
+      "\032\022message_base.proto\"\255\001\n\016Entrance_statu\022"
+      "\016\n\006paused\030\001 \002(\010\022.\n\017parkspace_statu\030\002 \001(\016"
+      "2\025.message.Module_statu\022,\n\rmeasure_statu"
+      "\030\003 \001(\0162\025.message.Module_statu\022-\n\016dispatc"
+      "h_statu\030\004 \001(\0162\025.message.Module_statu\"\263\001\n"
+      "\034Central_controller_statu_msg\022%\n\tbase_in"
+      "fo\030\001 \002(\0132\022.message.Base_info\0226\n\025entrance"
+      "_statu_vector\030\002 \003(\0132\027.message.Entrance_s"
+      "tatu\0224\n\023export_statu_vector\030\003 \003(\0132\027.mess"
+      "age.Entrance_statu\"\230\001\n\035Entrance_manual_o"
+      "peration_msg\022%\n\tbase_info\030\001 \002(\0132\022.messag"
+      "e.Base_info\022\023\n\013terminal_id\030\002 \002(\005\022+\n\014proc"
+      "ess_type\030\003 \002(\0162\025.message.Process_type\022\016\n"
+      "\006paused\030\004 \002(\010\"\264\001\n\034Process_manual_operati"
+      "on_msg\022%\n\tbase_info\030\001 \002(\0132\022.message.Base"
+      "_info\022\017\n\007license\030\002 \002(\t\022%\n\tstep_type\030\003 \002("
+      "\0162\022.message.Step_type\0225\n\014operate_type\030\004 "
+      "\002(\0162\037.message.Process_operation_type*S\n\026"
+      "Process_operation_type\022\022\n\016eManual_cancel"
+      "\020\000\022\021\n\reManual_retry\020\001\022\022\n\016eManual_ignore\020"
+      "\002*=\n\014Module_statu\022\016\n\neConnected\020\000\022\021\n\reDi"
+      "sconnected\020\001\022\n\n\006eFault\020\002"
   };
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-      descriptor, 756);
+      descriptor, 904);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "central_control_message.proto", &protobuf_RegisterTypes);
   ::protobuf_message_5fbase_2eproto::AddDescriptors();
@@ -218,11 +264,11 @@ struct StaticDescriptorInitializer {
 } static_descriptor_initializer;
 }  // namespace protobuf_central_5fcontrol_5fmessage_2eproto
 namespace message {
-const ::google::protobuf::EnumDescriptor* Entrance_statu_descriptor() {
+const ::google::protobuf::EnumDescriptor* Process_operation_type_descriptor() {
   protobuf_central_5fcontrol_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
   return protobuf_central_5fcontrol_5fmessage_2eproto::file_level_enum_descriptors[0];
 }
-bool Entrance_statu_IsValid(int value) {
+bool Process_operation_type_IsValid(int value) {
   switch (value) {
     case 0:
     case 1:
@@ -233,11 +279,11 @@ bool Entrance_statu_IsValid(int value) {
   }
 }
 
-const ::google::protobuf::EnumDescriptor* Process_operation_type_descriptor() {
+const ::google::protobuf::EnumDescriptor* Module_statu_descriptor() {
   protobuf_central_5fcontrol_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
   return protobuf_central_5fcontrol_5fmessage_2eproto::file_level_enum_descriptors[1];
 }
-bool Process_operation_type_IsValid(int value) {
+bool Module_statu_IsValid(int value) {
   switch (value) {
     case 0:
     case 1:
@@ -249,6 +295,391 @@ bool Process_operation_type_IsValid(int value) {
 }
 
 
+// ===================================================================
+
+void Entrance_statu::InitAsDefaultInstance() {
+}
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+const int Entrance_statu::kPausedFieldNumber;
+const int Entrance_statu::kParkspaceStatuFieldNumber;
+const int Entrance_statu::kMeasureStatuFieldNumber;
+const int Entrance_statu::kDispatchStatuFieldNumber;
+#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
+
+Entrance_statu::Entrance_statu()
+  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
+  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
+    ::protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsEntrance_statu();
+  }
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:message.Entrance_statu)
+}
+Entrance_statu::Entrance_statu(const Entrance_statu& from)
+  : ::google::protobuf::Message(),
+      _internal_metadata_(NULL),
+      _has_bits_(from._has_bits_),
+      _cached_size_(0) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::memcpy(&paused_, &from.paused_,
+    static_cast<size_t>(reinterpret_cast<char*>(&dispatch_statu_) -
+    reinterpret_cast<char*>(&paused_)) + sizeof(dispatch_statu_));
+  // @@protoc_insertion_point(copy_constructor:message.Entrance_statu)
+}
+
+void Entrance_statu::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(&paused_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&dispatch_statu_) -
+      reinterpret_cast<char*>(&paused_)) + sizeof(dispatch_statu_));
+}
+
+Entrance_statu::~Entrance_statu() {
+  // @@protoc_insertion_point(destructor:message.Entrance_statu)
+  SharedDtor();
+}
+
+void Entrance_statu::SharedDtor() {
+}
+
+void Entrance_statu::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Entrance_statu::descriptor() {
+  ::protobuf_central_5fcontrol_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_central_5fcontrol_5fmessage_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
+}
+
+const Entrance_statu& Entrance_statu::default_instance() {
+  ::protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsEntrance_statu();
+  return *internal_default_instance();
+}
+
+Entrance_statu* Entrance_statu::New(::google::protobuf::Arena* arena) const {
+  Entrance_statu* n = new Entrance_statu;
+  if (arena != NULL) {
+    arena->Own(n);
+  }
+  return n;
+}
+
+void Entrance_statu::Clear() {
+// @@protoc_insertion_point(message_clear_start:message.Entrance_statu)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 15u) {
+    ::memset(&paused_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&dispatch_statu_) -
+        reinterpret_cast<char*>(&paused_)) + sizeof(dispatch_statu_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear();
+}
+
+bool Entrance_statu::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:message.Entrance_statu)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required bool paused = 1;
+      case 1: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
+          set_has_paused();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &paused_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // optional .message.Module_statu parkspace_statu = 2;
+      case 2: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::message::Module_statu_IsValid(value)) {
+            set_parkspace_statu(static_cast< ::message::Module_statu >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(
+                2, static_cast< ::google::protobuf::uint64>(value));
+          }
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // optional .message.Module_statu measure_statu = 3;
+      case 3: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::message::Module_statu_IsValid(value)) {
+            set_measure_statu(static_cast< ::message::Module_statu >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(
+                3, static_cast< ::google::protobuf::uint64>(value));
+          }
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // optional .message.Module_statu dispatch_statu = 4;
+      case 4: {
+        if (static_cast< ::google::protobuf::uint8>(tag) ==
+            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::message::Module_statu_IsValid(value)) {
+            set_dispatch_statu(static_cast< ::message::Module_statu >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(
+                4, static_cast< ::google::protobuf::uint64>(value));
+          }
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:message.Entrance_statu)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:message.Entrance_statu)
+  return false;
+#undef DO_
+}
+
+void Entrance_statu::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:message.Entrance_statu)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required bool paused = 1;
+  if (cached_has_bits & 0x00000001u) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->paused(), output);
+  }
+
+  // optional .message.Module_statu parkspace_statu = 2;
+  if (cached_has_bits & 0x00000002u) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->parkspace_statu(), output);
+  }
+
+  // optional .message.Module_statu measure_statu = 3;
+  if (cached_has_bits & 0x00000004u) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->measure_statu(), output);
+  }
+
+  // optional .message.Module_statu dispatch_statu = 4;
+  if (cached_has_bits & 0x00000008u) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->dispatch_statu(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:message.Entrance_statu)
+}
+
+::google::protobuf::uint8* Entrance_statu::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, ::google::protobuf::uint8* target) const {
+  (void)deterministic; // Unused
+  // @@protoc_insertion_point(serialize_to_array_start:message.Entrance_statu)
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  // required bool paused = 1;
+  if (cached_has_bits & 0x00000001u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->paused(), target);
+  }
+
+  // optional .message.Module_statu parkspace_statu = 2;
+  if (cached_has_bits & 0x00000002u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->parkspace_statu(), target);
+  }
+
+  // optional .message.Module_statu measure_statu = 3;
+  if (cached_has_bits & 0x00000004u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      3, this->measure_statu(), target);
+  }
+
+  // optional .message.Module_statu dispatch_statu = 4;
+  if (cached_has_bits & 0x00000008u) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      4, this->dispatch_statu(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:message.Entrance_statu)
+  return target;
+}
+
+size_t Entrance_statu::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:message.Entrance_statu)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  // required bool paused = 1;
+  if (has_paused()) {
+    total_size += 1 + 1;
+  }
+  if (_has_bits_[0 / 32] & 14u) {
+    // optional .message.Module_statu parkspace_statu = 2;
+    if (has_parkspace_statu()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->parkspace_statu());
+    }
+
+    // optional .message.Module_statu measure_statu = 3;
+    if (has_measure_statu()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->measure_statu());
+    }
+
+    // optional .message.Module_statu dispatch_statu = 4;
+    if (has_dispatch_statu()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->dispatch_statu());
+    }
+
+  }
+  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = cached_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Entrance_statu::MergeFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:message.Entrance_statu)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Entrance_statu* source =
+      ::google::protobuf::internal::DynamicCastToGenerated<const Entrance_statu>(
+          &from);
+  if (source == NULL) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:message.Entrance_statu)
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:message.Entrance_statu)
+    MergeFrom(*source);
+  }
+}
+
+void Entrance_statu::MergeFrom(const Entrance_statu& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:message.Entrance_statu)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::google::protobuf::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 15u) {
+    if (cached_has_bits & 0x00000001u) {
+      paused_ = from.paused_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      parkspace_statu_ = from.parkspace_statu_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      measure_statu_ = from.measure_statu_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      dispatch_statu_ = from.dispatch_statu_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+}
+
+void Entrance_statu::CopyFrom(const ::google::protobuf::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:message.Entrance_statu)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Entrance_statu::CopyFrom(const Entrance_statu& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:message.Entrance_statu)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Entrance_statu::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  return true;
+}
+
+void Entrance_statu::Swap(Entrance_statu* other) {
+  if (other == this) return;
+  InternalSwap(other);
+}
+void Entrance_statu::InternalSwap(Entrance_statu* other) {
+  using std::swap;
+  swap(paused_, other->paused_);
+  swap(parkspace_statu_, other->parkspace_statu_);
+  swap(measure_statu_, other->measure_statu_);
+  swap(dispatch_statu_, other->dispatch_statu_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(_cached_size_, other->_cached_size_);
+}
+
+::google::protobuf::Metadata Entrance_statu::GetMetadata() const {
+  protobuf_central_5fcontrol_5fmessage_2eproto::protobuf_AssignDescriptorsOnce();
+  return ::protobuf_central_5fcontrol_5fmessage_2eproto::file_level_metadata[kIndexInFileMessages];
+}
+
+
 // ===================================================================
 
 void Central_controller_statu_msg::InitAsDefaultInstance() {
@@ -368,26 +799,8 @@ bool Central_controller_statu_msg::MergePartialFromCodedStream(
       // repeated .message.Entrance_statu entrance_statu_vector = 2;
       case 2: {
         if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
-          int value;
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
-                 input, &value)));
-          if (::message::Entrance_statu_IsValid(value)) {
-            add_entrance_statu_vector(static_cast< ::message::Entrance_statu >(value));
-          } else {
-            mutable_unknown_fields()->AddVarint(
-                2, static_cast< ::google::protobuf::uint64>(value));
-          }
-        } else if (
-            static_cast< ::google::protobuf::uint8>(tag) ==
             static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
-          DO_((::google::protobuf::internal::WireFormat::ReadPackedEnumPreserveUnknowns(
-                 input,
-                 2,
-                 ::message::Entrance_statu_IsValid,
-                 mutable_unknown_fields(),
-                 this->mutable_entrance_statu_vector())));
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_entrance_statu_vector()));
         } else {
           goto handle_unusual;
         }
@@ -397,26 +810,8 @@ bool Central_controller_statu_msg::MergePartialFromCodedStream(
       // repeated .message.Entrance_statu export_statu_vector = 3;
       case 3: {
         if (static_cast< ::google::protobuf::uint8>(tag) ==
-            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
-          int value;
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
-                 input, &value)));
-          if (::message::Entrance_statu_IsValid(value)) {
-            add_export_statu_vector(static_cast< ::message::Entrance_statu >(value));
-          } else {
-            mutable_unknown_fields()->AddVarint(
-                3, static_cast< ::google::protobuf::uint64>(value));
-          }
-        } else if (
-            static_cast< ::google::protobuf::uint8>(tag) ==
             static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
-          DO_((::google::protobuf::internal::WireFormat::ReadPackedEnumPreserveUnknowns(
-                 input,
-                 3,
-                 ::message::Entrance_statu_IsValid,
-                 mutable_unknown_fields(),
-                 this->mutable_export_statu_vector())));
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_export_statu_vector()));
         } else {
           goto handle_unusual;
         }
@@ -457,15 +852,17 @@ void Central_controller_statu_msg::SerializeWithCachedSizes(
   }
 
   // repeated .message.Entrance_statu entrance_statu_vector = 2;
-  for (int i = 0, n = this->entrance_statu_vector_size(); i < n; i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteEnum(
-      2, this->entrance_statu_vector(i), output);
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->entrance_statu_vector_size()); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->entrance_statu_vector(static_cast<int>(i)), output);
   }
 
   // repeated .message.Entrance_statu export_statu_vector = 3;
-  for (int i = 0, n = this->export_statu_vector_size(); i < n; i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteEnum(
-      3, this->export_statu_vector(i), output);
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->export_statu_vector_size()); i < n; i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->export_statu_vector(static_cast<int>(i)), output);
   }
 
   if (_internal_metadata_.have_unknown_fields()) {
@@ -491,12 +888,20 @@ void Central_controller_statu_msg::SerializeWithCachedSizes(
   }
 
   // repeated .message.Entrance_statu entrance_statu_vector = 2;
-  target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
-    2, this->entrance_statu_vector_, target);
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->entrance_statu_vector_size()); i < n; i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        2, this->entrance_statu_vector(static_cast<int>(i)), deterministic, target);
+  }
 
   // repeated .message.Entrance_statu export_statu_vector = 3;
-  target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
-    3, this->export_statu_vector_, target);
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->export_statu_vector_size()); i < n; i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        3, this->export_statu_vector(static_cast<int>(i)), deterministic, target);
+  }
 
   if (_internal_metadata_.have_unknown_fields()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
@@ -523,22 +928,24 @@ size_t Central_controller_statu_msg::ByteSizeLong() const {
   }
   // repeated .message.Entrance_statu entrance_statu_vector = 2;
   {
-    size_t data_size = 0;
-    unsigned int count = static_cast<unsigned int>(this->entrance_statu_vector_size());for (unsigned int i = 0; i < count; i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
-        this->entrance_statu_vector(static_cast<int>(i)));
+    unsigned int count = static_cast<unsigned int>(this->entrance_statu_vector_size());
+    total_size += 1UL * count;
+    for (unsigned int i = 0; i < count; i++) {
+      total_size +=
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          this->entrance_statu_vector(static_cast<int>(i)));
     }
-    total_size += (1UL * count) + data_size;
   }
 
   // repeated .message.Entrance_statu export_statu_vector = 3;
   {
-    size_t data_size = 0;
-    unsigned int count = static_cast<unsigned int>(this->export_statu_vector_size());for (unsigned int i = 0; i < count; i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
-        this->export_statu_vector(static_cast<int>(i)));
+    unsigned int count = static_cast<unsigned int>(this->export_statu_vector_size());
+    total_size += 1UL * count;
+    for (unsigned int i = 0; i < count; i++) {
+      total_size +=
+        ::google::protobuf::internal::WireFormatLite::MessageSize(
+          this->export_statu_vector(static_cast<int>(i)));
     }
-    total_size += (1UL * count) + data_size;
   }
 
   int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
@@ -593,6 +1000,8 @@ void Central_controller_statu_msg::CopyFrom(const Central_controller_statu_msg&
 
 bool Central_controller_statu_msg::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->entrance_statu_vector())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->export_statu_vector())) return false;
   if (has_base_info()) {
     if (!this->base_info_->IsInitialized()) return false;
   }
@@ -633,7 +1042,7 @@ void Entrance_manual_operation_msg::clear_base_info() {
 const int Entrance_manual_operation_msg::kBaseInfoFieldNumber;
 const int Entrance_manual_operation_msg::kTerminalIdFieldNumber;
 const int Entrance_manual_operation_msg::kProcessTypeFieldNumber;
-const int Entrance_manual_operation_msg::kEntranceStatuFieldNumber;
+const int Entrance_manual_operation_msg::kPausedFieldNumber;
 #endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
 
 Entrance_manual_operation_msg::Entrance_manual_operation_msg()
@@ -664,8 +1073,8 @@ Entrance_manual_operation_msg::Entrance_manual_operation_msg(const Entrance_manu
 void Entrance_manual_operation_msg::SharedCtor() {
   _cached_size_ = 0;
   ::memset(&base_info_, 0, static_cast<size_t>(
-      reinterpret_cast<char*>(&entrance_statu_) -
-      reinterpret_cast<char*>(&base_info_)) + sizeof(entrance_statu_));
+      reinterpret_cast<char*>(&paused_) -
+      reinterpret_cast<char*>(&base_info_)) + sizeof(paused_));
   process_type_ = 1;
 }
 
@@ -714,8 +1123,8 @@ void Entrance_manual_operation_msg::Clear() {
   }
   if (cached_has_bits & 14u) {
     ::memset(&terminal_id_, 0, static_cast<size_t>(
-        reinterpret_cast<char*>(&entrance_statu_) -
-        reinterpret_cast<char*>(&terminal_id_)) + sizeof(entrance_statu_));
+        reinterpret_cast<char*>(&paused_) -
+        reinterpret_cast<char*>(&terminal_id_)) + sizeof(paused_));
     process_type_ = 1;
   }
   _has_bits_.Clear();
@@ -778,20 +1187,14 @@ bool Entrance_manual_operation_msg::MergePartialFromCodedStream(
         break;
       }
 
-      // required .message.Entrance_statu entrance_statu = 4;
+      // required bool paused = 4;
       case 4: {
         if (static_cast< ::google::protobuf::uint8>(tag) ==
             static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
-          int value;
+          set_has_paused();
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
-                 input, &value)));
-          if (::message::Entrance_statu_IsValid(value)) {
-            set_entrance_statu(static_cast< ::message::Entrance_statu >(value));
-          } else {
-            mutable_unknown_fields()->AddVarint(
-                4, static_cast< ::google::protobuf::uint64>(value));
-          }
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &paused_)));
         } else {
           goto handle_unusual;
         }
@@ -842,10 +1245,9 @@ void Entrance_manual_operation_msg::SerializeWithCachedSizes(
       3, this->process_type(), output);
   }
 
-  // required .message.Entrance_statu entrance_statu = 4;
+  // required bool paused = 4;
   if (cached_has_bits & 0x00000004u) {
-    ::google::protobuf::internal::WireFormatLite::WriteEnum(
-      4, this->entrance_statu(), output);
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->paused(), output);
   }
 
   if (_internal_metadata_.have_unknown_fields()) {
@@ -881,10 +1283,9 @@ void Entrance_manual_operation_msg::SerializeWithCachedSizes(
       3, this->process_type(), target);
   }
 
-  // required .message.Entrance_statu entrance_statu = 4;
+  // required bool paused = 4;
   if (cached_has_bits & 0x00000004u) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
-      4, this->entrance_statu(), target);
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->paused(), target);
   }
 
   if (_internal_metadata_.have_unknown_fields()) {
@@ -913,10 +1314,9 @@ size_t Entrance_manual_operation_msg::RequiredFieldsByteSizeFallback() const {
         this->terminal_id());
   }
 
-  if (has_entrance_statu()) {
-    // required .message.Entrance_statu entrance_statu = 4;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::EnumSize(this->entrance_statu());
+  if (has_paused()) {
+    // required bool paused = 4;
+    total_size += 1 + 1;
   }
 
   if (has_process_type()) {
@@ -947,9 +1347,8 @@ size_t Entrance_manual_operation_msg::ByteSizeLong() const {
       ::google::protobuf::internal::WireFormatLite::Int32Size(
         this->terminal_id());
 
-    // required .message.Entrance_statu entrance_statu = 4;
-    total_size += 1 +
-      ::google::protobuf::internal::WireFormatLite::EnumSize(this->entrance_statu());
+    // required bool paused = 4;
+    total_size += 1 + 1;
 
     // required .message.Process_type process_type = 3;
     total_size += 1 +
@@ -996,7 +1395,7 @@ void Entrance_manual_operation_msg::MergeFrom(const Entrance_manual_operation_ms
       terminal_id_ = from.terminal_id_;
     }
     if (cached_has_bits & 0x00000004u) {
-      entrance_statu_ = from.entrance_statu_;
+      paused_ = from.paused_;
     }
     if (cached_has_bits & 0x00000008u) {
       process_type_ = from.process_type_;
@@ -1035,7 +1434,7 @@ void Entrance_manual_operation_msg::InternalSwap(Entrance_manual_operation_msg*
   using std::swap;
   swap(base_info_, other->base_info_);
   swap(terminal_id_, other->terminal_id_);
-  swap(entrance_statu_, other->entrance_statu_);
+  swap(paused_, other->paused_);
   swap(process_type_, other->process_type_);
   swap(_has_bits_[0], other->_has_bits_[0]);
   _internal_metadata_.Swap(&other->_internal_metadata_);

message/central_control_message.pb.h

@@ -38,12 +38,14 @@ namespace protobuf_central_5fcontrol_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[3];
+  static const ::google::protobuf::internal::ParseTable schema[4];
   static const ::google::protobuf::internal::FieldMetadata field_metadata[];
   static const ::google::protobuf::internal::SerializationTable serialization_table[];
   static const ::google::protobuf::uint32 offsets[];
 };
 void AddDescriptors();
+void InitDefaultsEntrance_statuImpl();
+void InitDefaultsEntrance_statu();
 void InitDefaultsCentral_controller_statu_msgImpl();
 void InitDefaultsCentral_controller_statu_msg();
 void InitDefaultsEntrance_manual_operation_msgImpl();
@@ -51,6 +53,7 @@ void InitDefaultsEntrance_manual_operation_msg();
 void InitDefaultsProcess_manual_operation_msgImpl();
 void InitDefaultsProcess_manual_operation_msg();
 inline void InitDefaults() {
+  InitDefaultsEntrance_statu();
   InitDefaultsCentral_controller_statu_msg();
   InitDefaultsEntrance_manual_operation_msg();
   InitDefaultsProcess_manual_operation_msg();
@@ -63,32 +66,15 @@ extern Central_controller_statu_msgDefaultTypeInternal _Central_controller_statu
 class Entrance_manual_operation_msg;
 class Entrance_manual_operation_msgDefaultTypeInternal;
 extern Entrance_manual_operation_msgDefaultTypeInternal _Entrance_manual_operation_msg_default_instance_;
+class Entrance_statu;
+class Entrance_statuDefaultTypeInternal;
+extern Entrance_statuDefaultTypeInternal _Entrance_statu_default_instance_;
 class Process_manual_operation_msg;
 class Process_manual_operation_msgDefaultTypeInternal;
 extern Process_manual_operation_msgDefaultTypeInternal _Process_manual_operation_msg_default_instance_;
 }  // namespace message
 namespace message {
 
-enum Entrance_statu {
-  eEnable = 0,
-  eDisable = 1,
-  ePaused = 2
-};
-bool Entrance_statu_IsValid(int value);
-const Entrance_statu Entrance_statu_MIN = eEnable;
-const Entrance_statu Entrance_statu_MAX = ePaused;
-const int Entrance_statu_ARRAYSIZE = Entrance_statu_MAX + 1;
-
-const ::google::protobuf::EnumDescriptor* Entrance_statu_descriptor();
-inline const ::std::string& Entrance_statu_Name(Entrance_statu value) {
-  return ::google::protobuf::internal::NameOfEnum(
-    Entrance_statu_descriptor(), value);
-}
-inline bool Entrance_statu_Parse(
-    const ::std::string& name, Entrance_statu* value) {
-  return ::google::protobuf::internal::ParseNamedEnum<Entrance_statu>(
-    Entrance_statu_descriptor(), name, value);
-}
 enum Process_operation_type {
   eManual_cancel = 0,
   eManual_retry = 1,
@@ -109,8 +95,168 @@ inline bool Process_operation_type_Parse(
   return ::google::protobuf::internal::ParseNamedEnum<Process_operation_type>(
     Process_operation_type_descriptor(), name, value);
 }
+enum Module_statu {
+  eConnected = 0,
+  eDisconnected = 1,
+  eFault = 2
+};
+bool Module_statu_IsValid(int value);
+const Module_statu Module_statu_MIN = eConnected;
+const Module_statu Module_statu_MAX = eFault;
+const int Module_statu_ARRAYSIZE = Module_statu_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Module_statu_descriptor();
+inline const ::std::string& Module_statu_Name(Module_statu value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Module_statu_descriptor(), value);
+}
+inline bool Module_statu_Parse(
+    const ::std::string& name, Module_statu* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Module_statu>(
+    Module_statu_descriptor(), name, value);
+}
 // ===================================================================
 
+class Entrance_statu : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Entrance_statu) */ {
+ public:
+  Entrance_statu();
+  virtual ~Entrance_statu();
+
+  Entrance_statu(const Entrance_statu& from);
+
+  inline Entrance_statu& operator=(const Entrance_statu& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Entrance_statu(Entrance_statu&& from) noexcept
+    : Entrance_statu() {
+    *this = ::std::move(from);
+  }
+
+  inline Entrance_statu& operator=(Entrance_statu&& 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 Entrance_statu& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Entrance_statu* internal_default_instance() {
+    return reinterpret_cast<const Entrance_statu*>(
+               &_Entrance_statu_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(Entrance_statu* other);
+  friend void swap(Entrance_statu& a, Entrance_statu& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Entrance_statu* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Entrance_statu* 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 Entrance_statu& from);
+  void MergeFrom(const Entrance_statu& 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(Entrance_statu* 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 bool paused = 1;
+  bool has_paused() const;
+  void clear_paused();
+  static const int kPausedFieldNumber = 1;
+  bool paused() const;
+  void set_paused(bool value);
+
+  // optional .message.Module_statu parkspace_statu = 2;
+  bool has_parkspace_statu() const;
+  void clear_parkspace_statu();
+  static const int kParkspaceStatuFieldNumber = 2;
+  ::message::Module_statu parkspace_statu() const;
+  void set_parkspace_statu(::message::Module_statu value);
+
+  // optional .message.Module_statu measure_statu = 3;
+  bool has_measure_statu() const;
+  void clear_measure_statu();
+  static const int kMeasureStatuFieldNumber = 3;
+  ::message::Module_statu measure_statu() const;
+  void set_measure_statu(::message::Module_statu value);
+
+  // optional .message.Module_statu dispatch_statu = 4;
+  bool has_dispatch_statu() const;
+  void clear_dispatch_statu();
+  static const int kDispatchStatuFieldNumber = 4;
+  ::message::Module_statu dispatch_statu() const;
+  void set_dispatch_statu(::message::Module_statu value);
+
+  // @@protoc_insertion_point(class_scope:message.Entrance_statu)
+ private:
+  void set_has_paused();
+  void clear_has_paused();
+  void set_has_parkspace_statu();
+  void clear_has_parkspace_statu();
+  void set_has_measure_statu();
+  void clear_has_measure_statu();
+  void set_has_dispatch_statu();
+  void clear_has_dispatch_statu();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  bool paused_;
+  int parkspace_statu_;
+  int measure_statu_;
+  int dispatch_statu_;
+  friend struct ::protobuf_central_5fcontrol_5fmessage_2eproto::TableStruct;
+  friend void ::protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsEntrance_statuImpl();
+};
+// -------------------------------------------------------------------
+
 class Central_controller_statu_msg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:message.Central_controller_statu_msg) */ {
  public:
   Central_controller_statu_msg();
@@ -153,7 +299,7 @@ class Central_controller_statu_msg : public ::google::protobuf::Message /* @@pro
                &_Central_controller_statu_msg_default_instance_);
   }
   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
-    0;
+    1;
 
   void Swap(Central_controller_statu_msg* other);
   friend void swap(Central_controller_statu_msg& a, Central_controller_statu_msg& b) {
@@ -204,21 +350,25 @@ class Central_controller_statu_msg : public ::google::protobuf::Message /* @@pro
   int entrance_statu_vector_size() const;
   void clear_entrance_statu_vector();
   static const int kEntranceStatuVectorFieldNumber = 2;
-  ::message::Entrance_statu entrance_statu_vector(int index) const;
-  void set_entrance_statu_vector(int index, ::message::Entrance_statu value);
-  void add_entrance_statu_vector(::message::Entrance_statu value);
-  const ::google::protobuf::RepeatedField<int>& entrance_statu_vector() const;
-  ::google::protobuf::RepeatedField<int>* mutable_entrance_statu_vector();
+  const ::message::Entrance_statu& entrance_statu_vector(int index) const;
+  ::message::Entrance_statu* mutable_entrance_statu_vector(int index);
+  ::message::Entrance_statu* add_entrance_statu_vector();
+  ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu >*
+      mutable_entrance_statu_vector();
+  const ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu >&
+      entrance_statu_vector() const;
 
   // repeated .message.Entrance_statu export_statu_vector = 3;
   int export_statu_vector_size() const;
   void clear_export_statu_vector();
   static const int kExportStatuVectorFieldNumber = 3;
-  ::message::Entrance_statu export_statu_vector(int index) const;
-  void set_export_statu_vector(int index, ::message::Entrance_statu value);
-  void add_export_statu_vector(::message::Entrance_statu value);
-  const ::google::protobuf::RepeatedField<int>& export_statu_vector() const;
-  ::google::protobuf::RepeatedField<int>* mutable_export_statu_vector();
+  const ::message::Entrance_statu& export_statu_vector(int index) const;
+  ::message::Entrance_statu* mutable_export_statu_vector(int index);
+  ::message::Entrance_statu* add_export_statu_vector();
+  ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu >*
+      mutable_export_statu_vector();
+  const ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu >&
+      export_statu_vector() const;
 
   // required .message.Base_info base_info = 1;
   bool has_base_info() const;
@@ -237,8 +387,8 @@ class Central_controller_statu_msg : public ::google::protobuf::Message /* @@pro
   ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
   ::google::protobuf::internal::HasBits<1> _has_bits_;
   mutable int _cached_size_;
-  ::google::protobuf::RepeatedField<int> entrance_statu_vector_;
-  ::google::protobuf::RepeatedField<int> export_statu_vector_;
+  ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu > entrance_statu_vector_;
+  ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu > export_statu_vector_;
   ::message::Base_info* base_info_;
   friend struct ::protobuf_central_5fcontrol_5fmessage_2eproto::TableStruct;
   friend void ::protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsCentral_controller_statu_msgImpl();
@@ -287,7 +437,7 @@ class Entrance_manual_operation_msg : public ::google::protobuf::Message /* @@pr
                &_Entrance_manual_operation_msg_default_instance_);
   }
   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
-    1;
+    2;
 
   void Swap(Entrance_manual_operation_msg* other);
   friend void swap(Entrance_manual_operation_msg& a, Entrance_manual_operation_msg& b) {
@@ -350,12 +500,12 @@ class Entrance_manual_operation_msg : public ::google::protobuf::Message /* @@pr
   ::google::protobuf::int32 terminal_id() const;
   void set_terminal_id(::google::protobuf::int32 value);
 
-  // required .message.Entrance_statu entrance_statu = 4;
-  bool has_entrance_statu() const;
-  void clear_entrance_statu();
-  static const int kEntranceStatuFieldNumber = 4;
-  ::message::Entrance_statu entrance_statu() const;
-  void set_entrance_statu(::message::Entrance_statu value);
+  // required bool paused = 4;
+  bool has_paused() const;
+  void clear_paused();
+  static const int kPausedFieldNumber = 4;
+  bool paused() const;
+  void set_paused(bool value);
 
   // required .message.Process_type process_type = 3;
   bool has_process_type() const;
@@ -372,8 +522,8 @@ class Entrance_manual_operation_msg : public ::google::protobuf::Message /* @@pr
   void clear_has_terminal_id();
   void set_has_process_type();
   void clear_has_process_type();
-  void set_has_entrance_statu();
-  void clear_has_entrance_statu();
+  void set_has_paused();
+  void clear_has_paused();
 
   // helper for ByteSizeLong()
   size_t RequiredFieldsByteSizeFallback() const;
@@ -383,7 +533,7 @@ class Entrance_manual_operation_msg : public ::google::protobuf::Message /* @@pr
   mutable int _cached_size_;
   ::message::Base_info* base_info_;
   ::google::protobuf::int32 terminal_id_;
-  int entrance_statu_;
+  bool paused_;
   int process_type_;
   friend struct ::protobuf_central_5fcontrol_5fmessage_2eproto::TableStruct;
   friend void ::protobuf_central_5fcontrol_5fmessage_2eproto::InitDefaultsEntrance_manual_operation_msgImpl();
@@ -432,7 +582,7 @@ class Process_manual_operation_msg : public ::google::protobuf::Message /* @@pro
                &_Process_manual_operation_msg_default_instance_);
   }
   static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
-    2;
+    3;
 
   void Swap(Process_manual_operation_msg* other);
   friend void swap(Process_manual_operation_msg& a, Process_manual_operation_msg& b) {
@@ -550,6 +700,109 @@ class Process_manual_operation_msg : public ::google::protobuf::Message /* @@pro
   #pragma GCC diagnostic push
   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif  // __GNUC__
+// Entrance_statu
+
+// required bool paused = 1;
+inline bool Entrance_statu::has_paused() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Entrance_statu::set_has_paused() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Entrance_statu::clear_has_paused() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Entrance_statu::clear_paused() {
+  paused_ = false;
+  clear_has_paused();
+}
+inline bool Entrance_statu::paused() const {
+  // @@protoc_insertion_point(field_get:message.Entrance_statu.paused)
+  return paused_;
+}
+inline void Entrance_statu::set_paused(bool value) {
+  set_has_paused();
+  paused_ = value;
+  // @@protoc_insertion_point(field_set:message.Entrance_statu.paused)
+}
+
+// optional .message.Module_statu parkspace_statu = 2;
+inline bool Entrance_statu::has_parkspace_statu() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Entrance_statu::set_has_parkspace_statu() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Entrance_statu::clear_has_parkspace_statu() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Entrance_statu::clear_parkspace_statu() {
+  parkspace_statu_ = 0;
+  clear_has_parkspace_statu();
+}
+inline ::message::Module_statu Entrance_statu::parkspace_statu() const {
+  // @@protoc_insertion_point(field_get:message.Entrance_statu.parkspace_statu)
+  return static_cast< ::message::Module_statu >(parkspace_statu_);
+}
+inline void Entrance_statu::set_parkspace_statu(::message::Module_statu value) {
+  assert(::message::Module_statu_IsValid(value));
+  set_has_parkspace_statu();
+  parkspace_statu_ = value;
+  // @@protoc_insertion_point(field_set:message.Entrance_statu.parkspace_statu)
+}
+
+// optional .message.Module_statu measure_statu = 3;
+inline bool Entrance_statu::has_measure_statu() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Entrance_statu::set_has_measure_statu() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Entrance_statu::clear_has_measure_statu() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Entrance_statu::clear_measure_statu() {
+  measure_statu_ = 0;
+  clear_has_measure_statu();
+}
+inline ::message::Module_statu Entrance_statu::measure_statu() const {
+  // @@protoc_insertion_point(field_get:message.Entrance_statu.measure_statu)
+  return static_cast< ::message::Module_statu >(measure_statu_);
+}
+inline void Entrance_statu::set_measure_statu(::message::Module_statu value) {
+  assert(::message::Module_statu_IsValid(value));
+  set_has_measure_statu();
+  measure_statu_ = value;
+  // @@protoc_insertion_point(field_set:message.Entrance_statu.measure_statu)
+}
+
+// optional .message.Module_statu dispatch_statu = 4;
+inline bool Entrance_statu::has_dispatch_statu() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Entrance_statu::set_has_dispatch_statu() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Entrance_statu::clear_has_dispatch_statu() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Entrance_statu::clear_dispatch_statu() {
+  dispatch_statu_ = 0;
+  clear_has_dispatch_statu();
+}
+inline ::message::Module_statu Entrance_statu::dispatch_statu() const {
+  // @@protoc_insertion_point(field_get:message.Entrance_statu.dispatch_statu)
+  return static_cast< ::message::Module_statu >(dispatch_statu_);
+}
+inline void Entrance_statu::set_dispatch_statu(::message::Module_statu value) {
+  assert(::message::Module_statu_IsValid(value));
+  set_has_dispatch_statu();
+  dispatch_statu_ = value;
+  // @@protoc_insertion_point(field_set:message.Entrance_statu.dispatch_statu)
+}
+
+// -------------------------------------------------------------------
+
 // Central_controller_statu_msg
 
 // required .message.Base_info base_info = 1;
@@ -609,30 +862,28 @@ inline int Central_controller_statu_msg::entrance_statu_vector_size() const {
 inline void Central_controller_statu_msg::clear_entrance_statu_vector() {
   entrance_statu_vector_.Clear();
 }
-inline ::message::Entrance_statu Central_controller_statu_msg::entrance_statu_vector(int index) const {
+inline const ::message::Entrance_statu& Central_controller_statu_msg::entrance_statu_vector(int index) const {
   // @@protoc_insertion_point(field_get:message.Central_controller_statu_msg.entrance_statu_vector)
-  return static_cast< ::message::Entrance_statu >(entrance_statu_vector_.Get(index));
+  return entrance_statu_vector_.Get(index);
 }
-inline void Central_controller_statu_msg::set_entrance_statu_vector(int index, ::message::Entrance_statu value) {
-  assert(::message::Entrance_statu_IsValid(value));
-  entrance_statu_vector_.Set(index, value);
-  // @@protoc_insertion_point(field_set:message.Central_controller_statu_msg.entrance_statu_vector)
+inline ::message::Entrance_statu* Central_controller_statu_msg::mutable_entrance_statu_vector(int index) {
+  // @@protoc_insertion_point(field_mutable:message.Central_controller_statu_msg.entrance_statu_vector)
+  return entrance_statu_vector_.Mutable(index);
 }
-inline void Central_controller_statu_msg::add_entrance_statu_vector(::message::Entrance_statu value) {
-  assert(::message::Entrance_statu_IsValid(value));
-  entrance_statu_vector_.Add(value);
+inline ::message::Entrance_statu* Central_controller_statu_msg::add_entrance_statu_vector() {
   // @@protoc_insertion_point(field_add:message.Central_controller_statu_msg.entrance_statu_vector)
+  return entrance_statu_vector_.Add();
 }
-inline const ::google::protobuf::RepeatedField<int>&
-Central_controller_statu_msg::entrance_statu_vector() const {
-  // @@protoc_insertion_point(field_list:message.Central_controller_statu_msg.entrance_statu_vector)
-  return entrance_statu_vector_;
-}
-inline ::google::protobuf::RepeatedField<int>*
+inline ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu >*
 Central_controller_statu_msg::mutable_entrance_statu_vector() {
   // @@protoc_insertion_point(field_mutable_list:message.Central_controller_statu_msg.entrance_statu_vector)
   return &entrance_statu_vector_;
 }
+inline const ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu >&
+Central_controller_statu_msg::entrance_statu_vector() const {
+  // @@protoc_insertion_point(field_list:message.Central_controller_statu_msg.entrance_statu_vector)
+  return entrance_statu_vector_;
+}
 
 // repeated .message.Entrance_statu export_statu_vector = 3;
 inline int Central_controller_statu_msg::export_statu_vector_size() const {
@@ -641,30 +892,28 @@ inline int Central_controller_statu_msg::export_statu_vector_size() const {
 inline void Central_controller_statu_msg::clear_export_statu_vector() {
   export_statu_vector_.Clear();
 }
-inline ::message::Entrance_statu Central_controller_statu_msg::export_statu_vector(int index) const {
+inline const ::message::Entrance_statu& Central_controller_statu_msg::export_statu_vector(int index) const {
   // @@protoc_insertion_point(field_get:message.Central_controller_statu_msg.export_statu_vector)
-  return static_cast< ::message::Entrance_statu >(export_statu_vector_.Get(index));
+  return export_statu_vector_.Get(index);
 }
-inline void Central_controller_statu_msg::set_export_statu_vector(int index, ::message::Entrance_statu value) {
-  assert(::message::Entrance_statu_IsValid(value));
-  export_statu_vector_.Set(index, value);
-  // @@protoc_insertion_point(field_set:message.Central_controller_statu_msg.export_statu_vector)
+inline ::message::Entrance_statu* Central_controller_statu_msg::mutable_export_statu_vector(int index) {
+  // @@protoc_insertion_point(field_mutable:message.Central_controller_statu_msg.export_statu_vector)
+  return export_statu_vector_.Mutable(index);
 }
-inline void Central_controller_statu_msg::add_export_statu_vector(::message::Entrance_statu value) {
-  assert(::message::Entrance_statu_IsValid(value));
-  export_statu_vector_.Add(value);
+inline ::message::Entrance_statu* Central_controller_statu_msg::add_export_statu_vector() {
   // @@protoc_insertion_point(field_add:message.Central_controller_statu_msg.export_statu_vector)
+  return export_statu_vector_.Add();
 }
-inline const ::google::protobuf::RepeatedField<int>&
-Central_controller_statu_msg::export_statu_vector() const {
-  // @@protoc_insertion_point(field_list:message.Central_controller_statu_msg.export_statu_vector)
-  return export_statu_vector_;
-}
-inline ::google::protobuf::RepeatedField<int>*
+inline ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu >*
 Central_controller_statu_msg::mutable_export_statu_vector() {
   // @@protoc_insertion_point(field_mutable_list:message.Central_controller_statu_msg.export_statu_vector)
   return &export_statu_vector_;
 }
+inline const ::google::protobuf::RepeatedPtrField< ::message::Entrance_statu >&
+Central_controller_statu_msg::export_statu_vector() const {
+  // @@protoc_insertion_point(field_list:message.Central_controller_statu_msg.export_statu_vector)
+  return export_statu_vector_;
+}
 
 // -------------------------------------------------------------------
 
@@ -769,29 +1018,28 @@ inline void Entrance_manual_operation_msg::set_process_type(::message::Process_t
   // @@protoc_insertion_point(field_set:message.Entrance_manual_operation_msg.process_type)
 }
 
-// required .message.Entrance_statu entrance_statu = 4;
-inline bool Entrance_manual_operation_msg::has_entrance_statu() const {
+// required bool paused = 4;
+inline bool Entrance_manual_operation_msg::has_paused() const {
   return (_has_bits_[0] & 0x00000004u) != 0;
 }
-inline void Entrance_manual_operation_msg::set_has_entrance_statu() {
+inline void Entrance_manual_operation_msg::set_has_paused() {
   _has_bits_[0] |= 0x00000004u;
 }
-inline void Entrance_manual_operation_msg::clear_has_entrance_statu() {
+inline void Entrance_manual_operation_msg::clear_has_paused() {
   _has_bits_[0] &= ~0x00000004u;
 }
-inline void Entrance_manual_operation_msg::clear_entrance_statu() {
-  entrance_statu_ = 0;
-  clear_has_entrance_statu();
+inline void Entrance_manual_operation_msg::clear_paused() {
+  paused_ = false;
+  clear_has_paused();
 }
-inline ::message::Entrance_statu Entrance_manual_operation_msg::entrance_statu() const {
-  // @@protoc_insertion_point(field_get:message.Entrance_manual_operation_msg.entrance_statu)
-  return static_cast< ::message::Entrance_statu >(entrance_statu_);
+inline bool Entrance_manual_operation_msg::paused() const {
+  // @@protoc_insertion_point(field_get:message.Entrance_manual_operation_msg.paused)
+  return paused_;
 }
-inline void Entrance_manual_operation_msg::set_entrance_statu(::message::Entrance_statu value) {
-  assert(::message::Entrance_statu_IsValid(value));
-  set_has_entrance_statu();
-  entrance_statu_ = value;
-  // @@protoc_insertion_point(field_set:message.Entrance_manual_operation_msg.entrance_statu)
+inline void Entrance_manual_operation_msg::set_paused(bool value) {
+  set_has_paused();
+  paused_ = value;
+  // @@protoc_insertion_point(field_set:message.Entrance_manual_operation_msg.paused)
 }
 
 // -------------------------------------------------------------------
@@ -968,6 +1216,8 @@ inline void Process_manual_operation_msg::set_operate_type(::message::Process_op
 
 // -------------------------------------------------------------------
 
+// -------------------------------------------------------------------
+
 
 // @@protoc_insertion_point(namespace_scope)
 
@@ -976,16 +1226,16 @@ inline void Process_manual_operation_msg::set_operate_type(::message::Process_op
 namespace google {
 namespace protobuf {
 
-template <> struct is_proto_enum< ::message::Entrance_statu> : ::google::protobuf::internal::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::message::Entrance_statu>() {
-  return ::message::Entrance_statu_descriptor();
-}
 template <> struct is_proto_enum< ::message::Process_operation_type> : ::google::protobuf::internal::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::message::Process_operation_type>() {
   return ::message::Process_operation_type_descriptor();
 }
+template <> struct is_proto_enum< ::message::Module_statu> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::message::Module_statu>() {
+  return ::message::Module_statu_descriptor();
+}
 
 }  // namespace protobuf
 }  // namespace google

message/central_control_message.proto

@@ -2,13 +2,6 @@ syntax = "proto2";
 package message;
 import "message_base.proto";
 
-//出入口状态
-enum Entrance_statu
-{
-    eEnable=0;                          //出入口关闭
-    eDisable=1;                         //出入口开放
-    ePaused=2;                          //急停
-}
 
 //针对流程的手动操作类型
 enum Process_operation_type
@@ -18,6 +11,21 @@ enum Process_operation_type
     eManual_ignore=2;                   //忽略
 }
 
+enum Module_statu
+{
+    eConnected=0;               //连接
+    eDisconnected=1;            //连接丢失
+    eFault=2;                   //故障
+}
+
+//出入口状态
+message Entrance_statu
+{
+    required    bool                paused=1;
+    optional    Module_statu        parkspace_statu=2;
+    optional    Module_statu        measure_statu=3;
+    optional    Module_statu        dispatch_statu=4;
+}
 
 //中控状态消息
 message Central_controller_statu_msg
@@ -27,13 +35,13 @@ message Central_controller_statu_msg
     repeated Entrance_statu             export_statu_vector=3;      //出口状态
 }
 
-//出入口手动操作消息
+//出入口手动急停/启动消息
 message Entrance_manual_operation_msg
 {
     required Base_info                  base_info=1;
     required int32                      terminal_id=2;
     required Process_type               process_type=3;
-    required Entrance_statu             entrance_statu=4;           //要修改的出入口状态
+    required bool                       paused=4;           //是否急停
 }
 
 //流程手动操作消息

system/PickupProcessTask.cpp

@@ -76,8 +76,13 @@ Error_manager PickupProcessTask::search_space_step()
     {
         return Error_manager(PAUSE, MINOR_ERROR, "系统已急停");
     }
-    //
-    if(Command_manager::get_instance_pointer()->export_statu(m_terminor_id)!=Command_manager::Enable) {
+
+    message::Entrance_statu statu=Command_manager::get_instance_pointer()->export_statu(m_terminor_id);
+    if(statu.has_paused()==false) {
+        return Error_manager(ERROR, MINOR_ERROR, "出口已禁止使用 Disable");
+    }
+    if(statu.paused()==true)
+    {
         return Error_manager(ERROR, MINOR_ERROR, "出口已禁止使用 Disable");
     }
 
@@ -87,7 +92,7 @@ Error_manager PickupProcessTask::search_space_step()
     if(m_car_info.has_car_width()==false||m_car_info.has_car_height()== false
         ||m_car_info.has_license()==false)
     {
-        return Error_manager(INVALID_MESSAGE,CRITICAL_ERROR,"查询车位请求汽车信息错误");
+        return Error_manager(INVALID_MESSAGE,CRITICAL_ERROR,"查询车位请求信息错误");
     }
 
     /*

system/StoreProcessTask.cpp

@@ -203,7 +203,12 @@ Error_manager StoreProcessTask::alloc_space_step()
         return Error_manager(PAUSE, MINOR_ERROR, "系统已急停");
     }
     //
-    if(Command_manager::get_instance_pointer()->entrance_statu(m_terminor_id)!=Command_manager::Enable) {
+    message::Entrance_statu statu=Command_manager::get_instance_pointer()->entrance_statu(m_terminor_id);
+    if(statu.has_paused()==false) {
+        return Error_manager(ERROR, MINOR_ERROR, "入口已禁止使用 Disable");
+    }
+    if(statu.paused()==true)
+    {
         return Error_manager(ERROR, MINOR_ERROR, "入口已禁止使用 Disable");
     }
 

system/command_manager.cpp

@@ -51,12 +51,12 @@ Error_manager Command_manager::init(setting::System_setting system_setting) {
         return Error_manager(ERROR, MAJOR_ERROR, "系统配置出入口数量错误");
     }
     //初始化出入口状态为 Enable
-    m_input_entrance_statu.resize(system_setting.entrance_num());
+    m_output_entrance_paused.resize(system_setting.entrance_num());
     for(int i=0;i<system_setting.entrance_num();++i)
-        m_input_entrance_statu[i]=Enable;
-    m_output_entrance_statu.resize(system_setting.export_num());
+        m_output_entrance_paused[i]=false;
+    m_output_entrance_paused.resize(system_setting.export_num());
     for(int i=0;i<system_setting.export_num();++i)
-        m_output_entrance_statu[i]=Enable;
+        m_output_entrance_paused[i]=false;
 
     //创建线程池
     if (m_thread_queue_process == nullptr) {
@@ -277,7 +277,7 @@ Error_manager Command_manager::execute_pickup_command(message::Pickup_command_re
         response.mutable_code()->CopyFrom(error_msg);
         return Error_manager(ERROR, MINOR_ERROR, "出口 id 设置错误");
     }
-    if(m_output_entrance_statu[request.terminal_id()]!=Enable)
+    if(m_output_entrance_paused[request.terminal_id()]!=false)
     {
         error_msg.set_error_code(ERROR);
         error_msg.set_error_description("中控出口已停止使用");
@@ -353,34 +353,70 @@ Error_manager Command_manager::execute_pickup_command(message::Pickup_command_re
 /*
     * 控制入口 开放或者关闭
     */
-Error_manager Command_manager::enable_entrance(int terminal_id,Entrance_statu statu)
+Error_manager Command_manager::pause_entrance(int terminal_id,bool paused)
 {
     if(terminal_id<0 || terminal_id>m_system_setting.entrance_num())
         return Error_manager(ERROR,MINOR_ERROR,"xxxx");
-    m_input_entrance_statu[terminal_id]=statu;
+    m_input_entrance_paused[terminal_id]=paused;
     return SUCCESS;
 }
 
-Command_manager::Entrance_statu Command_manager::entrance_statu(int terminal_id)
+message::Entrance_statu Command_manager::entrance_statu(int terminal_id)
 {
+    message::Entrance_statu entrance_statu;
+
     if(terminal_id<0 || terminal_id>=m_system_setting.entrance_num())
-        return Disable;
-    return m_input_entrance_statu[terminal_id];
+        return entrance_statu;
+
+    message::Module_statu  statu=message::eConnected;
+    Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
+    statu=(code==SUCCESS)?message::eConnected:message::eFault;
+    entrance_statu.set_parkspace_statu(statu);
+
+    code=Measure_excutor::get_instance_pointer()->check_statu(terminal_id);
+    if (code==ERROR) statu=message::eFault;
+    if(code==DISCONNECT) statu=message::eDisconnected;
+    entrance_statu.set_measure_statu(statu);
+
+    code=Dispatch_excutor::get_instance_pointer()->check_entrance_statu(terminal_id);
+    if (code==ERROR) statu=message::eFault;
+    if(code==DISCONNECT) statu=message::eDisconnected;
+    entrance_statu.set_dispatch_statu(statu);
+
+    entrance_statu.set_paused(m_input_entrance_paused[terminal_id]);
+
+
+    return entrance_statu;
 }
-Command_manager::Entrance_statu Command_manager::export_statu(int terminal_id)
+message::Entrance_statu Command_manager::export_statu(int terminal_id)
 {
+    message::Entrance_statu entrance_statu;
     if(terminal_id<0 || terminal_id>=m_system_setting.export_num())
-        return Disable;
-    return m_output_entrance_statu[terminal_id];
+        return entrance_statu;
+
+    message::Module_statu  statu=message::eConnected;
+    Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
+    statu=(code==SUCCESS)?message::eConnected:message::eFault;
+    entrance_statu.set_parkspace_statu(statu);
+
+    code=Dispatch_excutor::get_instance_pointer()->check_entrance_statu(terminal_id);
+    if (code==ERROR) statu=message::eFault;
+    if(code==DISCONNECT) statu=message::eDisconnected;
+    entrance_statu.set_dispatch_statu(statu);
+
+    entrance_statu.set_paused(m_input_entrance_paused[terminal_id]);
+
+    return entrance_statu;
 }
 /*
  * 控制出口 开放或者关闭
  */
-Error_manager Command_manager::enable_export(int terminal_id,Entrance_statu statu)
+Error_manager Command_manager::pause_export(int terminal_id,bool paused)
 {
     if(terminal_id<0 || terminal_id>m_system_setting.export_num())
         return Error_manager(ERROR,MINOR_ERROR,"xxxx");
-    m_output_entrance_statu[terminal_id]=statu;
+    m_output_entrance_paused[terminal_id]=paused;
+    return SUCCESS;
 }
 
 /*
@@ -410,15 +446,44 @@ void Command_manager::publish_statu()
         for(int i=0;i<m_system_setting.entrance_num();++i)
         {
             message::Entrance_statu entrance_statu;
-            entrance_statu=message::Entrance_statu (m_input_entrance_statu[i]);
-            msg.add_entrance_statu_vector(entrance_statu);
+            message::Module_statu  statu=message::eConnected;
+            Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
+            statu=(code==SUCCESS)?message::eConnected:message::eFault;
+            entrance_statu.set_parkspace_statu(statu);
+
+            code=Measure_excutor::get_instance_pointer()->check_statu(i);
+            if (code==ERROR) statu=message::eFault;
+            if(code==DISCONNECT) statu=message::eDisconnected;
+            entrance_statu.set_measure_statu(statu);
+
+            code=Dispatch_excutor::get_instance_pointer()->check_entrance_statu(i);
+            if (code==ERROR) statu=message::eFault;
+            if(code==DISCONNECT) statu=message::eDisconnected;
+            entrance_statu.set_dispatch_statu(statu);
+
+            entrance_statu.set_paused(m_input_entrance_paused[i]);
+
+            msg.mutable_export_statu_vector()->Add();
+            msg.mutable_export_statu_vector(msg.export_statu_vector_size()-1)->CopyFrom(entrance_statu);
         }
 
         for(int i=0;i<m_system_setting.export_num();++i)
         {
             message::Entrance_statu entrance_statu;
-            entrance_statu=message::Entrance_statu (m_input_entrance_statu[i]);
-            msg.add_export_statu_vector(entrance_statu);
+            message::Module_statu  statu=message::eConnected;
+            Error_manager code=Parkspace_excutor::get_instance_pointer()->check_statu();
+            statu=(code==SUCCESS)?message::eConnected:message::eFault;
+            entrance_statu.set_parkspace_statu(statu);
+
+            code=Dispatch_excutor::get_instance_pointer()->check_export_statu(i);
+            if (code==ERROR) statu=message::eFault;
+            if(code==DISCONNECT) statu=message::eDisconnected;
+            entrance_statu.set_dispatch_statu(statu);
+
+            entrance_statu.set_paused(m_output_entrance_paused[i]);
+
+            msg.mutable_export_statu_vector()->Add();
+            msg.mutable_export_statu_vector(msg.export_statu_vector_size()-1)->CopyFrom(entrance_statu);
         }
         Command_accepter::get_instance_pointer()->post_central_statu(msg);
     }

system/command_manager.h

@@ -22,13 +22,6 @@
 
 class Command_manager :public Singleton<Command_manager>{
     friend Singleton<Command_manager>;
-public:
-    enum Entrance_statu
-    {
-        Enable=0,
-        Disable,
-        Paused,
-    };
 public:
     ~Command_manager();
 
@@ -50,17 +43,18 @@ public:
     /*
      * 控制入口 开放或者关闭
      */
-    Error_manager enable_entrance(int terminal_id,Entrance_statu statu);
+    Error_manager pause_entrance(int terminal_id,bool paused);
+
     /*
      * 获取出入口状态
      */
-    Entrance_statu entrance_statu(int terminal_id);
-    Entrance_statu export_statu(int terminal_id);
+    message::Entrance_statu entrance_statu(int terminal_id);
+    message::Entrance_statu export_statu(int terminal_id);
 
     /*
      * 控制出口 开放或者关闭
      */
-    Error_manager enable_export(int terminal_id, Entrance_statu statu);
+    Error_manager pause_export(int terminal_id, bool paused);
 
     /*
      * pause,系统急停,急停状态下不允许自动流程的指令执行,允许管理员手动指令执行
@@ -82,8 +76,8 @@ protected:
     tq::IQueue*                         m_thread_queue_process;         //指令流程线程池
 
     bool                                m_system_paused;
-    std::vector<Entrance_statu>         m_input_entrance_statu;     //入口状态(关闭/开放)
-    std::vector<Entrance_statu>         m_output_entrance_statu;    //出口状态(关闭/开放)
+    std::vector<bool>                   m_input_entrance_paused;     //入口状态(关闭/开放)
+    std::vector<bool>                   m_output_entrance_paused;    //出口状态(关闭/开放)
 
     setting::System_setting             m_system_setting;