jinchao/XNSim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
jinchao 2025-06-26 15:26:26 +08:00
parent 261cc444d6
commit c30b580a56
19 changed files with 393 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Release/database/LogInfo.db
View File

Binary file not shown.

BIN
Release/database/XNSim.db
View File

Binary file not shown.

70
Release/include/XNCore/XNDDSInterface.h
View File

@ -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(
std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 275");
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"A01161009:T 必须是算术类型或std::array类型");
}
} catch (const std::exception &e) {
throw std::runtime_error("无法解析第 " + std::to_string(i)
+ " 个元素: " + e.what());
LOG_WARNING("A01163010:无法解析第 %1 个元素: %2", i, 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>,
"模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 293");
static_assert(std::is_arithmetic_v<T2>, "A01161011:模板参数T2必须是算术类型");
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::"
"array类型时，它的数组嵌套不能超过两层，详见XNDDSInterfac"
"e.cpp：line 313");
"A01161013:模板参数T1是std::"
"array类型时，它的数组嵌套不能超过两层");
}
} else {
static_assert(
std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 320");
static_assert(std::is_arithmetic_v<array_type>
|| is_std_array_v<array_type>,
"A01161014:模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型");
}
}
} else {
static_assert(
std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 326");
static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"A01161015:模板参数T1必须是算术类型或std::array类型");
}
}
}
@ -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>,
"模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 337");
static_assert(std::is_arithmetic_v<T2>, "A01161016:模板参数T2必须是算术类型");
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>,
"模板参数T1是std::"
"array类型时，它的数组嵌套不能超过两层，详见XNDDSInterface."
"cpp：line 357");
static_assert(
std::is_arithmetic_v<sub_array_type>,
"A01161018:模板参数T1是std::array类型时，它的数组嵌套不能超过两层");
}
} else {
static_assert(
std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 364");
static_assert(std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"A01161019:模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型");
}
}
data = temp;
} else {
static_assert(
std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 371");
static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"A01161020:模板参数T1必须是算术类型或std::array类型");
}
}

18
Release/include/XNCore/XNDDSManager.h
View File

@ -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);
}
};

30
Release/include/XNCore/XNScenarioManager.h
View File

@ -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 运行环境描述管理器类
* @details 主要负责解析运行环境配置文件来设置系统运行参数。
* @brief 构型管理器类
* @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 运行环境配置文件解析
* @param XmlPath: std::string类型，运行环境配置文件解析路径
* @brief 构型配置文件解析
* @param XmlPath: std::string类型，构型配置文件解析路径
* @param initialType: uint32_t类型，初始化类型
* @return true: 解析成功
* @return false: 解析失败
@ -79,16 +79,16 @@ public:
private:
/**
* @brief 解析运行环境配置文件
* @param XmlPath: std::string类型，运行环境配置文件解析路径
* @brief 解析构型配置文件
* @param XmlPath: std::string类型，构型配置文件解析路径
* @return true: 解析成功
* @return false: 解析失败
*/
bool ParseScenarioXml(const std::string &XmlPath);
/**
* @brief 解析构型配置文件
* @param ConfigID: std::string类型，构型配置文件在数据库中的ID
* @brief 解析数据库构型配置
* @param ConfigID: std::string类型，构型配置在数据库中的ID
* @return true: 解析成功
* @return false: 解析失败
*/

70
XNCore/XNDDSInterface.h
View File

@ -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(
std::is_arithmetic_v<T> || is_std_array_v<T>,
"T 必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 275");
static_assert(std::is_arithmetic_v<T> || is_std_array_v<T>,
"A01161009:T 必须是算术类型或std::array类型");
}
} catch (const std::exception &e) {
throw std::runtime_error("无法解析第 " + std::to_string(i)
+ " 个元素: " + e.what());
LOG_WARNING("A01163010:无法解析第 %1 个元素: %2", i, 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>,
"模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 293");
static_assert(std::is_arithmetic_v<T2>, "A01161011:模板参数T2必须是算术类型");
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::"
"array类型时，它的数组嵌套不能超过两层，详见XNDDSInterfac"
"e.cpp：line 313");
"A01161013:模板参数T1是std::"
"array类型时，它的数组嵌套不能超过两层");
}
} else {
static_assert(
std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 320");
static_assert(std::is_arithmetic_v<array_type>
|| is_std_array_v<array_type>,
"A01161014:模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型");
}
}
} else {
static_assert(
std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 326");
static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"A01161015:模板参数T1必须是算术类型或std::array类型");
}
}
}
@ -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>,
"模板参数T2必须是算术类型，详见XNDDSInterface.cpp：line 337");
static_assert(std::is_arithmetic_v<T2>, "A01161016:模板参数T2必须是算术类型");
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>,
"模板参数T1是std::"
"array类型时，它的数组嵌套不能超过两层，详见XNDDSInterface."
"cpp：line 357");
static_assert(
std::is_arithmetic_v<sub_array_type>,
"A01161018:模板参数T1是std::array类型时，它的数组嵌套不能超过两层");
}
} else {
static_assert(
std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 364");
static_assert(std::is_arithmetic_v<array_type> || is_std_array_v<array_type>,
"A01161019:模板参数T1是std::array类型时，它的value_"
"type必须是算术类型或std::array类型");
}
}
data = temp;
} else {
static_assert(
std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"模板参数T1必须是算术类型或std::array类型，详见XNDDSInterface.cpp：line 371");
static_assert(std::is_arithmetic_v<T1> || is_std_array_v<T1>,
"A01161020:模板参数T1必须是算术类型或std::array类型");
}
}

7
XNCore/XNDDSManager.cpp
View File

@ -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管理器创建域参与者成功!");
}

18
XNCore/XNDDSManager.h
View File

@ -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);
}
};

85
XNCore/XNEventManager.cpp
View File

@ -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: "
+ eventName + ", handler ID: " + std::to_string(handlerId) + " (object: "
+ std::to_string(objectId) + ", local: " + std::to_string(d->localIdCounter) + ")");
LOG_INFO("D01094004:注册 %1 事件处理器, 事件名称: %2, 处理器ID: %3 (对象ID: %4, 本地ID: %5)",
async ? "异步" : "同步", eventName, handlerId, objectId, 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)
+ " from event: " + eventName);
LOG_INFO("D01094006:移除事件 %1 的处理器ID: %2", eventName, handlerId);
// 如果事件没有处理器了，移除整个事件
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)
+ " not found in event: " + eventName);
LOG_WARNING("B01093007:移除事件 %1 的处理器ID: %2 时, 处理器不存在!", eventName, handlerId);
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)
+ " from event: " + eventToRemove);
LOG_INFO("D01094008:移除事件 %1 的处理器ID: %2", eventToRemove, handlerId);
// 如果事件没有处理器了，移除整个事件
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())
+ " for event " + eventName + ": " + e.what());
LOG_ERROR("B01092010:事件 %1 的处理器ID: %2 执行时发生异常: %3", eventName,
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);

40
XNCore/XNFramework.cpp
View File

@ -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("D01054003：开始解析构型文件 ...");
LOG_INFO("D01054009:主框架初始化成功！");
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;
}

52
XNCore/XNModelManager.cpp
View File

@ -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!");
return true;
}
bool XNModelManager::Initialize()
{
T_D();
LOG_INFO("XNModelManager Initialize Success!");
d->_status = XNFrameObjectStatus::Initialized;
LOG_INFO("D01114002:模型管理器准备就绪!");
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!",
className.c_str(), modelPath.c_str());
LOG_WARNING("B01113004:动态链接库 %1 中未找到模型 %2!", modelPath, className);
dlclose(handle);
return;
}
} else {
LOG_WARNING("0x2177 InitialModel function not found in dynamic link library %s!",
modelPath.c_str());
LOG_WARNING("B01113005:动态链接库 %1 中未找到 %2 函数!", modelPath, initialModelName);
dlclose(handle);
return;
}
} else {
LOG_WARNING("0x2172 Model %s Dynamic link library loading failed! Error: %s",
className.c_str(), dlerror());
LOG_WARNING("C01113006:动态链接库 %1 加载失败! 错误: %2", modelPath, dlerror());
}
}
@ -149,29 +146,34 @@ uint32_t XNModelManager::RegisterModel()
XNModelObjectPtr XNModelManager::GetModel(uint32_t modelID)
{
T_D();
if (d->ModelIDAssigned[modelID - 10000]) {
auto model = d->ModelMap.find(modelID);
if (model != d->ModelMap.end()) {
return model->second;
if (modelID >= 10000 && modelID < 20000) {
if (d->ModelIDAssigned[modelID - 10000]) {
auto model = d->ModelMap.find(modelID);
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(
"0x2177 Submission of periodic function was rejected, model ID %1 is not registered!",
id);
LOG_WARNING("B01113010:模型ID %1 注册周期性函数失败, 模型不存在!", id);
}
}

55
XNCore/XNModelObject.cpp
View File

@ -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 "
"with the model name in the configuration file of model %2!",
GetObjectName(), modelName ? modelName : "null");
LOG_WARNING("A01143003:模型配置文件 %1 中模型名称不一致, 模型名称: %2, 配置文件中名称: %3!",
GetXmlPath(), 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 "
"%1 is not in the x-x format, registration not executed!",
GetObjectName());
LOG_WARNING("A01143004:模型配置文件 %1 中运行节点属性值 %2 不是 x-x 格式!", GetXmlPath(),
funcNode);
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!",
GetObjectName(), d->_sLibPath);
LOG_INFO("D01144005:模型 %1 加载数据包动态库 %2 成功!", GetObjectName(), d->_sLibPath);
} else {
LOG_WARNING(
"0x2160 Model %1 failed to find algorithm dynamic library %2, will not call "
"algorithm!",
GetObjectName(), d->_sLibPath);
LOG_WARNING("A01143006:模型 %1 加载数据包动态库 %2 失败, 将不调用数据包模型!",
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(),
modelName.c_str(), modelVersion.c_str());
LOG_ERROR("A01142011:未找到机型为 %1, 模型名称为 %2, 版本号 %3 的记录", planeName,
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;
}

87
XNCore/XNScenarioManager.cpp
View File

@ -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",
cpu.c_str(), cpuAff.c_str());
LOG_ERROR(
"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 GroupName = XNSim::getStringFromSqlite3(modelGroupsStmt, 2);
double GroupFreq = std::stod(XNSim::getStringFromSqlite3(modelGroupsStmt, 3));
uint32_t GroupPriority = XNSim::safe_stoi(XNSim::getStringFromSqlite3(modelGroupsStmt, 4));
std::string GroupCPUAff = XNSim::getStringFromSqlite3(modelGroupsStmt, 5);
std::string GroupID = XNSim::getStringFromSqlite3(modelGroupsStmt, 1);
std::string GroupName = XNSim::getStringFromSqlite3(modelGroupsStmt, 2);
double GroupFreq = std::stod(XNSim::getStringFromSqlite3(modelGroupsStmt, 3));
uint32_t GroupPriority = XNSim::safe_stoi(XNSim::getStringFromSqlite3(modelGroupsStmt, 4));
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",
cpu.c_str(), cpuAff.c_str());
LOG_ERROR(
"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);
}

30
XNCore/XNScenarioManager.h
View File

@ -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 运行环境描述管理器类
* @details 主要负责解析运行环境配置文件来设置系统运行参数。
* @brief 构型管理器类
* @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 运行环境配置文件解析
* @param XmlPath: std::string类型，运行环境配置文件解析路径
* @brief 构型配置文件解析
* @param XmlPath: std::string类型，构型配置文件解析路径
* @param initialType: uint32_t类型，初始化类型
* @return true: 解析成功
* @return false: 解析失败
@ -79,16 +79,16 @@ public:
private:
/**
* @brief 解析运行环境配置文件
* @param XmlPath: std::string类型，运行环境配置文件解析路径
* @brief 解析构型配置文件
* @param XmlPath: std::string类型，构型配置文件解析路径
* @return true: 解析成功
* @return false: 解析失败
*/
bool ParseScenarioXml(const std::string &XmlPath);
/**
* @brief 解析构型配置文件
* @param ConfigID: std::string类型，构型配置文件在数据库中的ID
* @brief 解析数据库构型配置
* @param ConfigID: std::string类型，构型配置在数据库中的ID
* @return true: 解析成功
* @return false: 解析失败
*/

41
XNCore/XNServiceManager.cpp
View File

@ -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);
dlclose(handle);
return;
service->SetXmlPath(serviceName + "," + serviceVersion);
}
// 注册服务到管理器
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!",
serviceName.c_str(), servicePath.c_str());
LOG_WARNING("B01123004:动态链接库 %1 中未找到服务 %2!", servicePath, serviceName);
dlclose(handle);
return;
}
} else {
LOG_WARNING(
"0x2177 Service %s Initialization Failed, Function InitialService Not Found!",
serviceName.c_str());
LOG_WARNING("B01123005:动态链接库 %1 中未找到函数 %2!", servicePath,
initialServiceName);
dlclose(handle);
return;
}
} else {
LOG_WARNING("0x2172 Service %s Dynamic link library loading failed! Error: %s",
serviceName.c_str(), dlerror());
LOG_WARNING("C01123006:动态链接库 %1 加载失败! 错误: %2", servicePath, dlerror());
}
}
XNServiceObjectPtr XNServiceManager::GetService(uint32_t serviceID)
{
T_D();
if (d->ServiceIDAssigned[serviceID - 20000]
&& d->ServiceList.find(serviceID) != d->ServiceList.end()) {
return d->ServiceList[serviceID];
} else {
if (serviceID >= 20000 && serviceID < 30000) {
if (d->ServiceIDAssigned[serviceID - 20000]) {
if (d->ServiceList.find(serviceID) != d->ServiceList.end()) {
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()

94
XNCore/XNServiceObject.cpp
View File

@ -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 "
"with the service name in the configuration file of service %2!",
GetObjectName(), serviceName);
LOG_WARNING("A01153003:服务配置文件 %1 中服务名称不一致, 服务名称: %2, 配置文件中名称: %3!",
GetXmlPath(), 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(),
serviceVersion.c_str());
LOG_ERROR("A01152008:未找到服务名称为 %1, 版本号 %2 的记录", serviceName, serviceVersion);
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:获取主框架失败!");
}
}

30
XNCore/XNThread.cpp
View File

@ -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;

25
XNCore/XNThreadManager.cpp
View File

@ -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",
id, freqGroup, RunPos, RunPriorty);
LOG_INFO("D01074005:模型 [ %1 ] 注册周期性函数成功! 运行节点: %2-%3 优先级: %4", id,
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 "
"between 0 and 5, registration failed!",
id);
LOG_WARNING("A01073006:模型 [ %1 ] 的运行频率分组不在0~5之间,注册失败!", id);
return false;
} else if (RunPos > (1 << freqGroup)) {
// 如果运行节点不符合要求
LOG_WARNING("0x2171 The run node submitted for registration by model [ %1 ] exceeds the "
"maximum node count for the frequency group, registration failed!",
id);
LOG_WARNING("A01073007:模型 [ %1 ] 的运行节点 %2 超出当前频率分组最大节点数 %3,注册失败!",
id, RunPos, (1 << freqGroup));
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();
}

20
XNCore/XNTimeManager.cpp
View File

@ -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;
}