V0.36.2.250626_alpha:为XNCore添加了规范的出错信息

Release/include/XNCore/XNDDSInterface.h

@@ -75,7 +75,7 @@ protected:
 			}
 		} else {
 			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 78");
+						  "A01161001:T 必须是算术类型或std::array类型");
 		}
 
 		return result;
@@ -109,7 +109,7 @@ protected:
 			setByteArrayFromStdArray(data.value(), thisArray);
 		} else {
 			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 112");
+						  "A01161002:T 必须是算术类型或std::array类型");
 		}
 	}
 
@@ -132,7 +132,7 @@ protected:
 							getTypeSize<T>());
 			} else {
 				static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-							  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 135");
+							  "A01161003:T 必须是算术类型或std::array类型");
 			}
 		}
 
@@ -158,7 +158,7 @@ protected:
 				setByteArrayFromStdArray(data[i], subArray);
 			} else {
 				static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-							  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 160");
+							  "A01161004:T 必须是算术类型或std::array类型");
 			}
 		}
 	}
@@ -186,7 +186,7 @@ protected:
 			}
 		} else {
 			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 188");
+						  "A01161005:T 必须是算术类型或std::array类型");
 		}
 		return std::string();
 	}
@@ -214,6 +214,7 @@ protected:
 				items.push_back(item);
 			}
 			if (items.size() != getArrayWholeSize<T>()) {
+				LOG_WARNING("A01163006:数组大小不一致, 设置数据失败!");
 				return;
 			}
 			T temp;
@@ -221,7 +222,7 @@ protected:
 			data = temp;
 		} else {
 			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 220");
+						  "A01161007:T 必须是算术类型或std::array类型");
 		}
 	}
 
@@ -249,7 +250,7 @@ protected:
 				ss << getStringFromStdArray(data[i]);
 			} else {
 				static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-							  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 243");
+							  "A01161008:T 必须是算术类型或std::array类型");
 			}
 		}
 		return ss.str();
@@ -281,13 +282,11 @@ protected:
 					// 对于嵌套数组，递归处理
 					start_pos = setStdArrayFromString(data[i], value, start_pos);
 				} else {
-					static_assert(
+					static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						std::is_arithmetic_v<T> || is_std_array_v<T>,
+								  "A01161009:T 必须是算术类型或std::array类型");
-						"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 275");
 				}
 			} catch (const std::exception &e) {
-				throw std::runtime_error("无法解析第 " + std::to_string(i)
+				LOG_WARNING("A01163010:无法解析第 %1 个元素: %2", i, e.what());
-										 + " 个元素: " + e.what());
 			}
 		}
 		return start_pos + N;
@@ -299,10 +298,9 @@ protected:
 		if (data) {
 			auto temp = data.value();
 			if constexpr (std::is_arithmetic_v<T1>) {
-				static_assert(std::is_arithmetic_v<T2>,
+				static_assert(std::is_arithmetic_v<T2>, "A01161011:模板参数T2必须是算术类型");
-							  "模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 293");
 				static_assert(std::is_convertible_v<T1, T2>,
-							  "模板参数T1必须可以转换为T2类型，详见XNDDSInterface.cpp：line 295");
+							  "A01161012:模板参数T1必须可以转换为T2类型");
 				model_data = temp;
 			} else if constexpr (is_std_array_v<T1>) {
 				size_t arraySize = array_size_v<T1>;
@@ -320,21 +318,19 @@ protected:
 							}
 						} else {
 							static_assert(std::is_arithmetic_v<sub_array_type>,
-										  "模板参数T1是std::"
+										  "A01161013:模板参数T1是std::"
-										  "array类型时，它的数组嵌套不能超过两层，详见XNDDSInterfac"
+										  "array类型时，它的数组嵌套不能超过两层");
-										  "e.cpp：line 313");
 						}
 					} else {
-						static_assert(
+						static_assert(std::is_arithmetic_v<array_type>
-							std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
+										  || is_std_array_v<array_type>,
-							"模板参数T1是std::array类型时，它的value_"
+									  "A01161014:模板参数T1是std::array类型时，它的value_"
-							"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 320");
+									  "type必须是算术类型或std::array类型");
 					}
 				}
 			} else {
-				static_assert(
+				static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
-					std::is_arithmetic_v<T1> || is_std_array_v<T1>,
+							  "A01161015:模板参数T1必须是算术类型或std::array类型");
-					"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 326");
 			}
 		}
 	}
@@ -343,10 +339,9 @@ protected:
 	void assign_value_set(eprosima::fastcdr::optional<T1> &data, const T2 &model_data)
 	{
 		if constexpr (std::is_arithmetic_v<T1>) {
-			static_assert(std::is_arithmetic_v<T2>,
+			static_assert(std::is_arithmetic_v<T2>, "A01161016:模板参数T2必须是算术类型");
-						  "模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 337");
 			static_assert(std::is_convertible_v<T2, T1>,
-						  "模板参数T2必须可以转换为T1类型，详见XNDDSInterface.cpp：line 339");
+						  "A01161017:模板参数T2必须可以转换为T1类型");
 			data = model_data;
 		} else if constexpr (is_std_array_v<T1>) {
 			T1 temp;
@@ -363,23 +358,20 @@ protected:
 							temp[i][j] = model_data[i][j];
 						}
 					} else {
-						static_assert(std::is_arithmetic_v<sub_array_type>,
+						static_assert(
-									  "模板参数T1是std::"
+							std::is_arithmetic_v<sub_array_type>,
-									  "array类型时，它的数组嵌套不能超过两层，详见XNDDSInterface."
+							"A01161018:模板参数T1是std::array类型时，它的数组嵌套不能超过两层");
-									  "cpp：line 357");
 					}
 				} else {
-					static_assert(
+					static_assert(std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
-						std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
+								  "A01161019:模板参数T1是std::array类型时，它的value_"
-						"模板参数T1是std::array类型时，它的value_"
+								  "type必须是算术类型或std::array类型");
-						"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 364");
 				}
 			}
 			data = temp;
 		} else {
-			static_assert(
+			static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
-				std::is_arithmetic_v<T1> || is_std_array_v<T1>,
+						  "A01161020:模板参数T1必须是算术类型或std::array类型");
-				"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 371");
 		}
 	}
 

Release/include/XNCore/XNDDSManager.h

@@ -77,7 +77,7 @@ public:
 			tmp.topic = d->participant_->create_topic(topicName, typeSupport.get_type_name(),
 													  FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
 			if (tmp.topic == nullptr) {
-				LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
+				LOG_ERROR("C01102001:创建主题 %1 失败!", topicName);
 				d->topics_.erase(topicName);
 				return nullptr;
 			}
@@ -87,7 +87,7 @@ public:
 		tmp.publishers_[publisherID].publisher =
 			d->participant_->create_publisher(FAST_DDS_MACRO::PUBLISHER_QOS_DEFAULT, nullptr);
 		if (tmp.publishers_[publisherID].publisher == nullptr) {
-			LOG_ERROR("0x2131 Create Publisher %1 for Topic %2 Failed!", publisherID, topicName);
+			LOG_ERROR("C01102002:创建主题 %1 的发布者 %2 失败!", topicName, publisherID);
 			return nullptr;
 		}
 
@@ -107,10 +107,11 @@ public:
 			tmp.publishers_[publisherID].publisher->create_datawriter(tmp.topic, dataWriterQos,
 																	  nullptr);
 		if (tmp.publishers_[publisherID].dataWriter == nullptr) {
-			LOG_ERROR("0x2132 Create DataWriter %1 for Topic %2 Failed!", publisherID, topicName);
+			LOG_ERROR("C01102003:创建主题 %1 的发布者 %2 的数据写入器失败!", topicName,
+					  publisherID);
 			return nullptr;
 		}
-		LOG_INFO("0x2133 Create Publisher %1 for Topic %2 Success!", publisherID, topicName);
+		LOG_INFO("D01104004:创建主题 %1 的发布者 %2 的数据写入器成功!", topicName, publisherID);
 		return tmp.publishers_[publisherID].dataWriter;
 	}
 
@@ -128,7 +129,7 @@ public:
 			tmp.topic = d->participant_->create_topic(topicName, typeSupport.get_type_name(),
 													  FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
 			if (tmp.topic == nullptr) {
-				LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
+				LOG_ERROR("C01102005:创建主题 %1 失败!", topicName);
 				d->topics_.erase(topicName);
 				return;
 			}
@@ -138,7 +139,7 @@ public:
 		tmp.subscribers_[subscriberID].subscriber =
 			d->participant_->create_subscriber(FAST_DDS_MACRO::SUBSCRIBER_QOS_DEFAULT, nullptr);
 		if (tmp.subscribers_[subscriberID].subscriber == nullptr) {
-			LOG_ERROR("0x2135 Create Subscriber %1 for Topic %2 Failed!", subscriberID, topicName);
+			LOG_ERROR("C01102006:创建主题 %1 的订阅者 %2 失败!", topicName, subscriberID);
 		}
 		FAST_DDS_MACRO::DataReaderQos dataReaderQos;
 		dataReaderQos.durability().kind = FAST_DDS_MACRO::VOLATILE_DURABILITY_QOS;
@@ -148,8 +149,9 @@ public:
 			tmp.subscribers_[subscriberID].subscriber->create_datareader(tmp.topic, dataReaderQos,
 																		 listener);
 		if (tmp.subscribers_[subscriberID].dataReader == nullptr) {
-			LOG_ERROR("0x2136 Create DataReader %1 for Topic %2 Failed!", subscriberID, topicName);
+			LOG_ERROR("C01102007:创建主题 %1 的订阅者 %2 的数据读取器失败!", topicName,
+					  subscriberID);
 		}
-		LOG_INFO("0x2137 Create Subscriber %1 for Topic %2 Success!", subscriberID, topicName);
+		LOG_INFO("D01104008:创建主题 %1 的订阅者 %2 的数据读取器成功!", topicName, subscriberID);
 	}
 };

Release/include/XNCore/XNScenarioManager.h

@@ -1,7 +1,7 @@
 /**
  * @file XNScenarioDescriptor.h
  * @author	jinchao
- * @brief 运行环境描述管理器类头文件
+ * @brief 构型管理器类头文件
  * @version	1.0
  * @date 2024-11-07
  *
@@ -14,8 +14,8 @@
 struct XNScenarioManagerPrivate;
 
 /**
- * @brief 运行环境描述管理器类
+ * @brief 构型管理器类
- * @details 主要负责解析运行环境配置文件来设置系统运行参数。
+ * @details 主要负责解析构型配置来设置系统运行参数。
  */
 class XNScenarioManager : public XNBaseFrameObject
 {
@@ -23,18 +23,18 @@ class XNScenarioManager : public XNBaseFrameObject
 	XN_DECLARE_PRIVATE(XNScenarioManager)
 public:
 	/**
-	 * @brief 运行环境描述管理器类默认构造函数
+	 * @brief 构型管理器类默认构造函数
 	 */
 	XNScenarioManager();
 
 	/**
-	 * @brief 运行环境描述管理器类析构函数
+	 * @brief 构型管理器类析构函数
 	 */
 	virtual ~XNScenarioManager();
 
 protected:
 	/**
-	 * @brief 运行环境描述管理器类带参构造函数
+	 * @brief 构型管理器类带参构造函数
 	 * @param p:私有结构体指针
 	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
 	 */
@@ -55,22 +55,22 @@ public:
 
 public:
 	/**
-	 * @brief 初始化运行环境描述管理器
+	 * @brief 初始化构型管理器
 	 * @return true:	初始化成功
 	 * @return false:	初始化失败
-	 * @details	运行环境描述管理器的初始化接口函数
+	 * @details	构型管理器的初始化接口函数
 	 */
 	virtual bool Initialize() override;
 
 	/**
 	 * @brief 仿真运行前最后处理
-	 * @note  运行环境描述管理器在系统运行开始前的准备工作
+	 * @note  构型管理器在系统运行开始前的准备工作
 	 */
 	virtual bool PrepareForExecute() override;
 
 	/**
-	 * @brief 运行环境配置文件解析
+	 * @brief 构型配置文件解析
-	 * @param XmlPath:	std::string类型，运行环境配置文件解析路径
+	 * @param XmlPath:	std::string类型，构型配置文件解析路径
 	 * @param initialType:	uint32_t类型，初始化类型
 	 * @return true:	解析成功
 	 * @return false:	解析失败
@@ -79,16 +79,16 @@ public:
 
 private:
 	/**
-	 * @brief 解析运行环境配置文件
+	 * @brief 解析构型配置文件
-	 * @param XmlPath:	std::string类型，运行环境配置文件解析路径
+	 * @param XmlPath:	std::string类型，构型配置文件解析路径
 	 * @return true:	解析成功
 	 * @return false:	解析失败
 	 */
 	bool ParseScenarioXml(const std::string &XmlPath);
 
 	/**
-	 * @brief 解析构型配置文件
+	 * @brief 解析数据库构型配置
-	 * @param ConfigID:	std::string类型，构型配置文件在数据库中的ID
+	 * @param ConfigID:	std::string类型，构型配置在数据库中的ID
 	 * @return true:	解析成功
 	 * @return false:	解析失败
 	 */

XNCore/XNDDSInterface.h

@@ -75,7 +75,7 @@ protected:
 			}
 		} else {
 			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 78");
+						  "A01161001:T 必须是算术类型或std::array类型");
 		}
 
 		return result;
@@ -109,7 +109,7 @@ protected:
 			setByteArrayFromStdArray(data.value(), thisArray);
 		} else {
 			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 112");
+						  "A01161002:T 必须是算术类型或std::array类型");
 		}
 	}
 
@@ -132,7 +132,7 @@ protected:
 							getTypeSize<T>());
 			} else {
 				static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-							  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 135");
+							  "A01161003:T 必须是算术类型或std::array类型");
 			}
 		}
 
@@ -158,7 +158,7 @@ protected:
 				setByteArrayFromStdArray(data[i], subArray);
 			} else {
 				static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-							  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 160");
+							  "A01161004:T 必须是算术类型或std::array类型");
 			}
 		}
 	}
@@ -186,7 +186,7 @@ protected:
 			}
 		} else {
 			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 188");
+						  "A01161005:T 必须是算术类型或std::array类型");
 		}
 		return std::string();
 	}
@@ -214,6 +214,7 @@ protected:
 				items.push_back(item);
 			}
 			if (items.size() != getArrayWholeSize<T>()) {
+				LOG_WARNING("A01163006:数组大小不一致, 设置数据失败!");
 				return;
 			}
 			T temp;
@@ -221,7 +222,7 @@ protected:
 			data = temp;
 		} else {
 			static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 220");
+						  "A01161007:T 必须是算术类型或std::array类型");
 		}
 	}
 
@@ -249,7 +250,7 @@ protected:
 				ss << getStringFromStdArray(data[i]);
 			} else {
 				static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-							  "T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 243");
+							  "A01161008:T 必须是算术类型或std::array类型");
 			}
 		}
 		return ss.str();
@@ -281,13 +282,11 @@ protected:
 					// 对于嵌套数组，递归处理
 					start_pos = setStdArrayFromString(data[i], value, start_pos);
 				} else {
-					static_assert(
+					static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
-						std::is_arithmetic_v<T> || is_std_array_v<T>,
+								  "A01161009:T 必须是算术类型或std::array类型");
-						"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 275");
 				}
 			} catch (const std::exception &e) {
-				throw std::runtime_error("无法解析第 " + std::to_string(i)
+				LOG_WARNING("A01163010:无法解析第 %1 个元素: %2", i, e.what());
-										 + " 个元素: " + e.what());
 			}
 		}
 		return start_pos + N;
@@ -299,10 +298,9 @@ protected:
 		if (data) {
 			auto temp = data.value();
 			if constexpr (std::is_arithmetic_v<T1>) {
-				static_assert(std::is_arithmetic_v<T2>,
+				static_assert(std::is_arithmetic_v<T2>, "A01161011:模板参数T2必须是算术类型");
-							  "模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 293");
 				static_assert(std::is_convertible_v<T1, T2>,
-							  "模板参数T1必须可以转换为T2类型，详见XNDDSInterface.cpp：line 295");
+							  "A01161012:模板参数T1必须可以转换为T2类型");
 				model_data = temp;
 			} else if constexpr (is_std_array_v<T1>) {
 				size_t arraySize = array_size_v<T1>;
@@ -320,21 +318,19 @@ protected:
 							}
 						} else {
 							static_assert(std::is_arithmetic_v<sub_array_type>,
-										  "模板参数T1是std::"
+										  "A01161013:模板参数T1是std::"
-										  "array类型时，它的数组嵌套不能超过两层，详见XNDDSInterfac"
+										  "array类型时，它的数组嵌套不能超过两层");
-										  "e.cpp：line 313");
 						}
 					} else {
-						static_assert(
+						static_assert(std::is_arithmetic_v<array_type>
-							std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
+										  || is_std_array_v<array_type>,
-							"模板参数T1是std::array类型时，它的value_"
+									  "A01161014:模板参数T1是std::array类型时，它的value_"
-							"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 320");
+									  "type必须是算术类型或std::array类型");
 					}
 				}
 			} else {
-				static_assert(
+				static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
-					std::is_arithmetic_v<T1> || is_std_array_v<T1>,
+							  "A01161015:模板参数T1必须是算术类型或std::array类型");
-					"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 326");
 			}
 		}
 	}
@@ -343,10 +339,9 @@ protected:
 	void assign_value_set(eprosima::fastcdr::optional<T1> &data, const T2 &model_data)
 	{
 		if constexpr (std::is_arithmetic_v<T1>) {
-			static_assert(std::is_arithmetic_v<T2>,
+			static_assert(std::is_arithmetic_v<T2>, "A01161016:模板参数T2必须是算术类型");
-						  "模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 337");
 			static_assert(std::is_convertible_v<T2, T1>,
-						  "模板参数T2必须可以转换为T1类型，详见XNDDSInterface.cpp：line 339");
+						  "A01161017:模板参数T2必须可以转换为T1类型");
 			data = model_data;
 		} else if constexpr (is_std_array_v<T1>) {
 			T1 temp;
@@ -363,23 +358,20 @@ protected:
 							temp[i][j] = model_data[i][j];
 						}
 					} else {
-						static_assert(std::is_arithmetic_v<sub_array_type>,
+						static_assert(
-									  "模板参数T1是std::"
+							std::is_arithmetic_v<sub_array_type>,
-									  "array类型时，它的数组嵌套不能超过两层，详见XNDDSInterface."
+							"A01161018:模板参数T1是std::array类型时，它的数组嵌套不能超过两层");
-									  "cpp：line 357");
 					}
 				} else {
-					static_assert(
+					static_assert(std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
-						std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
+								  "A01161019:模板参数T1是std::array类型时，它的value_"
-						"模板参数T1是std::array类型时，它的value_"
+								  "type必须是算术类型或std::array类型");
-						"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 364");
 				}
 			}
 			data = temp;
 		} else {
-			static_assert(
+			static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
-				std::is_arithmetic_v<T1> || is_std_array_v<T1>,
+						  "A01161020:模板参数T1必须是算术类型或std::array类型");
-				"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 371");
 		}
 	}
 

XNCore/XNDDSManager.cpp

@@ -20,7 +20,7 @@ bool XNDDSManager::Initialize()
 	d->_status		= XNFrameObjectStatus::Initialized;
 	d->participant_ = nullptr;
 	d->topics_.clear();
-	LOG_INFO("DDS管理器初始化成功!");
+	LOG_INFO("D01104009:DDS管理器初始化成功!");
 	return true;
 }
 
@@ -28,7 +28,7 @@ bool XNDDSManager::PrepareForExecute()
 {
 	T_D();
 	d->_status = XNFrameObjectStatus::Ready;
-	LOG_INFO("DDS管理器准备就绪!");
+	LOG_INFO("D01104010:DDS管理器准备就绪!");
 	return true;
 }
 
@@ -40,6 +40,7 @@ void XNDDSManager::SetDomainID(uint32_t domainID)
 	d->participant_ = FAST_DDS_MACRO::DomainParticipantFactory::get_instance()->create_participant(
 		domainID, participantQos);
 	if (d->participant_ == nullptr) {
-		LOG_ERROR("0x2130 DDS管理器创建域参与者失败!");
+		LOG_ERROR("C01102011:DDS管理器创建域参与者失败!");
 	}
+	LOG_INFO("D01104012:DDS管理器创建域参与者成功!");
 }

XNCore/XNDDSManager.h

@@ -77,7 +77,7 @@ public:
 			tmp.topic = d->participant_->create_topic(topicName, typeSupport.get_type_name(),
 													  FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
 			if (tmp.topic == nullptr) {
-				LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
+				LOG_ERROR("C01102001:创建主题 %1 失败!", topicName);
 				d->topics_.erase(topicName);
 				return nullptr;
 			}
@@ -87,7 +87,7 @@ public:
 		tmp.publishers_[publisherID].publisher =
 			d->participant_->create_publisher(FAST_DDS_MACRO::PUBLISHER_QOS_DEFAULT, nullptr);
 		if (tmp.publishers_[publisherID].publisher == nullptr) {
-			LOG_ERROR("0x2131 Create Publisher %1 for Topic %2 Failed!", publisherID, topicName);
+			LOG_ERROR("C01102002:创建主题 %1 的发布者 %2 失败!", topicName, publisherID);
 			return nullptr;
 		}
 
@@ -107,10 +107,11 @@ public:
 			tmp.publishers_[publisherID].publisher->create_datawriter(tmp.topic, dataWriterQos,
 																	  nullptr);
 		if (tmp.publishers_[publisherID].dataWriter == nullptr) {
-			LOG_ERROR("0x2132 Create DataWriter %1 for Topic %2 Failed!", publisherID, topicName);
+			LOG_ERROR("C01102003:创建主题 %1 的发布者 %2 的数据写入器失败!", topicName,
+					  publisherID);
 			return nullptr;
 		}
-		LOG_INFO("0x2133 Create Publisher %1 for Topic %2 Success!", publisherID, topicName);
+		LOG_INFO("D01104004:创建主题 %1 的发布者 %2 的数据写入器成功!", topicName, publisherID);
 		return tmp.publishers_[publisherID].dataWriter;
 	}
 
@@ -128,7 +129,7 @@ public:
 			tmp.topic = d->participant_->create_topic(topicName, typeSupport.get_type_name(),
 													  FAST_DDS_MACRO::TOPIC_QOS_DEFAULT);
 			if (tmp.topic == nullptr) {
-				LOG_ERROR("0x2130 Create Topic %1 Failed!", topicName);
+				LOG_ERROR("C01102005:创建主题 %1 失败!", topicName);
 				d->topics_.erase(topicName);
 				return;
 			}
@@ -138,7 +139,7 @@ public:
 		tmp.subscribers_[subscriberID].subscriber =
 			d->participant_->create_subscriber(FAST_DDS_MACRO::SUBSCRIBER_QOS_DEFAULT, nullptr);
 		if (tmp.subscribers_[subscriberID].subscriber == nullptr) {
-			LOG_ERROR("0x2135 Create Subscriber %1 for Topic %2 Failed!", subscriberID, topicName);
+			LOG_ERROR("C01102006:创建主题 %1 的订阅者 %2 失败!", topicName, subscriberID);
 		}
 		FAST_DDS_MACRO::DataReaderQos dataReaderQos;
 		dataReaderQos.durability().kind = FAST_DDS_MACRO::VOLATILE_DURABILITY_QOS;
@@ -148,8 +149,9 @@ public:
 			tmp.subscribers_[subscriberID].subscriber->create_datareader(tmp.topic, dataReaderQos,
 																		 listener);
 		if (tmp.subscribers_[subscriberID].dataReader == nullptr) {
-			LOG_ERROR("0x2136 Create DataReader %1 for Topic %2 Failed!", subscriberID, topicName);
+			LOG_ERROR("C01102007:创建主题 %1 的订阅者 %2 的数据读取器失败!", topicName,
+					  subscriberID);
 		}
-		LOG_INFO("0x2137 Create Subscriber %1 for Topic %2 Success!", subscriberID, topicName);
+		LOG_INFO("D01104008:创建主题 %1 的订阅者 %2 的数据读取器成功!", topicName, subscriberID);
 	}
 };

XNCore/XNEventManager.cpp

@@ -31,13 +31,39 @@ XNEventManager::XNEventManager(PrivateType *p) : XNBaseFrameObject(p)
 {
 }
 
+// 初始化事件管理器
+bool XNEventManager::Initialize()
+{
+	T_D();
+	// 配置普通线程池
+	SetMaxThreadCount(std::thread::hardware_concurrency());
+
+	// 配置实时线程池
+	SetRTThreadPoolConfig(2,								   // 最大线程数
+						  sched_get_priority_min(SCHED_FIFO),  // 最小优先级
+						  sched_get_priority_max(SCHED_FIFO)); // 最大优先级
+
+	LOG_INFO("D01094001:事件管理器初始化成功!");
+	d->_status = XNFrameObjectStatus::Initialized;
+	return true;
+}
+
+// 准备执行
+bool XNEventManager::PrepareForExecute()
+{
+	T_D();
+	d->_status = XNFrameObjectStatus::Ready;
+	LOG_INFO("D01094002:事件管理器准备就绪!");
+	return true;
+}
+
 // 修改注册事件处理器的实现
 int XNEventManager::RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
 										 uint32_t objectId, bool async, XNEvent::Priority priority)
 {
 	T_D();
 	if (eventName.empty() || !callback) {
-		LOG_WARNING("Invalid event name or callback!");
+		LOG_WARNING("A01093003:注册的事件名称或回调函数为空，注册失败!");
 		return -1;
 	}
 
@@ -63,9 +89,8 @@ int XNEventManager::RegisterEventHandler(const std::string &eventName, XNEventCa
 	// 添加反向映射
 	d->handlerToEvent[handlerId] = eventName;
 
-	LOG_INFO("Registered " + std::string(async ? "async" : "sync") + " event handler for event: "
+	LOG_INFO("D01094004:注册 %1 事件处理器, 事件名称: %2, 处理器ID: %3 (对象ID: %4, 本地ID: %5)",
-			 + eventName + ", handler ID: " + std::to_string(handlerId) + " (object: "
+			 async ? "异步" : "同步", eventName, handlerId, objectId, d->localIdCounter);
-			 + std::to_string(objectId) + ", local: " + std::to_string(d->localIdCounter) + ")");
 	return handlerId;
 }
 
@@ -79,7 +104,7 @@ bool XNEventManager::RemoveEventHandler(const std::string &eventName, int handle
 	if (!eventName.empty()) {
 		auto it = d->eventHandlers.find(eventName);
 		if (it == d->eventHandlers.end()) {
-			LOG_WARNING("Event " + eventName + " not found!");
+			LOG_WARNING("B01093005:移除事件 %1 时, 事件不存在!", eventName);
 			return false;
 		}
 
@@ -92,8 +117,7 @@ bool XNEventManager::RemoveEventHandler(const std::string &eventName, int handle
 		if (handlerIt != handlers.end()) {
 			handlers.erase(handlerIt);
 			d->handlerToEvent.erase(handlerId);
-			LOG_INFO("Removed handler ID " + std::to_string(handlerId)
+			LOG_INFO("D01094006:移除事件 %1 的处理器ID: %2", eventName, handlerId);
-					 + " from event: " + eventName);
 
 			// 如果事件没有处理器了，移除整个事件
 			if (handlers.empty()) {
@@ -101,8 +125,7 @@ bool XNEventManager::RemoveEventHandler(const std::string &eventName, int handle
 			}
 			return true;
 		}
-		LOG_WARNING("Handler ID " + std::to_string(handlerId)
+		LOG_WARNING("B01093007:移除事件 %1 的处理器ID: %2 时, 处理器不存在!", eventName, handlerId);
-					+ " not found in event: " + eventName);
 		return false;
 	}
 
@@ -119,8 +142,7 @@ bool XNEventManager::RemoveEventHandler(const std::string &eventName, int handle
 		if (handlerIt != handlers.end()) {
 			handlers.erase(handlerIt);
 			d->handlerToEvent.erase(handlerId);
-			LOG_INFO("Removed handler ID " + std::to_string(handlerId)
+			LOG_INFO("D01094008:移除事件 %1 的处理器ID: %2", eventToRemove, handlerId);
-					 + " from event: " + eventToRemove);
 
 			// 如果事件没有处理器了，移除整个事件
 			if (handlers.empty()) {
@@ -130,7 +152,7 @@ bool XNEventManager::RemoveEventHandler(const std::string &eventName, int handle
 		}
 	}
 
-	LOG_WARNING("Handler ID " + std::to_string(handlerId) + " not found!");
+	LOG_WARNING("B01093009:移除处理器ID: %1 时, 处理器不存在!", handlerId);
 	return false;
 }
 
@@ -167,8 +189,8 @@ void XNEventManager::TriggerEvent(const std::string &eventName, const std::any &
 				handler.callback(eventData);
 				EventProcessed(eventName, true);
 			} catch (const std::exception &e) {
-				LOG_ERROR("Exception in handler " + std::to_string(handler.GetHandlerId())
+				LOG_ERROR("B01092010:事件 %1 的处理器ID: %2 执行时发生异常: %3", eventName,
-						  + " for event " + eventName + ": " + e.what());
+						  handler.GetHandlerId(), e.what());
 				EventProcessed(eventName, false);
 			}
 		}
@@ -212,7 +234,7 @@ void XNEventManager::SetMaxThreadCount(int count)
 			}
 		});
 	}
-	LOG_INFO("Set thread pool max thread count to " + std::to_string(count));
+	LOG_INFO("D01094011:设置事件处理线程池最大线程数为 %1", count);
 }
 
 int XNEventManager::GetMaxThreadCount() const
@@ -227,33 +249,6 @@ void XNEventManager::WaitForAsyncEvents()
 	T_D();
 	std::unique_lock<std::mutex> lock(d->taskMutex);
 	d->taskCond.wait(lock, [this, d] { return d->taskQueue.empty(); });
-	LOG_INFO("All async events have been processed");
-}
-
-// 初始化事件管理器
-bool XNEventManager::Initialize()
-{
-	T_D();
-	// 配置普通线程池
-	SetMaxThreadCount(std::thread::hardware_concurrency());
-
-	// 配置实时线程池
-	SetRTThreadPoolConfig(2,								   // 最大线程数
-						  sched_get_priority_min(SCHED_FIFO),  // 最小优先级
-						  sched_get_priority_max(SCHED_FIFO)); // 最大优先级
-
-	LOG_INFO("XNEventManager Initialize Success!");
-	d->_status = XNFrameObjectStatus::Initialized;
-	return true;
-}
-
-// 准备执行
-bool XNEventManager::PrepareForExecute()
-{
-	T_D();
-	d->_status = XNFrameObjectStatus::Ready;
-	LOG_INFO("XNEventManager is prepared!");
-	return true;
 }
 
 void XNEventManager::SetRTThreadPoolConfig(int maxThreads, int minPriority, int maxPriority)
@@ -263,7 +258,7 @@ void XNEventManager::SetRTThreadPoolConfig(int maxThreads, int minPriority, int
 
 	XNFrameworkPtr framework = GetFramework();
 	if (!framework) {
-		LOG_WARNING("XNFramework is nullptr!");
+		LOG_WARNING("B01093012:主框架指针为空，无法设置实时线程池配置!");
 		return;
 	}
 
@@ -278,10 +273,10 @@ void XNEventManager::SetRTThreadPoolConfig(int maxThreads, int minPriority, int
 	}
 
 	if (lastCpu < 0) {
-		LOG_WARNING("No available CPU found in affinity mask, using default CPU 1");
+		LOG_WARNING("B01093013:没有可用的CPU，使用默认CPU 1");
 		lastCpu = 1;
 	} else {
-		LOG_INFO("RT thread bound to CPU " + std::to_string(lastCpu));
+		LOG_INFO("D01094014:实时事件处理线程绑定到CPU %1", lastCpu);
 	}
 
 	d->rtManager.start(maxThreads, maxPriority, lastCpu);

XNCore/XNFramework.cpp

@@ -82,7 +82,7 @@ void XNFramework::SetCpuAffinity(uint32_t cpuAffinity)
 bool XNFramework::Initialize(uint32_t initialType)
 {
 	T_D();
-	LOG_INFO("D01054001：主框架正在初始化...");
+	LOG_INFO("D01054001:主框架正在初始化...");
 	d->ddsManager->SetFramework(XN_THISPTR);
 	d->timeManager->SetFramework(XN_THISPTR);
 	d->threadManager->SetFramework(XN_THISPTR);
@@ -92,47 +92,47 @@ bool XNFramework::Initialize(uint32_t initialType)
 	d->eventManager->SetFramework(XN_THISPTR);
 	bool ret = d->eventManager->Initialize();
 	if (!ret) {
-		LOG_ERROR("B01052001：主框架初始化失败！");
+		LOG_ERROR("B01052002:主框架初始化失败！");
 		return false;
 	}
 	ret = d->timeManager->Initialize();
 	if (!ret) {
-		LOG_ERROR("B01052002：主框架初始化失败！");
+		LOG_ERROR("B01052003:主框架初始化失败！");
 		return false;
 	}
 	ret = d->ddsManager->Initialize();
 	if (!ret) {
-		LOG_ERROR("B01052003：主框架初始化失败！");
+		LOG_ERROR("B01052004:主框架初始化失败！");
 		return false;
 	}
 	ret = d->serviceManager->Initialize();
 	if (!ret) {
-		LOG_ERROR("B01052004：主框架初始化失败！");
+		LOG_ERROR("B01052005:主框架初始化失败！");
 		return false;
 	}
 	ret = d->threadManager->Initialize();
 	if (!ret) {
-		LOG_ERROR("B01052005：主框架初始化失败！");
+		LOG_ERROR("B01052006:主框架初始化失败！");
 		return false;
 	}
 	ret = d->modelManager->Initialize();
 	if (!ret) {
-		LOG_ERROR("B01052006：主框架初始化失败！");
+		LOG_ERROR("B01052007:主框架初始化失败！");
 		return false;
 	}
 	ret = d->scenarioManager->Initialize();
 	if (!ret) {
-		LOG_ERROR("B01052007：主框架初始化失败！");
+		LOG_ERROR("B01052008:主框架初始化失败！");
 		return false;
 	}
-	LOG_INFO("D01054002：主框架初始化成功！");
+	LOG_INFO("D01054009:主框架初始化成功！");
-	LOG_INFO("D01054003：开始解析构型文件 ...");
+	LOG_INFO("D01054010:开始解析构型文件 ...");
 	ret = d->scenarioManager->AnalysisScenarioXml(d->scenarioXml, initialType);
 	if (!ret) {
-		LOG_ERROR("B01052008：主框架解析构型文件失败！");
+		LOG_ERROR("B01052011:主框架解析构型失败！");
 		return false;
 	}
-	LOG_INFO("D01054004：解析构型文件成功！");
+	LOG_INFO("D01054012:解析构型成功！");
 	return true;
 }
 
@@ -142,40 +142,40 @@ bool XNFramework::PrepareForExecute()
 
 	bool ret = d->eventManager->PrepareForExecute();
 	if (!ret) {
-		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		LOG_ERROR("B01052013:主框架准备执行失败！");
 		return false;
 	}
 	ret = d->timeManager->PrepareForExecute();
 	if (!ret) {
-		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		LOG_ERROR("B01052014:主框架准备执行失败！");
 		return false;
 	}
 	ret = d->ddsManager->PrepareForExecute();
 	if (!ret) {
-		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		LOG_ERROR("B01052015:主框架准备执行失败！");
 		return false;
 	}
 	ret = d->serviceManager->PrepareForExecute();
 	if (!ret) {
-		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		LOG_ERROR("B01052016:主框架准备执行失败！");
 		return false;
 	}
 	ret = d->threadManager->PrepareForExecute();
 	if (!ret) {
-		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		LOG_ERROR("B01052017:主框架准备执行失败！");
 		return false;
 	}
 	ret = d->modelManager->PrepareForExecute();
 	if (!ret) {
-		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		LOG_ERROR("B01052018:主框架准备执行失败！");
 		return false;
 	}
 	ret = d->scenarioManager->PrepareForExecute();
 	if (!ret) {
-		LOG_ERROR("XNFramework PrepareForExecute Failed!");
+		LOG_ERROR("B01052019:主框架准备执行失败！");
 		return false;
 	}
-	LOG_INFO("XNCore is prepared for execute! Simulation will start soon...");
+	LOG_INFO("D01054020:主框架准备就绪!");
 	return true;
 }
 

XNCore/XNModelManager.cpp

@@ -34,6 +34,14 @@ XNModelManager::XNModelManager(PrivateType *p) : XNBaseFrameObject(p)
 	d->ModelIDAssigned.resize(10000, false);
 }
 
+bool XNModelManager::Initialize()
+{
+	T_D();
+	LOG_INFO("D01114001:模型管理器初始化成功!");
+	d->_status = XNFrameObjectStatus::Initialized;
+	return true;
+}
+
 // 运行前最后准备
 bool XNModelManager::PrepareForExecute()
 {
@@ -42,15 +50,7 @@ bool XNModelManager::PrepareForExecute()
 		model.second->PrepareForExecute();
 	}
 	d->_status = XNFrameObjectStatus::Ready;
-	LOG_INFO("XNModelManager is prepared!");
+	LOG_INFO("D01114002:模型管理器准备就绪!");
-	return true;
-}
-
-bool XNModelManager::Initialize()
-{
-	T_D();
-	LOG_INFO("XNModelManager Initialize Success!");
-	d->_status = XNFrameObjectStatus::Initialized;
 	return true;
 }
 
@@ -69,7 +69,7 @@ void XNModelManager::LoadModel(const std::string &modelPath, const std::string &
 			if (model) {
 				uint32_t modelID = RegisterModel();
 				if (modelID == 0) {
-					LOG_WARNING("0x2174 Assign Model ID Failed, Model ID is used up!");
+					LOG_WARNING("B01113003:分配模型ID失败, 模型ID已用完, 模型无法注册!");
 					dlclose(handle);
 					return;
 				}
@@ -112,20 +112,17 @@ void XNModelManager::LoadModel(const std::string &modelPath, const std::string &
 					}
 				}
 			} else {
-				LOG_WARNING("0x2173 Model %s Not found in dynamic link library %s!",
+				LOG_WARNING("B01113004:动态链接库 %1 中未找到模型 %2!", modelPath, className);
-							className.c_str(), modelPath.c_str());
 				dlclose(handle);
 				return;
 			}
 		} else {
-			LOG_WARNING("0x2177 InitialModel function not found in dynamic link library %s!",
+			LOG_WARNING("B01113005:动态链接库 %1 中未找到 %2 函数!", modelPath, initialModelName);
-						modelPath.c_str());
 			dlclose(handle);
 			return;
 		}
 	} else {
-		LOG_WARNING("0x2172 Model %s Dynamic link library loading failed! Error: %s",
+		LOG_WARNING("C01113006:动态链接库 %1 加载失败! 错误: %2", modelPath, dlerror());
-					className.c_str(), dlerror());
 	}
 }
 
@@ -149,29 +146,34 @@ uint32_t XNModelManager::RegisterModel()
 XNModelObjectPtr XNModelManager::GetModel(uint32_t modelID)
 {
 	T_D();
-	if (d->ModelIDAssigned[modelID - 10000]) {
+	if (modelID >= 10000 && modelID < 20000) {
-		auto model = d->ModelMap.find(modelID);
+		if (d->ModelIDAssigned[modelID - 10000]) {
-		if (model != d->ModelMap.end()) {
+			auto model = d->ModelMap.find(modelID);
-			return model->second;
+			if (model != d->ModelMap.end()) {
+				return model->second;
+			}
+			LOG_WARNING("B01113007:模型ID %1 对应的模型不存在!", modelID);
+			return nullptr;
 		}
+		LOG_WARNING("B01113008:模型ID %1 未注册!", modelID);
 		return nullptr;
-	} else
+	} else {
+		LOG_WARNING("B01113009:模型ID %1 不合法!", modelID);
 		return nullptr;
+	}
 }
 
 void XNModelManager::RegisterFunction(uint32_t id, XNCallBack fun, uint32_t threadID,
 									  uint32_t freqGroup, uint32_t RunPos, uint32_t RunPriorty)
 {
 	T_D();
-	if (d->ModelIDAssigned[id - 10000]) {
+	if (GetModel(id) != nullptr) {
 		auto framework = GetFramework();
 		if (framework) {
 			framework->GetThreadManager()->RegisterFunction(id, fun, threadID, freqGroup, RunPos,
 															RunPriorty);
 		}
 	} else {
-		LOG_WARNING(
+		LOG_WARNING("B01113010:模型ID %1 注册周期性函数失败, 模型不存在!", id);
-			"0x2177 Submission of periodic function was rejected, model ID %1 is not registered!",
-			id);
 	}
 }

XNCore/XNModelObject.cpp

@@ -221,22 +221,21 @@ void XNModelObject::ParseXml()
 	// 读取配置文件，设置循环执行函数
 	std::ifstream file(GetXmlPath());
 	if (!file.is_open()) {
-		LOG_WARNING("0x2161 Failed to open the model configuration file: %1!", GetXmlPath());
+		LOG_WARNING("C01143001:模型配置文件 %1 打开失败!", GetXmlPath());
 		return;
 	}
 	tinyxml2::XMLDocument doc;
 	doc.LoadFile(GetXmlPath().c_str());
 	tinyxml2::XMLElement *rootNode = doc.FirstChildElement("Model");
 	if (!rootNode) {
-		LOG_WARNING("0x2161 Failed to parse model configuration file: %1!", GetXmlPath());
+		LOG_WARNING("C01143002:模型配置文件 %1 解析失败!", GetXmlPath());
 		return;
 	}
 	// 读取配置文件的模型参数
 	const char *modelName = rootNode->FirstChildElement("Name")->GetText();
 	if (!modelName || std::string(modelName) != GetObjectName()) {
-		LOG_WARNING("0x2162 The model name in the configuration file of model %1 is not consistent "
+		LOG_WARNING("A01143003:模型配置文件 %1 中模型名称不一致, 模型名称: %2, 配置文件中名称: %3!",
-					"with the model name in the configuration file of model %2!",
+					GetXmlPath(), GetObjectName(), modelName ? modelName : "null");
-					GetObjectName(), modelName ? modelName : "null");
 		return;
 	}
 	d->_sDescription = rootNode->FirstChildElement("Description")->GetText();
@@ -255,9 +254,8 @@ void XNModelObject::ParseXml()
 	// 检查运行节点是否是 "x-x" 形式
 	size_t tmp = funcNode.find('-');
 	if (tmp == std::string::npos || tmp == 0) {
-		LOG_WARNING("0x2162 The value of the run node attribute in the configuration file of model "
+		LOG_WARNING("A01143004:模型配置文件 %1 中运行节点属性值 %2 不是 x-x 格式!", GetXmlPath(),
-					"%1 is not in the x-x format, registration not executed!",
+					funcNode);
-					GetObjectName());
 		return;
 	}
 
@@ -286,13 +284,10 @@ void XNModelObject::ParseXml()
 		// 使用标准C++动态库加载
 		d->_dynamicLib = dlopen(d->_sLibPath.c_str(), RTLD_LAZY);
 		if (d->_dynamicLib) { // 动态库加载成功
-			LOG_INFO("0x2163 Model %1 loaded algorithm dynamic library %2 successfully!",
+			LOG_INFO("D01144005:模型 %1 加载数据包动态库 %2 成功!", GetObjectName(), d->_sLibPath);
-					 GetObjectName(), d->_sLibPath);
 		} else {
-			LOG_WARNING(
+			LOG_WARNING("A01143006:模型 %1 加载数据包动态库 %2 失败, 将不调用数据包模型!",
-				"0x2160 Model %1 failed to find algorithm dynamic library %2, will not call "
+						GetObjectName(), d->_sLibPath);
-				"algorithm!",
-				GetObjectName(), d->_sLibPath);
 			d->_dynamicLib = nullptr;
 		}
 	}
@@ -320,7 +315,7 @@ void XNModelObject::ParseConfig()
 	// 获取数据库路径
 	std::string dbPath = std::getenv("XNCore");
 	if (dbPath.empty()) {
-		LOG_ERROR("0x1015 未设置XNCore环境变量, 引擎将退出!");
+		LOG_ERROR("A01142007:未设置XNCore环境变量, 无法解析模型配置!");
 		return;
 	}
 	dbPath += "/database/XNSim.db";
@@ -328,7 +323,7 @@ void XNModelObject::ParseConfig()
 	// 打开数据库
 	sqlite3 *db;
 	if (sqlite3_open(dbPath.c_str(), &db) != SQLITE_OK) {
-		LOG_ERROR("0x1016 打开数据库失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01142008:打开数据库失败: %1", sqlite3_errmsg(db));
 		return;
 	}
 
@@ -337,7 +332,7 @@ void XNModelObject::ParseConfig()
 		"SELECT * FROM XNModelsVersion WHERE PlaneName = ? AND ClassName = ? AND Version = ?";
 	sqlite3_stmt *stmt;
 	if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
-		LOG_ERROR("0x1017 准备SQL语句失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01142009:准备SQL语句失败: %1", sqlite3_errmsg(db));
 		sqlite3_close(db);
 		return;
 	}
@@ -347,7 +342,7 @@ void XNModelObject::ParseConfig()
 		|| sqlite3_bind_text(stmt, 2, modelName.c_str(), modelName.length(), nullptr) != SQLITE_OK
 		|| sqlite3_bind_text(stmt, 3, modelVersion.c_str(), modelVersion.length(), nullptr)
 			   != SQLITE_OK) {
-		LOG_ERROR("0x1018 绑定参数失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01142010:绑定参数失败: %1", sqlite3_errmsg(db));
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
 		return;
@@ -355,8 +350,8 @@ void XNModelObject::ParseConfig()
 
 	// 执行查询
 	if (sqlite3_step(stmt) != SQLITE_ROW) {
-		LOG_ERROR("0x1019 未找到机型为%1,模型名称为%2,版本号%3的记录", planeName.c_str(),
+		LOG_ERROR("A01142011:未找到机型为 %1, 模型名称为 %2, 版本号 %3 的记录", planeName,
-				  modelName.c_str(), modelVersion.c_str());
+				  modelName, modelVersion);
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
 		return;
@@ -396,9 +391,9 @@ void XNModelObject::ParseConfig()
 		// 使用标准C++动态库加载
 		d->_dynamicLib = dlopen(libPath.c_str(), RTLD_LAZY);
 		if (d->_dynamicLib) { // 动态库加载成功
-			LOG_INFO("0x2163 模型 %1 加载数据包模型动态库 %2 成功!", GetObjectName(), libPath);
+			LOG_INFO("D01144012:模型 %1 加载数据包模型动态库 %2 成功!", GetObjectName(), libPath);
 		} else {
-			LOG_WARNING("0x2160 模型 %1 未找到数据包模型动态库 %2, 将不调用数据包模型!",
+			LOG_WARNING("A01143013:模型 %1 加载数据包模型动态库 %2 失败, 将不调用数据包模型!",
 						GetObjectName(), libPath);
 			d->_dynamicLib = nullptr;
 		}
@@ -452,17 +447,21 @@ void XNModelObject::RegisterDDSParticipant()
 	T_D();
 	auto framework = GetFramework();
 	if (framework == nullptr) {
-		LOG_WARNING("Failed to get Framework!");
+		LOG_WARNING("B01143014:获取主框架失败!");
 		return;
 	}
 	auto ddsManager = framework->GetDDSManager();
 	if (ddsManager == nullptr) {
-		LOG_WARNING("Failed to get DDSManager!");
+		LOG_WARNING("B01143015:获取DDS管理器失败!");
 		return;
 	}
 	uint32_t MyID  = GetUniqueId();
 	d->_dataWriter = ddsManager->RegisterPublisher<XNSim::XNSimStatus::XNModelStatusPubSubType>(
 		"XNSim::XNSimStatus::XNModelStatus", MyID);
+	if (d->_dataWriter == nullptr) {
+		LOG_WARNING("B01143016:注册DDS参与者失败!");
+		return;
+	}
 }
 
 int XNModelObject::RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
@@ -471,13 +470,13 @@ int XNModelObject::RegisterEventHandler(const std::string &eventName, XNEventCal
 	// 获取事件管理器
 	auto framework = GetFramework();
 	if (framework == nullptr) {
-		LOG_WARNING("Failed to get Framework!");
+		LOG_WARNING("B01143017:获取主框架失败!");
 		return -1;
 	}
 
 	XNEventManagerPtr eventManager = framework->GetEventManager();
 	if (eventManager == nullptr) {
-		LOG_WARNING("Failed to get EventManager!");
+		LOG_WARNING("B01143018:获取事件管理器失败!");
 		return -1;
 	}
 
@@ -491,13 +490,13 @@ void XNModelObject::TriggerEvent(const std::string &eventName, const std::any &e
 	// 获取事件管理器
 	auto framework = GetFramework();
 	if (framework == nullptr) {
-		LOG_WARNING("Failed to get Framework!");
+		LOG_WARNING("B01143019:获取主框架失败!");
 		return;
 	}
 
 	XNEventManagerPtr eventManager = framework->GetEventManager();
 	if (eventManager == nullptr) {
-		LOG_WARNING("Failed to get EventManager!");
+		LOG_WARNING("B01143020:获取事件管理器失败!");
 		return;
 	}
 

XNCore/XNScenarioManager.cpp

@@ -1,7 +1,7 @@
 /**
  * @file XNScenarioManager.cpp
  * @author	jinchao
- * @brief 运行环境描述管理器类源文件
+ * @brief 构型管理器类源文件
  * @version	1.0
  * @date 2024-11-07
  *
@@ -53,7 +53,7 @@ void XNScenarioManager::SetSimName(const std::string &simName)
 bool XNScenarioManager::Initialize()
 {
 	T_D();
-	LOG_INFO("XNScenarioManager Initialize Success!");
+	LOG_INFO("D01084001:构型管理器初始化成功!");
 	d->_status = XNFrameObjectStatus::Initialized;
 	return true;
 }
@@ -62,11 +62,11 @@ bool XNScenarioManager::PrepareForExecute()
 {
 	T_D();
 	d->_status = XNFrameObjectStatus::Ready;
-	LOG_INFO("XNScenarioManager is prepared!");
+	LOG_INFO("D01084002:构型管理器准备就绪!");
 	return true;
 }
 
-// 运行环境配置文件解析
+// 构型配置文件解析
 bool XNScenarioManager::AnalysisScenarioXml(const std::string &XmlPath, uint32_t initialType)
 {
 	T_D();
@@ -77,18 +77,18 @@ bool XNScenarioManager::AnalysisScenarioXml(const std::string &XmlPath, uint32_t
 	}
 }
 
-// 解析运行环境描述文件
+// 解析构型配置文件
 bool XNScenarioManager::ParseScenarioXml(const std::string &XmlPath)
 {
 	T_D();
 	std::ifstream file(XmlPath);
 	if (!file.is_open()) {
-		LOG_ERROR("0x2100 打开运行环境描述文件: %1出错，错误信息： %2", XmlPath, strerror(errno));
+		LOG_ERROR("C01082003:打开构型配置文件 %1 出错, 错误信息: %2", XmlPath, strerror(errno));
 		return false;
 	}
 	tinyxml2::XMLDocument doc;
 	if (doc.LoadFile(XmlPath.c_str()) != tinyxml2::XML_SUCCESS) {
-		LOG_ERROR("0x2100 解析XML文件: %1 失败", XmlPath);
+		LOG_ERROR("C01082004:构型配置文件 %1 的XML解析失败!", XmlPath);
 		file.close();
 		return false;
 	}
@@ -110,6 +110,10 @@ bool XNScenarioManager::ParseScenarioXml(const std::string &XmlPath)
 	GetFramework()->SetServicePath(servicePath);
 	// 设置域ID
 	uint32_t domainID = std::stoul(envInfo->Attribute("DomainID"));
+	if (domainID == 0 || domainID > 225) {
+		LOG_WARNING("A01083005:DDS通信域ID设置错误, 使用默认域ID: 10");
+		domainID = 10;
+	}
 	GetFramework()->GetDDSManager()->SetDomainID(domainID);
 	// 读取CPU亲和性
 	std::string cpuAff					= envInfo->Attribute("CPUAffinity");
@@ -126,6 +130,7 @@ bool XNScenarioManager::ParseScenarioXml(const std::string &XmlPath)
 			libName					   = XNSim::getFileNameWithoutExt(libName);
 			std::string dynamicLibName = servicePath + "/lib" + libName + ".so." + serviceVersion;
 			// 加载动态库
+			LOG_INFO("D01084006:正在加载服务 %1", dynamicLibName);
 			GetFramework()->GetServiceManager()->LoadService(dynamicLibName, libName,
 															 serviceVersion, 0);
 			service = service->NextSiblingElement("Service");
@@ -142,7 +147,8 @@ bool XNScenarioManager::ParseScenarioXml(const std::string &XmlPath)
 		// 读取模型分组优先级
 		int modelGroupPriority = XNSim::safe_stoi(modelGroup->Attribute("Priority"));
 		if (modelGroupPriority > 99 || modelGroupPriority < 0) {
-			LOG_ERROR("0x2100 模型分组优先级设置错误，优先级值：%d", modelGroupPriority);
+			LOG_ERROR("A01082007:模型组 %1 优先级设置错误(0~99)，优先级值：%2", modelGroupName,
+					  modelGroupPriority);
 			return false;
 		}
 		// 读取模型分组CPU亲和性
@@ -152,8 +158,9 @@ bool XNScenarioManager::ParseScenarioXml(const std::string &XmlPath)
 		// 验证CPU亲和性
 		for (const auto &cpu : modelGroupCPUAffList) {
 			if (std::find(cpuAffList.begin(), cpuAffList.end(), cpu) == cpuAffList.end()) {
-				LOG_ERROR("0x2100 模型分组CPU亲和性设置错误，CPU亲和性值：%s,进程CPU亲和性值：%s",
+				LOG_ERROR(
-						  cpu.c_str(), cpuAff.c_str());
+					"A01082008:模型组 %1 的CPU亲和性设置错误, CPU亲和性值: %2,进程CPU亲和性值: %3",
+					modelGroupName, cpu.c_str(), cpuAff.c_str());
 				return false;
 			}
 		}
@@ -179,6 +186,7 @@ bool XNScenarioManager::ParseScenarioXml(const std::string &XmlPath)
 			libName					   = XNSim::getFileNameWithoutExt(libName);
 			std::string dynamicLibName = modelPath + "/lib" + libName + ".so." + modelVersion;
 			// 加载动态库
+			LOG_INFO("D01084009:正在加载模型 %1", dynamicLibName);
 			GetFramework()->GetModelManager()->LoadModel(dynamicLibName, libName, modelVersion,
 														 planeName, 0, threadID);
 			model = model->NextSiblingElement("Model");
@@ -197,7 +205,7 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 	// 获取数据库路径
 	std::string XNCorePath = std::getenv("XNCore");
 	if (XNCorePath.empty()) {
-		LOG_ERROR("0x1015 未设置XNCore环境变量, 引擎将退出!");
+		LOG_ERROR("A01082010:使用数据库构型配置时必须设置XNCore环境变量!");
 		return false;
 	}
 	std::string dbPath = XNCorePath + "/database/XNSim.db";
@@ -205,7 +213,7 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 	// 打开数据库
 	sqlite3 *db;
 	if (sqlite3_open(dbPath.c_str(), &db) != SQLITE_OK) {
-		LOG_ERROR("0x1016 打开数据库失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01082011:打开数据库 %1 失败, 错误信息: %2", dbPath, sqlite3_errmsg(db));
 		return false;
 	}
 
@@ -213,7 +221,7 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 	std::string sql = "SELECT * FROM Configuration WHERE ConfID = ?";
 	sqlite3_stmt *stmt;
 	if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
-		LOG_ERROR("0x1017 准备SQL语句失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01082012:数据库查询时准备SQL语句失败, 错误信息: %1", sqlite3_errmsg(db));
 		sqlite3_close(db);
 		return false;
 	}
@@ -221,7 +229,7 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 	// 绑定参数
 	int configIdInt = XNSim::safe_stoi(ConfigID);
 	if (sqlite3_bind_int(stmt, 1, configIdInt) != SQLITE_OK) {
-		LOG_ERROR("0x1018 绑定参数失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01082013:数据库查询时绑定参数失败, 错误信息: %1", sqlite3_errmsg(db));
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
 		return false;
@@ -229,7 +237,7 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 
 	// 执行查询
 	if (sqlite3_step(stmt) != SQLITE_ROW) {
-		LOG_ERROR("0x1019 未找到配置ID为%1的记录", ConfigID);
+		LOG_ERROR("A01082014:未在数据库中找到配置ID为 %1 的记录", ConfigID);
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
 		return false;
@@ -250,7 +258,7 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 	// 设置域ID
 	uint32_t domainID = std::stoul(XNSim::getStringFromSqlite3(stmt, 7));
 	if (domainID == 0 || domainID > 225) {
-		LOG_WARNING("0x1020 域ID设置错误，使用默认域ID: 10");
+		LOG_WARNING("A01083015:DDS通信域ID设置错误, 使用默认域ID: 10");
 		domainID = 10;
 	}
 	GetFramework()->GetDDSManager()->SetDomainID(domainID);
@@ -262,14 +270,16 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 	std::string servicesSql = "SELECT * FROM LoadServices WHERE ConfID = ?";
 	sqlite3_stmt *servicesStmt;
 	if (sqlite3_prepare_v2(db, servicesSql.c_str(), -1, &servicesStmt, nullptr) != SQLITE_OK) {
-		LOG_ERROR("0x1020 准备LoadServices查询语句失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01082016:数据库查询时准备LoadServices表的SQL查询语句失败, 错误信息: %1",
+				  sqlite3_errmsg(db));
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
 		return false;
 	}
 	// 绑定参数
 	if (sqlite3_bind_int(servicesStmt, 1, configIdInt) != SQLITE_OK) {
-		LOG_ERROR("0x1021 绑定LoadServices参数失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01082017:数据库查询时绑定LoadServices表的参数失败, 错误信息: %1",
+				  sqlite3_errmsg(db));
 		sqlite3_finalize(servicesStmt);
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
@@ -286,6 +296,7 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 		ClassName				   = XNSim::getFileNameWithoutExt(ClassName);
 		std::string dynamicLibName = servicePath + "/lib" + ClassName + ".so." + ServiceVersion;
 		// 加载动态库
+		LOG_INFO("D01084018:正在加载服务 %1", dynamicLibName);
 		GetFramework()->GetServiceManager()->LoadService(dynamicLibName, ClassName, ServiceVersion,
 														 1);
 	}
@@ -295,7 +306,8 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 	sqlite3_stmt *modelGroupsStmt;
 	if (sqlite3_prepare_v2(db, modelGroupsSql.c_str(), -1, &modelGroupsStmt, nullptr)
 		!= SQLITE_OK) {
-		LOG_ERROR("0x1020 准备LoadModelGroups查询语句失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01082019:数据库查询时准备LoadModelGroups表的SQL查询语句失败, 错误信息: %1",
+				  sqlite3_errmsg(db));
 		sqlite3_finalize(servicesStmt);
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
@@ -304,7 +316,8 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 
 	// 绑定参数
 	if (sqlite3_bind_int(modelGroupsStmt, 1, configIdInt) != SQLITE_OK) {
-		LOG_ERROR("0x1021 绑定LoadModelGroups参数失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01082020:数据库查询时绑定LoadModelGroups表的参数失败, 错误信息: %1",
+				  sqlite3_errmsg(db));
 		sqlite3_finalize(modelGroupsStmt);
 		sqlite3_finalize(servicesStmt);
 		sqlite3_finalize(stmt);
@@ -315,18 +328,29 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 	// 执行查询并处理结果
 	while (sqlite3_step(modelGroupsStmt) == SQLITE_ROW) {
 		// 获取模型组信息
-		std::string GroupID		= XNSim::getStringFromSqlite3(modelGroupsStmt, 1);
+		std::string GroupID	   = XNSim::getStringFromSqlite3(modelGroupsStmt, 1);
-		std::string GroupName	= XNSim::getStringFromSqlite3(modelGroupsStmt, 2);
+		std::string GroupName  = XNSim::getStringFromSqlite3(modelGroupsStmt, 2);
-		double GroupFreq		= std::stod(XNSim::getStringFromSqlite3(modelGroupsStmt, 3));
+		double GroupFreq	   = std::stod(XNSim::getStringFromSqlite3(modelGroupsStmt, 3));
-		uint32_t GroupPriority	= XNSim::safe_stoi(XNSim::getStringFromSqlite3(modelGroupsStmt, 4));
+		uint32_t GroupPriority = XNSim::safe_stoi(XNSim::getStringFromSqlite3(modelGroupsStmt, 4));
-		std::string GroupCPUAff = XNSim::getStringFromSqlite3(modelGroupsStmt, 5);
+		if (GroupPriority > 99 || GroupPriority < 0) {
+			LOG_ERROR("A01082021:模型组 %1 优先级设置错误(0~99)，优先级值：%2", GroupName,
+					  GroupPriority);
+			sqlite3_finalize(modelGroupsStmt);
+			sqlite3_finalize(servicesStmt);
+			sqlite3_finalize(stmt);
+			sqlite3_close(db);
+			return false;
+		}
+
+		std::string GroupCPUAff					 = XNSim::getStringFromSqlite3(modelGroupsStmt, 5);
 		std::vector<std::string> GroupCPUAffList = XNSim::split(GroupCPUAff, ",");
 
 		// 验证CPU亲和性
 		for (const auto &cpu : GroupCPUAffList) {
 			if (std::find(cpuAffList.begin(), cpuAffList.end(), cpu) == cpuAffList.end()) {
-				LOG_ERROR("0x2100 模型分组CPU亲和性设置错误，CPU亲和性值：%s,进程CPU亲和性值：%s",
+				LOG_ERROR(
-						  cpu.c_str(), cpuAff.c_str());
+					"A01082022:模型组 %1 的CPU亲和性设置错误, CPU亲和性值: %2,进程CPU亲和性值: %3",
+					GroupName, cpu.c_str(), cpuAff.c_str());
 				sqlite3_finalize(modelGroupsStmt);
 				sqlite3_finalize(servicesStmt);
 				sqlite3_finalize(stmt);
@@ -342,7 +366,6 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 				ThreadCpuAffinity |= 1 << std::distance(cpuAffList.begin(), it);
 			}
 		}
-		LOG_INFO("0x1021 添加线程池: %1", GroupName);
 		// 添加线程池
 		uint32_t threadID = GetFramework()->GetThreadManager()->AddThreadPool(
 			GroupName, GroupFreq, GroupPriority, ThreadCpuAffinity);
@@ -351,7 +374,8 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 		std::string modelsSql	 = "SELECT * FROM LoadModels WHERE GroupID = ?";
 		sqlite3_stmt *modelsStmt = nullptr;
 		if (sqlite3_prepare_v2(db, modelsSql.c_str(), -1, &modelsStmt, nullptr) != SQLITE_OK) {
-			LOG_ERROR("0x1022 准备LoadModels查询语句失败: %1", sqlite3_errmsg(db));
+			LOG_ERROR("C01082023:数据库查询时准备LoadModels表的SQL查询语句失败, 错误信息: %1",
+					  sqlite3_errmsg(db));
 			sqlite3_finalize(modelGroupsStmt);
 			sqlite3_finalize(servicesStmt);
 			sqlite3_finalize(stmt);
@@ -361,7 +385,8 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 
 		// 绑定参数
 		if (sqlite3_bind_int(modelsStmt, 1, XNSim::safe_stoi(GroupID)) != SQLITE_OK) {
-			LOG_ERROR("0x1023 绑定LoadModels参数失败: %1", sqlite3_errmsg(db));
+			LOG_ERROR("C01082024:数据库查询时绑定LoadModels表的参数失败, 错误信息: %1",
+					  sqlite3_errmsg(db));
 			sqlite3_finalize(modelsStmt);
 			sqlite3_finalize(modelGroupsStmt);
 			sqlite3_finalize(servicesStmt);
@@ -380,7 +405,7 @@ bool XNScenarioManager::ParseConfig(const std::string &ConfigID)
 			ClassName				   = XNSim::getFileNameWithoutExt(ClassName);
 			std::string dynamicLibName = modelPath + "/lib" + ClassName + ".so." + ModelVersion;
 			// 加载动态库
-			LOG_INFO("0x1021 加载模型: %1", dynamicLibName);
+			LOG_INFO("D01084025:正在加载模型 %1", dynamicLibName);
 			GetFramework()->GetModelManager()->LoadModel(dynamicLibName, ClassName, ModelVersion,
 														 planeName, 1, threadID);
 		}

XNCore/XNScenarioManager.h

@@ -1,7 +1,7 @@
 /**
  * @file XNScenarioDescriptor.h
  * @author	jinchao
- * @brief 运行环境描述管理器类头文件
+ * @brief 构型管理器类头文件
  * @version	1.0
  * @date 2024-11-07
  *
@@ -14,8 +14,8 @@
 struct XNScenarioManagerPrivate;
 
 /**
- * @brief 运行环境描述管理器类
+ * @brief 构型管理器类
- * @details 主要负责解析运行环境配置文件来设置系统运行参数。
+ * @details 主要负责解析构型配置来设置系统运行参数。
  */
 class XNScenarioManager : public XNBaseFrameObject
 {
@@ -23,18 +23,18 @@ class XNScenarioManager : public XNBaseFrameObject
 	XN_DECLARE_PRIVATE(XNScenarioManager)
 public:
 	/**
-	 * @brief 运行环境描述管理器类默认构造函数
+	 * @brief 构型管理器类默认构造函数
 	 */
 	XNScenarioManager();
 
 	/**
-	 * @brief 运行环境描述管理器类析构函数
+	 * @brief 构型管理器类析构函数
 	 */
 	virtual ~XNScenarioManager();
 
 protected:
 	/**
-	 * @brief 运行环境描述管理器类带参构造函数
+	 * @brief 构型管理器类带参构造函数
 	 * @param p:私有结构体指针
 	 * @details 子类构造时调用此构造函数，传入子类的私有结构体指针
 	 */
@@ -55,22 +55,22 @@ public:
 
 public:
 	/**
-	 * @brief 初始化运行环境描述管理器
+	 * @brief 初始化构型管理器
 	 * @return true:	初始化成功
 	 * @return false:	初始化失败
-	 * @details	运行环境描述管理器的初始化接口函数
+	 * @details	构型管理器的初始化接口函数
 	 */
 	virtual bool Initialize() override;
 
 	/**
 	 * @brief 仿真运行前最后处理
-	 * @note  运行环境描述管理器在系统运行开始前的准备工作
+	 * @note  构型管理器在系统运行开始前的准备工作
 	 */
 	virtual bool PrepareForExecute() override;
 
 	/**
-	 * @brief 运行环境配置文件解析
+	 * @brief 构型配置文件解析
-	 * @param XmlPath:	std::string类型，运行环境配置文件解析路径
+	 * @param XmlPath:	std::string类型，构型配置文件解析路径
 	 * @param initialType:	uint32_t类型，初始化类型
 	 * @return true:	解析成功
 	 * @return false:	解析失败
@@ -79,16 +79,16 @@ public:
 
 private:
 	/**
-	 * @brief 解析运行环境配置文件
+	 * @brief 解析构型配置文件
-	 * @param XmlPath:	std::string类型，运行环境配置文件解析路径
+	 * @param XmlPath:	std::string类型，构型配置文件解析路径
 	 * @return true:	解析成功
 	 * @return false:	解析失败
 	 */
 	bool ParseScenarioXml(const std::string &XmlPath);
 
 	/**
-	 * @brief 解析构型配置文件
+	 * @brief 解析数据库构型配置
-	 * @param ConfigID:	std::string类型，构型配置文件在数据库中的ID
+	 * @param ConfigID:	std::string类型，构型配置在数据库中的ID
 	 * @return true:	解析成功
 	 * @return false:	解析失败
 	 */

XNCore/XNServiceManager.cpp

@@ -21,7 +21,7 @@ XNServiceManager::XNServiceManager(PrivateType *p) : XNBaseFrameObject(p)
 bool XNServiceManager::Initialize()
 {
 	T_D();
-	LOG_INFO("XNServiceManager Initialize Success!");
+	LOG_INFO("D01124001:服务管理器初始化成功!");
 	d->_status = XNFrameObjectStatus::Initialized;
 	return true;
 }
@@ -33,7 +33,7 @@ bool XNServiceManager::PrepareForExecute()
 		service.second->PrepareForExecute();
 	}
 	d->_status = XNFrameObjectStatus::Ready;
-	LOG_INFO("XNServiceManager is prepared!");
+	LOG_INFO("D01124002:服务管理器准备就绪!");
 	return true;
 }
 
@@ -52,7 +52,7 @@ void XNServiceManager::LoadService(const std::string &servicePath, const std::st
 			if (service) {
 				uint32_t serviceID = RegisterService();
 				if (serviceID == 0) {
-					LOG_WARNING("0x2174 Assign Service ID Failed, Service ID is used up!");
+					LOG_WARNING("B01123003:分配服务ID失败, 服务ID已用完, 服务无法注册!");
 					dlclose(handle);
 					return;
 				}
@@ -65,49 +65,48 @@ void XNServiceManager::LoadService(const std::string &servicePath, const std::st
 						std::filesystem::path(servicePath).parent_path()
 						/ (serviceName + "_V" + serviceVersion + ".scfg");
 					service->SetXmlPath(configPath.string());
-				} else if (initialType == 1) {
-					LOG_INFO("0x2176 加载服务: %1", serviceName + "," + serviceVersion);
-					service->SetXmlPath(serviceName + "," + serviceVersion);
 				} else {
-					LOG_WARNING("0x2175 InitialType Error, InitialType: %d", initialType);
+					service->SetXmlPath(serviceName + "," + serviceVersion);
-					dlclose(handle);
-					return;
 				}
 
 				// 注册服务到管理器
 				d->ServiceList[serviceID] = service;
 				service->SetInitializeType(initialType);
 				// 初始化服务
-				LOG_INFO("0x2176 初始化服务: %1", serviceName);
 				service->Initialize();
 			} else {
-				LOG_WARNING("0x2173 Service %s Not found in dynamic link library %s!",
+				LOG_WARNING("B01123004:动态链接库 %1 中未找到服务 %2!", servicePath, serviceName);
-							serviceName.c_str(), servicePath.c_str());
 				dlclose(handle);
 				return;
 			}
 		} else {
-			LOG_WARNING(
+			LOG_WARNING("B01123005:动态链接库 %1 中未找到函数 %2!", servicePath,
-				"0x2177 Service %s Initialization Failed, Function InitialService Not Found!",
+						initialServiceName);
-				serviceName.c_str());
 			dlclose(handle);
 			return;
 		}
 	} else {
-		LOG_WARNING("0x2172 Service %s Dynamic link library loading failed! Error: %s",
+		LOG_WARNING("C01123006:动态链接库 %1 加载失败! 错误: %2", servicePath, dlerror());
-					serviceName.c_str(), dlerror());
 	}
 }
 
 XNServiceObjectPtr XNServiceManager::GetService(uint32_t serviceID)
 {
 	T_D();
-	if (d->ServiceIDAssigned[serviceID - 20000]
+	if (serviceID >= 20000 && serviceID < 30000) {
-		&& d->ServiceList.find(serviceID) != d->ServiceList.end()) {
+		if (d->ServiceIDAssigned[serviceID - 20000]) {
-		return d->ServiceList[serviceID];
+			if (d->ServiceList.find(serviceID) != d->ServiceList.end()) {
-	} else {
+				return d->ServiceList[serviceID];
+			} else {
+				LOG_WARNING("B01123007:服务ID %1 对应的模型不存在!", serviceID);
+				return nullptr;
+			}
+		}
+		LOG_WARNING("B01123008:服务ID %1 未注册!", serviceID);
 		return nullptr;
 	}
+	LOG_WARNING("B01123009:服务ID %1 不合法!", serviceID);
+	return nullptr;
 }
 
 uint32_t XNServiceManager::RegisterService()

XNCore/XNServiceObject.cpp

@@ -89,36 +89,6 @@ void XNServiceObject::SetChangeTime(const XNTimePoint &cTime)
 	d->_cChangeTime = cTime;
 }
 
-int XNServiceObject::RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
-										  bool async, XNEvent::Priority priority)
-{
-	// 注册事件处理器
-	T_D();
-	auto framework = GetFramework();
-	if (framework) {
-		auto eventManager = framework->GetEventManager();
-		if (eventManager) {
-			return eventManager->RegisterEventHandler(eventName, callback, GetUniqueId(), async,
-													  priority);
-		}
-	}
-	return -1;
-}
-
-void XNServiceObject::TriggerEvent(const std::string &eventName, const std::any &eventData,
-								   bool forceAsync, XNEvent::Priority priority)
-{
-	// 触发事件
-	T_D();
-	auto framework = GetFramework();
-	if (framework) {
-		auto eventManager = framework->GetEventManager();
-		if (eventManager) {
-			eventManager->TriggerEvent(eventName, eventData, forceAsync, priority);
-		}
-	}
-}
-
 int XNServiceObject::RegisterRTEventHandler(const std::string &eventName, XNEventCallback callback)
 {
 	return RegisterEventHandler(eventName, callback, true, XNEvent::Priority::RealTime);
@@ -150,21 +120,20 @@ void XNServiceObject::ParseXml()
 	T_D();
 	tinyxml2::XMLDocument doc;
 	if (doc.LoadFile(GetXmlPath().c_str()) != tinyxml2::XML_SUCCESS) {
-		LOG_WARNING("Failed to open the service configuration file: %1!", GetXmlPath());
+		LOG_WARNING("C01153001:服务配置文件 %1 打开失败!", GetXmlPath());
 		return;
 	}
 
 	tinyxml2::XMLElement *rootNode = doc.RootElement();
 	if (!rootNode) {
-		LOG_WARNING("Invalid XML file format: %1!", GetXmlPath());
+		LOG_WARNING("C01153002:服务配置文件 %1 解析失败!", GetXmlPath());
 		return;
 	}
 
 	const char *serviceName = rootNode->FirstChildElement("Name")->GetText();
 	if (serviceName != GetObjectName()) {
-		LOG_WARNING("The service name in the configuration file of service %1 is not consistent "
+		LOG_WARNING("A01153003:服务配置文件 %1 中服务名称不一致, 服务名称: %2, 配置文件中名称: %3!",
-					"with the service name in the configuration file of service %2!",
+					GetXmlPath(), GetObjectName(), serviceName);
-					GetObjectName(), serviceName);
 		return;
 	}
 
@@ -199,7 +168,7 @@ void XNServiceObject::ParseConfig()
 	// 获取数据库路径
 	std::string dbPath = std::getenv("XNCore");
 	if (dbPath.empty()) {
-		LOG_ERROR("0x1015 未设置XNCore环境变量, 引擎将退出!");
+		LOG_ERROR("A01152004:未设置XNCore环境变量, 无法解析服务配置!");
 		return;
 	}
 	dbPath += "/database/XNSim.db";
@@ -207,7 +176,7 @@ void XNServiceObject::ParseConfig()
 	// 打开数据库
 	sqlite3 *db;
 	if (sqlite3_open(dbPath.c_str(), &db) != SQLITE_OK) {
-		LOG_ERROR("0x1016 打开数据库失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01152005:打开数据库失败: %1", sqlite3_errmsg(db));
 		return;
 	}
 
@@ -215,7 +184,7 @@ void XNServiceObject::ParseConfig()
 	std::string sql = "SELECT * FROM XNServiceVersion WHERE ClassName = ? AND Version = ?";
 	sqlite3_stmt *stmt;
 	if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
-		LOG_ERROR("0x1017 准备SQL语句失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01152006:准备SQL语句失败: %1", sqlite3_errmsg(db));
 		sqlite3_close(db);
 		return;
 	}
@@ -224,7 +193,7 @@ void XNServiceObject::ParseConfig()
 	if (sqlite3_bind_text(stmt, 1, serviceName.c_str(), serviceName.length(), nullptr) != SQLITE_OK
 		|| sqlite3_bind_text(stmt, 2, serviceVersion.c_str(), serviceVersion.length(), nullptr)
 			   != SQLITE_OK) {
-		LOG_ERROR("0x1018 绑定参数失败: %1", sqlite3_errmsg(db));
+		LOG_ERROR("C01152007:绑定参数失败: %1", sqlite3_errmsg(db));
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
 		return;
@@ -232,8 +201,7 @@ void XNServiceObject::ParseConfig()
 
 	// 执行查询
 	if (sqlite3_step(stmt) != SQLITE_ROW) {
-		LOG_ERROR("0x1019 未找到服务名称为%1,版本号%2的记录", serviceName.c_str(),
+		LOG_ERROR("A01152008:未找到服务名称为 %1, 版本号 %2 的记录", serviceName, serviceVersion);
-				  serviceVersion.c_str());
 		sqlite3_finalize(stmt);
 		sqlite3_close(db);
 		return;
@@ -257,7 +225,6 @@ void XNServiceObject::ParseConfig()
 				for (const auto &cmd : commandList) {
 					if (cmd.contains("Name") && cmd.contains("Description")
 						&& cmd.contains("Call")) {
-						LOG_INFO("0x1021 服务命令: %1", cmd["Name"].get<std::string>());
 						// TODO: 处理服务命令信息
 						// d->_commandList.emplace_back(
 						// 	cmd["Name"].get<std::string>(),
@@ -268,7 +235,7 @@ void XNServiceObject::ParseConfig()
 				}
 			}
 		} catch (const std::exception &e) {
-			LOG_WARNING("0x1020 解析服务命令列表失败: %1", e.what());
+			//LOG_WARNING("解析服务命令列表失败: %1", e.what());
 		}
 	}
 
@@ -278,7 +245,7 @@ void XNServiceObject::ParseConfig()
 		try {
 			d->_otherParams = XN_JSON::parse(otherParamsStr);
 		} catch (const std::exception &e) {
-			LOG_WARNING("0x1020 解析其他参数失败: %1", e.what());
+			LOG_WARNING("C01152009:解析其他参数失败: %1", e.what());
 		}
 	}
 
@@ -310,3 +277,42 @@ void XNServiceObject::SetFramework(XNFrameworkPtr framework)
 	T_D();
 	d->pFramework = framework;
 }
+
+int XNServiceObject::RegisterEventHandler(const std::string &eventName, XNEventCallback callback,
+										  bool async, XNEvent::Priority priority)
+{
+	// 注册事件处理器
+	T_D();
+	auto framework = GetFramework();
+	if (framework) {
+		auto eventManager = framework->GetEventManager();
+		if (eventManager) {
+			return eventManager->RegisterEventHandler(eventName, callback, GetUniqueId(), async,
+													  priority);
+		} else {
+			LOG_WARNING("B01153011:获取事件管理器失败!");
+		}
+	} else {
+		LOG_WARNING("B01153010:获取主框架失败!");
+	}
+
+	return -1;
+}
+
+void XNServiceObject::TriggerEvent(const std::string &eventName, const std::any &eventData,
+								   bool forceAsync, XNEvent::Priority priority)
+{
+	// 触发事件
+	T_D();
+	auto framework = GetFramework();
+	if (framework) {
+		auto eventManager = framework->GetEventManager();
+		if (eventManager) {
+			eventManager->TriggerEvent(eventName, eventData, forceAsync, priority);
+		} else {
+			LOG_WARNING("B01153013:获取事件管理器失败!");
+		}
+	} else {
+		LOG_WARNING("B01153012:获取主框架失败!");
+	}
+}

XNCore/XNThread.cpp

@@ -54,21 +54,21 @@ bool XNThread::Initialize()
 	// 初始化线程参数
 	ret = pthread_attr_init(&(d->attr));
 	if (ret) {
-		LOG_ERROR("0x2210 Thread: %1 Initialize Attribute Failed!", GetObjectName());
+		LOG_ERROR("C01132001:线程 %1 初始化属性失败!", GetObjectName());
 		return false;
 	}
 
 	// 设置线程栈空间大小
 	ret = pthread_attr_setstacksize(&(d->attr), PTHREAD_STACK_MIN * 20);
 	if (ret) {
-		LOG_ERROR("0x2211 Thread: %1 Set Stack Space Failed!", GetObjectName());
+		LOG_ERROR("C01132002:线程 %1 设置栈空间失败!", GetObjectName());
 		return false;
 	}
 
 	// 设置线程调度策略
 	ret = pthread_attr_setschedpolicy(&(d->attr), SCHED_FIFO);
 	if (ret) {
-		LOG_ERROR("0x2212 Thread: %1 Set Scheduling Policy Failed!", GetObjectName());
+		LOG_ERROR("C01132003:线程 %1 设置调度策略失败!", GetObjectName());
 		return false;
 	}
 
@@ -76,21 +76,21 @@ bool XNThread::Initialize()
 	d->param.sched_priority = d->_uPriority;
 	ret						= pthread_attr_setschedparam(&(d->attr), &d->param);
 	if (ret) {
-		LOG_ERROR("0x2213 Thread: %1 Set Priority Failed!", GetObjectName());
+		LOG_ERROR("C01132004:线程 %1 设置优先级失败!", GetObjectName());
 		return false;
 	}
 
 	// 设置调度器继承
 	ret = pthread_attr_setinheritsched(&(d->attr), PTHREAD_EXPLICIT_SCHED);
 	if (ret) {
-		LOG_ERROR("0x2214 Thread: %1 Set Scheduler Inheritance Failed!", GetObjectName());
+		LOG_ERROR("C01132005:线程 %1 设置调度器继承失败!", GetObjectName());
 		return false;
 	}
 
 	// 线程创建
 	ret = pthread_create(&d->thread, &d->attr, ThreadFunction, this);
 	if (ret) {
-		LOG_ERROR("0x2215 Thread: %1 Create Failed!", GetObjectName());
+		LOG_ERROR("C01132006:线程 %1 创建失败!", GetObjectName());
 		return false;
 	}
 
@@ -101,23 +101,23 @@ bool XNThread::Initialize()
 
 	XNFrameworkPtr framework = GetFramework();
 	if (!framework) {
-		LOG_WARNING("0x2216 Thread: %1 get Framework Failed!", GetObjectName());
+		LOG_WARNING("B01133007:线程 %1 获取框架指针失败!", GetObjectName());
 		return true;
 	}
 
 	XNDDSManagerPtr ddsManager = framework->GetDDSManager();
 	if (!ddsManager) {
-		LOG_WARNING("0x2216 Thread: %1 get DDSManager Failed!", GetObjectName());
+		LOG_WARNING("B01133008:线程 %1 获取DDS管理器失败!", GetObjectName());
 		return true;
 	}
 
 	d->writer = ddsManager->RegisterPublisher<XNSim::XNSimStatus::XNThreadStatusPubSubType>(
 		"XNSim::XNSimStatus::XNThreadStatus", d->_threadID);
 	if (d->writer == nullptr) {
-		LOG_WARNING("0x2217 Thread: %1 get DDS Writer Failed!", GetObjectName());
+		LOG_WARNING("B01133009:线程 %1 获取DDS数据写入器失败!", GetObjectName());
 		return true;
 	}
-	LOG_INFO("Thread: %1 is prepared!", GetObjectName());
+	LOG_INFO("D01134010:线程 %1 准备就绪!", GetObjectName());
 	return true;
 }
 
@@ -154,7 +154,7 @@ void XNThread::Start()
 	}
 	pthread_cond_signal(&d->_cond);
 	pthread_mutex_unlock(&d->_mtx);
-	LOG_INFO("Thread: %1 Start!", GetObjectName());
+	LOG_INFO("D01134011:线程 %1 开始执行!", GetObjectName());
 }
 
 // 暂停执行
@@ -167,7 +167,7 @@ void XNThread::Pause()
 		d->_eRunStatus = RunStatus::Suspend;
 	}
 	pthread_mutex_unlock(&d->_mtx);
-	LOG_INFO("Thread: %1 Pause!", GetObjectName());
+	LOG_INFO("D01134012:线程 %1 暂停执行!", GetObjectName());
 }
 
 // 继续执行
@@ -181,6 +181,7 @@ void XNThread::Continue()
 	}
 	pthread_cond_signal(&d->_cond);
 	pthread_mutex_unlock(&d->_mtx);
+	LOG_INFO("D01134013:线程 %1 继续执行!", GetObjectName());
 }
 
 // 停止执行
@@ -194,6 +195,7 @@ void XNThread::Stop(bool force)
 		pthread_cond_signal(&d->_cond);
 		pthread_mutex_unlock(&d->_mtx);
 		Join();
+		LOG_INFO("D01134014:线程 %1 强制停止执行!", GetObjectName());
 	} else {
 		pthread_mutex_lock(&d->_mtx);
 		// 设置运行状态
@@ -201,8 +203,8 @@ void XNThread::Stop(bool force)
 		pthread_cond_signal(&d->_cond);
 		pthread_mutex_unlock(&d->_mtx);
 		Join();
+		LOG_INFO("D01134015:线程 %1 正常停止执行!", GetObjectName());
 	}
-	LOG_INFO("Thread: %1 Stop!", GetObjectName());
 }
 
 // 加入线程
@@ -323,7 +325,7 @@ bool XNThread::OnSetCPUAffinity()
 			CPU_SET(i, &mask);
 	}
 	if (pthread_setaffinity_np(d->thread, sizeof(mask), &mask) == -1) {
-		LOG_WARNING("0x2216 线程: %1 设置CPU亲和性失败!", GetObjectName());
+		LOG_WARNING("C01133017:线程 %1 设置CPU亲和性失败!", GetObjectName());
 		return false;
 	}
 	return true;

XNCore/XNThreadManager.cpp

@@ -36,7 +36,7 @@ bool XNThreadManager::Initialize()
 	d->_eRunStatus = RunStatus::NotStart;
 	d->threadList.clear();
 	d->funList.clear();
-	LOG_INFO("XNThreadManager Initialize Success!");
+	LOG_INFO("D01074001:线程管理器初始化成功!");
 	d->_status = XNFrameObjectStatus::Initialized;
 	return true;
 }
@@ -110,10 +110,10 @@ void XNThreadManager::RegisterFunction(uint32_t id, XNCallBack fun, uint32_t thr
 		d->funList[id].push_back(sFunInfo);
 		if (d->threadList.find(threadID) != d->threadList.end()) {
 			d->threadList[threadID]->AddFunction(fun, (FreqLevel)freqGroup, RunPos, RunPriorty);
-			LOG_INFO("Model [ %1] register periodic function success! Run node: %2-%3 Priority: %4",
+			LOG_INFO("D01074005:模型 [ %1 ] 注册周期性函数成功! 运行节点: %2-%3 优先级: %4", id,
-					 id, freqGroup, RunPos, RunPriorty);
+					 freqGroup, RunPos, RunPriorty);
 		} else {
-			LOG_ERROR("0x2172 The thread [ %1 ] does not exist, registration failed!", threadID);
+			LOG_ERROR("B01072008:线程 [ %1 ] 不存在,模型 [ %2 ] 注册周期性函数失败!", threadID, id);
 		}
 	}
 }
@@ -124,15 +124,12 @@ bool XNThreadManager::IsFunParamRight(uint32_t id, uint32_t freqGroup, uint32_t
 	// 检查提交的函数是否符合规定
 	if (freqGroup < 0 || freqGroup > 5) {
 		// 如果频率分组不是0～5
-		LOG_WARNING("0x2170 The submitted function's run frequency group of Model [ %1 ] is not "
+		LOG_WARNING("A01073006:模型 [ %1 ] 的运行频率分组不在0~5之间,注册失败!", id);
-					"between 0 and 5, registration failed!",
-					id);
 		return false;
 	} else if (RunPos > (1 << freqGroup)) {
 		// 如果运行节点不符合要求
-		LOG_WARNING("0x2171 The run node submitted for registration by model [ %1 ] exceeds the "
+		LOG_WARNING("A01073007:模型 [ %1 ] 的运行节点 %2 超出当前频率分组最大节点数 %3,注册失败!",
-					"maximum node count for the frequency group, registration failed!",
+					id, RunPos, (1 << freqGroup));
-					id);
 		return false;
 	}
 	return true;
@@ -156,16 +153,16 @@ bool XNThreadManager::PrepareForExecute()
 		}
 	}
 	// 所有线程初始化
-	LOG_INFO("XNThreadManager is preparing...");
+	LOG_INFO("D01074002:线程管理器正在初始化所有线程...");
 	for (auto &thread : d->threadList) {
 		bool bRet = thread.second->Initialize();
 		if (!bRet) {
-			LOG_ERROR("Thread [ %1 ] PrepareForExecute Failed!", thread.first);
+			LOG_ERROR("B01072009:线程 [ %1 ] 初始化失败!", thread.first);
 			continue;
 		}
 	}
 	d->_status = XNFrameObjectStatus::Ready;
-	LOG_INFO("XNThreadManager is prepared!");
+	LOG_INFO("D01074003:线程管理器准备就绪!");
 	return true;
 }
 
@@ -178,7 +175,7 @@ uint32_t XNThreadManager::AddThreadPool(std::string name, double freq, uint32_t
 	XNThreadPtr thread = std::make_shared<XNThread>(name, freq, priority, CPUAff);
 	thread->SetThreadID(AllocateThreadID());
 	thread->SetFramework(GetFramework());
-	LOG_INFO("Add Thread Success, Frequency: %1 Hz, Interval: %2 ns.", freq, 1.0e9 / freq);
+	LOG_INFO("D01074004:添加线程成功,运行频率: %1 Hz,运行间隔: %2 ns.", freq, 1.0e9 / freq);
 	d->threadList[thread->GetThreadID()] = thread;
 	return thread->GetThreadID();
 }

XNCore/XNTimeManager.cpp

@@ -53,10 +53,10 @@ void XNTimeManager::Start()
 {
 	T_D();
 	if (d->_eRunStatus == RunStatus::NotStart) {
-		LOG_INFO("XNSim Start!");
+		LOG_INFO("D01064003:仿真开始运行!");
 		d->_eRunStatus = RunStatus::Runing;
 	} else {
-		LOG_WARNING("XNSim Already Start!");
+		LOG_WARNING("A01063007:仿真已经运行,请勿重复运行!");
 	}
 }
 
@@ -64,10 +64,10 @@ void XNTimeManager::Abort()
 {
 	T_D();
 	if (d->_eRunStatus != RunStatus::Aborted) {
-		LOG_INFO("XNSim Abort!");
+		LOG_INFO("D01064004:仿真终止运行!");
 		d->_eRunStatus = RunStatus::Aborted;
 	} else {
-		LOG_WARNING("XNSim Already Abort!");
+		LOG_WARNING("A01062008:仿真已经终止运行,请勿重复终止!");
 	}
 }
 
@@ -75,10 +75,10 @@ void XNTimeManager::Pause()
 {
 	T_D();
 	if (d->_eRunStatus == RunStatus::Runing) {
-		LOG_INFO("XNSim Pause!");
+		LOG_INFO("D01064005:仿真暂停运行!");
 		d->_eRunStatus = RunStatus::Suspend;
 	} else {
-		LOG_WARNING("XNSim is not in Runing status!");
+		LOG_WARNING("A01062009:仿真不是运行状态,无法暂停!");
 	}
 }
 
@@ -86,10 +86,10 @@ void XNTimeManager::Continue()
 {
 	T_D();
 	if (d->_eRunStatus == RunStatus::Suspend) {
-		LOG_INFO("XNSim Continue!");
+		LOG_INFO("D01064006:仿真继续运行!");
 		d->_eRunStatus = RunStatus::Runing;
 	} else {
-		LOG_WARNING("XNSim is not in Pause status!");
+		LOG_WARNING("A01062010:仿真不是暂停状态,无法继续!");
 	}
 }
 
@@ -146,7 +146,7 @@ bool XNTimeManager::Initialize()
 	// 仿真时间初始化
 	d->_SimTime = d->_SimStartTime;
 
-	LOG_INFO("XNTimeManager Initialize Success!");
+	LOG_INFO("D01064001:时间管理器初始化成功!");
 	d->_status = XNFrameObjectStatus::Initialized;
 	return true;
 }
@@ -155,7 +155,7 @@ bool XNTimeManager::PrepareForExecute()
 {
 	T_D();
 	d->_status = XNFrameObjectStatus::Ready;
-	LOG_INFO("XNTimeManager is prepared!");
+	LOG_INFO("D01064002:时间管理器准备就绪!");
 	return true;
 }