V0.2.7

1、修改了一致性对比线程的运行方式，将其合并到其他线程中了
2、新增了写入报警日志的功能线程

CMakeLists.txt

@@ -194,5 +194,5 @@ file(GLOB GLOBAL_SRC
 add_subdirectory(${CMAKE_SOURCE_DIR}/Server)
 add_subdirectory(${CMAKE_SOURCE_DIR}/SettingLibrary)
 add_subdirectory(${CMAKE_SOURCE_DIR}/show2)
-# add_subdirectory(${CMAKE_SOURCE_DIR}/show3)
+add_subdirectory(${CMAKE_SOURCE_DIR}/show3)
 

RTPServer/RtpOneRoadThread.cpp

@@ -1,4 +1,5 @@
 #include "RtpOneRoadThread.h"
+#include "spdlog.h"
 
 
 
@@ -140,7 +141,7 @@ bool RTPOneRoadThread::removeUdpSession(const RtpSendClientInfo_t& udpSession)
 /* 发送数据的线程函数 */
 void RTPOneRoadThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, "------------- {} 开启RTP发送数据线程 -------------", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, "➢ {} 开启RTP发送数据线程 ", m_logBase);
     if(!initData())
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
@@ -156,7 +157,7 @@ void RTPOneRoadThread::task()
     m_eventLoop.exec();
     /* 清空数据 */
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, "------------- {} RTP发送数据线程结束 -------------", m_logBase);
+    SPDLOG_LOGGER_WARN(m_logger, "➢ {} RTP发送数据线程结束 ", m_logBase);
 }
 
 

SQL/ACASetting.sqlbook

@@ -1,143 +1,163 @@
 -- SQLBook: Code
--- Active: 1751960213665@@192.1.2.61@5236@EQM_CESHI
-
-#存储对比项的表格 tACACompareItems
-#对比项的对比通道表 tACACompareItemRoad
-
-#创建 tACACompareItems
--- 创建表
-CREATE TABLE tACACompareItems
-(
-    ItemID INT PRIMARY KEY,
-    ItemName VARCHAR(64) NOT NULL,
-    ItemEnable BIT NOT NULL DEFAULT 1,
-    RoadCount INT DEFAULT 0,
-    SilentEnable BIT NOT NULL DEFAULT 0,
-    SilentThreshold INT DEFAULT 0,
-    SilentDuration INT DEFAULT 0,
-    SilentSensitivity INT DEFAULT 0,
-    OverloadEnable BIT NOT NULL DEFAULT 0,
-    OverloadThreshold INT DEFAULT 0,
-    OverloadDuration INT DEFAULT 0,
-    OverloadSensitivity INT DEFAULT 0,
-    PhaseEnable BIT NOT NULL DEFAULT 0,
-    PhaseThreshold DOUBLE DEFAULT 0,
-    PhaseDuration INT DEFAULT 0,
-    PhaseSensitivity INT DEFAULT 0
-);
--- 表注释
-COMMENT ON TABLE tACACompareItems IS 'ACA对比项表';
--- 字段注释
-COMMENT ON COLUMN tACACompareItems.ItemID IS '对比项ID';
-COMMENT ON COLUMN tACACompareItems.ItemName IS '对比项名称';
-COMMENT ON COLUMN tACACompareItems.ItemEnable IS '对比项是否启用';
-COMMENT ON COLUMN tACACompareItems.RoadCount IS '对比通道数';
-COMMENT ON COLUMN tACACompareItems.SilentEnable IS '是否启用静音';
-COMMENT ON COLUMN tACACompareItems.SilentThreshold IS '静音阈值';
-COMMENT ON COLUMN tACACompareItems.SilentDuration IS '静音持续时间';
-COMMENT ON COLUMN tACACompareItems.SilentSensitivity IS '静音灵敏度';
-COMMENT ON COLUMN tACACompareItems.OverloadEnable IS '是否启用过载';
-COMMENT ON COLUMN tACACompareItems.OverloadThreshold IS '过载阈值';
-COMMENT ON COLUMN tACACompareItems.OverloadDuration IS '过载持续时间';
-COMMENT ON COLUMN tACACompareItems.OverloadSensitivity IS '过载灵敏度';
-COMMENT ON COLUMN tACACompareItems.PhaseEnable IS '是否启用反相';
-COMMENT ON COLUMN tACACompareItems.PhaseThreshold IS '反相阈值';
-COMMENT ON COLUMN tACACompareItems.PhaseDuration IS '反相持续时间';
-COMMENT ON COLUMN tACACompareItems.PhaseSensitivity IS '反相灵敏度';
--- 创建索引
--- CREATE INDEX idx_tACACompareItems_ItemName ON tACACompareItems (ItemName);
+-- Active: 1751960213665@@192.1.2.61@5236@EQM_CESHI
+
+#存储对比项的表格 tACACompareItems
+#对比项的对比通道表 tACACompareItemRoad
+
+#创建 tACACompareItems
+-- 创建表
+CREATE TABLE tACACompareItems
+(
+    ItemID INT PRIMARY KEY,
+    ItemName VARCHAR(64) NOT NULL,
+    ItemEnable BIT NOT NULL DEFAULT 1,
+    RoadCount INT DEFAULT 0,
+    SilentEnable BIT NOT NULL DEFAULT 0,
+    SilentThreshold INT DEFAULT 0,
+    SilentDuration INT DEFAULT 0,
+    SilentSensitivity INT DEFAULT 0,
+    OverloadEnable BIT NOT NULL DEFAULT 0,
+    OverloadThreshold INT DEFAULT 0,
+    OverloadDuration INT DEFAULT 0,
+    OverloadSensitivity INT DEFAULT 0,
+    PhaseEnable BIT NOT NULL DEFAULT 0,
+    PhaseThreshold DOUBLE DEFAULT 0,
+    PhaseDuration INT DEFAULT 0,
+    PhaseSensitivity INT DEFAULT 0
+);
+-- 表注释
+COMMENT ON TABLE tACACompareItems IS 'ACA对比项表';
+-- 字段注释
+COMMENT ON COLUMN tACACompareItems.ItemID IS '对比项ID';
+COMMENT ON COLUMN tACACompareItems.ItemName IS '对比项名称';
+COMMENT ON COLUMN tACACompareItems.ItemEnable IS '对比项是否启用';
+COMMENT ON COLUMN tACACompareItems.RoadCount IS '对比通道数';
+COMMENT ON COLUMN tACACompareItems.SilentEnable IS '是否启用静音';
+COMMENT ON COLUMN tACACompareItems.SilentThreshold IS '静音阈值';
+COMMENT ON COLUMN tACACompareItems.SilentDuration IS '静音持续时间';
+COMMENT ON COLUMN tACACompareItems.SilentSensitivity IS '静音灵敏度';
+COMMENT ON COLUMN tACACompareItems.OverloadEnable IS '是否启用过载';
+COMMENT ON COLUMN tACACompareItems.OverloadThreshold IS '过载阈值';
+COMMENT ON COLUMN tACACompareItems.OverloadDuration IS '过载持续时间';
+COMMENT ON COLUMN tACACompareItems.OverloadSensitivity IS '过载灵敏度';
+COMMENT ON COLUMN tACACompareItems.PhaseEnable IS '是否启用反相';
+COMMENT ON COLUMN tACACompareItems.PhaseThreshold IS '反相阈值';
+COMMENT ON COLUMN tACACompareItems.PhaseDuration IS '反相持续时间';
+COMMENT ON COLUMN tACACompareItems.PhaseSensitivity IS '反相灵敏度';
+-- 创建索引
+-- CREATE INDEX idx_tACACompareItems_ItemName ON tACACompareItems (ItemName);
 
 -- SQLBook: Code
-#删除 tACACompareItems
+#删除 tACACompareItems
 DROP TABLE IF EXISTS "EQM_CESHI".tACACompareItems;
 -- SQLBook: Code
-
-#创建 tACACompareItemRoad
-#这里设置了级联删除，当 tACACompareItems 表中的某个对比项被删除时，tACACompareItemRoad 中对应的通道也会被删除。
-CREATE TABLE tACACompareItemRoad
-(
-    ItemID INT NOT NULL,
-    RoadNum INT NOT NULL,
-    RoadName VARCHAR(64) NOT NULL,
-    RoadRecordEnable BIT NOT NULL DEFAULT 1,
-    SoundCardNum INT NOT NULL DEFAULT 0,
-    SoundCardID VARCHAR(64),
-    SoundCardName VARCHAR(64),
-    SoundCardRoadNum INT NOT NULL DEFAULT 0,
-    ChannelID INT,
-    ChannelName VARCHAR(64),
-    PRIMARY KEY (ItemID, RoadNum),
-    FOREIGN KEY (ItemID) REFERENCES tACACompareItems(ItemID)
-        ON DELETE CASCADE
-);
-
--- 表注释
-COMMENT ON TABLE tACACompareItemRoad IS '对比项通道表';
--- 字段注释
-COMMENT ON COLUMN tACACompareItemRoad.ItemID IS '对比项ID';
-COMMENT ON COLUMN tACACompareItemRoad.RoadNum IS '通道编号，1是主通道，其他对比通道依次向后排';
-COMMENT ON COLUMN tACACompareItemRoad.RoadName IS '通道名称';
-COMMENT ON COLUMN tACACompareItemRoad.RoadRecordEnable IS '通道录音是否启用';
-COMMENT ON COLUMN tACACompareItemRoad.SoundCardNum IS '声卡编号，在系统中的编号';
-COMMENT ON COLUMN tACACompareItemRoad.SoundCardID IS '声卡ID，可以使用声卡ID来打开声卡';
-COMMENT ON COLUMN tACACompareItemRoad.SoundCardName IS '声卡名称';
-COMMENT ON COLUMN tACACompareItemRoad.SoundCardRoadNum IS '声卡通道编号，使用声卡编号和声卡通道编号开始录音';
-COMMENT ON COLUMN tACACompareItemRoad.ChannelID IS '频道ID';
-COMMENT ON COLUMN tACACompareItemRoad.ChannelName IS '频道名称';
+
+#创建 tACACompareItemRoad
+#这里设置了级联删除，当 tACACompareItems 表中的某个对比项被删除时，tACACompareItemRoad 中对应的通道也会被删除。
+CREATE TABLE tACACompareItemRoad
+(
+    ItemID INT NOT NULL,
+    RoadNum INT NOT NULL,
+    RoadName VARCHAR(64) NOT NULL,
+    RoadRecordEnable BIT NOT NULL DEFAULT 1,
+    SoundCardNum INT NOT NULL DEFAULT 0,
+    SoundCardID VARCHAR(64),
+    SoundCardName VARCHAR(64),
+    SoundCardRoadNum INT NOT NULL DEFAULT 0,
+    ChannelID INT,
+    ChannelName VARCHAR(64),
+    PRIMARY KEY (ItemID, RoadNum),
+    FOREIGN KEY (ItemID) REFERENCES tACACompareItems(ItemID)
+        ON DELETE CASCADE
+);
+
+-- 表注释
+COMMENT ON TABLE tACACompareItemRoad IS '对比项通道表';
+-- 字段注释
+COMMENT ON COLUMN tACACompareItemRoad.ItemID IS '对比项ID';
+COMMENT ON COLUMN tACACompareItemRoad.RoadNum IS '通道编号，1是主通道，其他对比通道依次向后排';
+COMMENT ON COLUMN tACACompareItemRoad.RoadName IS '通道名称';
+COMMENT ON COLUMN tACACompareItemRoad.RoadRecordEnable IS '通道录音是否启用';
+COMMENT ON COLUMN tACACompareItemRoad.SoundCardNum IS '声卡编号，在系统中的编号';
+COMMENT ON COLUMN tACACompareItemRoad.SoundCardID IS '声卡ID，可以使用声卡ID来打开声卡';
+COMMENT ON COLUMN tACACompareItemRoad.SoundCardName IS '声卡名称';
+COMMENT ON COLUMN tACACompareItemRoad.SoundCardRoadNum IS '声卡通道编号，使用声卡编号和声卡通道编号开始录音';
+COMMENT ON COLUMN tACACompareItemRoad.ChannelID IS '频道ID';
+COMMENT ON COLUMN tACACompareItemRoad.ChannelName IS '频道名称';
 
 -- SQLBook: Code
-#创建ACA的系统配置表，使用Key获取存储的值，值内容是一个JOSN字符串
-CREATE TABLE tACASystemConfig
-(
-    PKID INT PRIMARY KEY AUTO_INCREMENT,
-    ConfigKey VARCHAR(64) NOT NULL UNIQUE,
-    ConfigValue TEXT NOT NULL,
-    UpdateTime TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    ConfigDesc VARCHAR(256)
-);
-CREATE OR REPLACE TRIGGER trg_update_time
-BEFORE UPDATE ON tACASystemConfig
-FOR EACH ROW
-BEGIN
-    :NEW.UpdateTime := CURRENT_TIMESTAMP;
-END;
--- 表注释
-COMMENT ON TABLE tACASystemConfig IS 'ACA系统配置表';
--- 字段注释
-COMMENT ON COLUMN tACASystemConfig.PKID IS '主键ID';
-COMMENT ON COLUMN tACASystemConfig.ConfigKey IS '配置键';
-COMMENT ON COLUMN tACASystemConfig.ConfigValue IS '配置值，存储为JSON字符串';
-COMMENT ON COLUMN tACASystemConfig.UpdateTime IS '配置更新时间';
+#创建ACA的系统配置表，使用Key获取存储的值，值内容是一个JOSN字符串
+CREATE TABLE tACASystemConfig
+(
+    PKID INT PRIMARY KEY AUTO_INCREMENT,
+    ConfigKey VARCHAR(64) NOT NULL UNIQUE,
+    ConfigValue TEXT NOT NULL,
+    UpdateTime TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    ConfigDesc VARCHAR(256)
+);
+CREATE OR REPLACE TRIGGER trg_update_time
+BEFORE UPDATE ON tACASystemConfig
+FOR EACH ROW
+BEGIN
+    :NEW.UpdateTime := CURRENT_TIMESTAMP;
+END;
+-- 表注释
+COMMENT ON TABLE tACASystemConfig IS 'ACA系统配置表';
+-- 字段注释
+COMMENT ON COLUMN tACASystemConfig.PKID IS '主键ID';
+COMMENT ON COLUMN tACASystemConfig.ConfigKey IS '配置键';
+COMMENT ON COLUMN tACASystemConfig.ConfigValue IS '配置值，存储为JSON字符串';
+COMMENT ON COLUMN tACASystemConfig.UpdateTime IS '配置更新时间';
 COMMENT ON COLUMN tACASystemConfig.ConfigDesc IS '配置描述';
 -- SQLBook: Code
-#创建检测计划表格
-CREATE TABLE tACADetectPeriod
-(
-    ItemID INT NOT NULL,
-    IsDetect BIT NOT NULL DEFAULT 1, -- 是否检测
-    WeekType INT NOT NULL,
-    CDate VARCHAR(32),
-    TimeStart VARCHAR(32) NOT NULL,
-    TimeEnd VARCHAR(32) NOT NULL,
-    ApplySlient BIT NOT NULL DEFAULT 0,  -- 是否应用静音
-    ApplyOverload BIT NOT NULL DEFAULT 0, -- 是否应用超载
-    ApplyPhase BIT NOT NULL DEFAULT 0,   -- 是否应用反相
-    ApplyNoise BIT NOT NULL DEFAULT 0,   -- 是否应用噪音
-    FOREIGN KEY (ItemID) REFERENCES tACACompareItems(ItemID)
-        ON DELETE CASCADE
-);
--- 表注释
-COMMENT ON TABLE tACADetectPeriod IS '检测计划表';
--- 字段注释
-COMMENT ON COLUMN tACADetectPeriod.ItemID IS '对比项ID';
-COMMENT ON COLUMN tACADetectPeriod.IsDetect IS '是否检测，1表示检测日期，0表示非检测日期';
-COMMENT ON COLUMN tACADetectPeriod.WeekType IS '检测计划的星期，1-7表示周一到周日，8表示特殊日期，也就是非检测日';
-COMMENT ON COLUMN tACADetectPeriod.CDate IS '检测计划的日期';
-COMMENT ON COLUMN tACADetectPeriod.TimeStart IS '检测计划的开始时间';
-COMMENT ON COLUMN tACADetectPeriod.TimeEnd IS '检测计划的结束时间';
-COMMENT ON COLUMN tACADetectPeriod.ApplySlient IS '是否应用静音检测';
-COMMENT ON COLUMN tACADetectPeriod.ApplyOverload IS '是否应用超载检测';
-COMMENT ON COLUMN tACADetectPeriod.ApplyPhase IS '是否应用反相检测';
-COMMENT ON COLUMN tACADetectPeriod.ApplyNoise IS '是否应用噪音检测';
--- 创建索引
-CREATE INDEX idx_tACADetectPeriod_ItemID ON tACADetectPeriod (ItemID);
+#创建检测计划表格
+CREATE TABLE tACADetectPeriod
+(
+    ItemID INT NOT NULL,
+    IsDetect BIT NOT NULL DEFAULT 1, -- 是否检测
+    WeekType INT NOT NULL,
+    CDate VARCHAR(32),
+    TimeStart VARCHAR(32) NOT NULL,
+    TimeEnd VARCHAR(32) NOT NULL,
+    ApplySlient BIT NOT NULL DEFAULT 0,  -- 是否应用静音
+    ApplyOverload BIT NOT NULL DEFAULT 0, -- 是否应用超载
+    ApplyPhase BIT NOT NULL DEFAULT 0,   -- 是否应用反相
+    ApplyNoise BIT NOT NULL DEFAULT 0,   -- 是否应用噪音
+    FOREIGN KEY (ItemID) REFERENCES tACACompareItems(ItemID)
+        ON DELETE CASCADE
+);
+-- 表注释
+COMMENT ON TABLE tACADetectPeriod IS '检测计划表';
+-- 字段注释
+COMMENT ON COLUMN tACADetectPeriod.ItemID IS '对比项ID';
+COMMENT ON COLUMN tACADetectPeriod.IsDetect IS '是否检测，1表示检测日期，0表示非检测日期';
+COMMENT ON COLUMN tACADetectPeriod.WeekType IS '检测计划的星期，1-7表示周一到周日，8表示特殊日期，也就是非检测日';
+COMMENT ON COLUMN tACADetectPeriod.CDate IS '检测计划的日期';
+COMMENT ON COLUMN tACADetectPeriod.TimeStart IS '检测计划的开始时间';
+COMMENT ON COLUMN tACADetectPeriod.TimeEnd IS '检测计划的结束时间';
+COMMENT ON COLUMN tACADetectPeriod.ApplySlient IS '是否应用静音检测';
+COMMENT ON COLUMN tACADetectPeriod.ApplyOverload IS '是否应用超载检测';
+COMMENT ON COLUMN tACADetectPeriod.ApplyPhase IS '是否应用反相检测';
+COMMENT ON COLUMN tACADetectPeriod.ApplyNoise IS '是否应用噪音检测';
+-- 创建索引
+CREATE INDEX idx_tACADetectPeriod_ItemID ON tACADetectPeriod (ItemID);
+-- SQLBook: Code
+#创建报警记录表
+CREATE TABLE tACAAlarmInfo
+(
+    PKID INT PRIMARY KEY AUTO_INCREMENT,
+    ItemID INT NOT NULL,
+    ItemName VARCHAR(64) NOT NULL,
+    AlarmType INT NOT NULL, -- 报警类型，1-静音，2-过载，3-反相，4-噪音
+    SoundCardNum VARCHAR(64) NOT NULL, -- 声卡编号（在系统中的编号）
+    SoundCardName VARCHAR(64), -- 声卡名称
+    SoundCardRoadNum INT NOT NULL, -- 声卡通道编号
+    CompareRoadNum INT NOT NULL, -- 对比通道编号
+    CompareRoadName VARCHAR(64), -- 对比通道名称
+    CompareRoadType INT, -- 通道类型：1、主输出，2、空收，3、主输出空收
+    AlarmStartTime VARCHAR(32), -- 报警开始时间 (格式：YYYY-MM-DD HH:MM:SS)
+    AlarmEndTime VARCHAR(32), -- 报警结束时间 (格式：YYYY-MM-DD HH:MM:SS)
+    AlarmDuration INT, -- 报警持续时间（秒数）
+    AlarmFilePath VARCHAR(256), -- 报警录音文件路径
+    
+)

Server/ACAServer.cpp

@@ -7,6 +7,7 @@
 #include "SystemConfig.h"
 #include "ThreadPool.h"
 #include "ThreadManager.h"
+#include "ThreadAlarmManager.h"
 
 #include <QFile>
 #include <QString>
@@ -30,10 +31,10 @@ ACAServer::ACAServer()
 
 ACAServer::~ACAServer()
 {
-    if(m_threadCompareItemManager != nullptr) {
-        delete m_threadCompareItemManager;
-        m_threadCompareItemManager = nullptr;
-    }
+    // if(m_threadCompareItemManager != nullptr) {
+    //     delete m_threadCompareItemManager;
+    //     m_threadCompareItemManager = nullptr;
+    // }
 }
 
 
@@ -109,16 +110,18 @@ bool ACAServer::initGlobalInfo()
 /* 开启服务 */
 bool ACAServer::startService()
 {
-    m_threadCompareItemManager = new ThreadCompareItemManager();
-    if(m_threadCompareItemManager == nullptr) 
-    {
-        SPDLOG_LOGGER_ERROR(m_logger, "创建对比项管理线程失败");
-        return false;
-    }
+    // m_threadCompareItemManager = new ThreadCompareItemManager();
+    // if(m_threadCompareItemManager == nullptr) 
+    // {
+    //     SPDLOG_LOGGER_ERROR(m_logger, "创建对比项管理线程失败");
+    //     return false;
+    // }
     /* 开启对比项管理线程 */
-    CPPTP.add_task(&ThreadCompareItemManager::thread_CompareItemManager, m_threadCompareItemManager);
+    CPPTP.add_task(&ThreadCompareItemManager::thread_CompareItemManager, &CompareItemManager);
     /* 开启录音通道检查线程 */
     CPPTP.add_task(&ACAServer::thread_deleteRecordThread, this);
+    /* 开启处理报警信息的线程 */
+    CPPTP.add_task(&ThreadAlarmManager::thread_task, &AlarmManager);
 
     return true;
 }

Server/ACAServer.h

@@ -71,7 +71,7 @@ private:
     const QString m_appType = "ACAWatch"; /* 应用类型 */
     std::atomic_bool m_isGetWebInfoSuccess = false; /* 是否获取WebAPI信息成功 */
 
-    ThreadCompareItemManager* m_threadCompareItemManager = nullptr; /* 对比项管理线程 */
+    // ThreadCompareItemManager* m_threadCompareItemManager = nullptr; /* 对比项管理线程 */
 
 };
 

Server/CMakeLists.txt

@@ -87,6 +87,8 @@ target_include_directories(${this_exe} PRIVATE
     ${CMAKE_SOURCE_DIR}/External/module/ThreadPool
     ${CMAKE_SOURCE_DIR}/External/module/RingQueue
     ${CMAKE_SOURCE_DIR}/External/module/mqtt
+    ${CMAKE_SOURCE_DIR}/External/module/mqtt_cpp
+    ${CMAKE_SOURCE_DIR}/External/module/OneThread
     
 
     ${spdlog_INCLUDE_DIR}

Server/DataStruct/AudioData.cpp

@@ -413,11 +413,11 @@ int32_t AudioSrcData::appendData(const char* srcData, int32_t size)
 
 AudioLeftRightData::AudioLeftRightData(int totalSize)
 {
-    if (totalSize == 0)
-    {
-        SPDLOG_ERROR("AudioLeftRightData::AudioLeftRightData totalSize is 0");
-        return;
-    }
+    // if (totalSize == 0)
+    // {
+    //     SPDLOG_ERROR("AudioLeftRightData::AudioLeftRightData totalSize is 0");
+    //     return;
+    // }
     this->totalSize = totalSize;
     vecLeftData.reserve(totalSize);
 	vecRightData.reserve(totalSize);

Server/ThreadCalculate/BaseCalculateThread.cpp

@@ -23,16 +23,17 @@ void BaseCalculateThread::threadTask()
                             m_threadInfo.compareItemInfo.strName.toStdString(),
                             static_cast<int>(m_threadInfo.threadType));
     m_threadInfo.threadState = EThreadState::State_Running;
+    m_isRunning = true;
     m_isStop = false;
     /* 执行任务，并阻塞到这个函数中，直到任务退出 */
     task();
 
-    SPDLOG_LOGGER_INFO(m_logger, "{} 执行结束", m_logBase);
     m_isRunning = false;
     /* 清理资源 */
     /* 设置全局的线程状态 */
     m_threadInfo.threadState = EThreadState::State_Stopped;
     m_isStop.store(true);
+    SPDLOG_LOGGER_INFO(m_logger, "★ {} 执行结束", m_logBase);
 }
 
 /* 更新线程信息 */

Server/ThreadCalculate/BaseCalculateThread.h

@@ -30,9 +30,9 @@ public:
     void updateThreadInfo(const CalculateThreadInfo_t& threadInfo);
 
     /* 停止线程，只设置个停止标志，不阻塞等待 */
-    void stopThread();
+    virtual void stopThread();
     /* 停止线程 */
-    void stopThreadBlock();
+    virtual void stopThreadBlock();
     
 
 protected:

Server/ThreadCalculate/CalculateDBThread.cpp

@@ -77,7 +77,7 @@ void CalculateDBThread::task()
     {
         return;
     }
-    SPDLOG_LOGGER_INFO(m_logger, " ****************** {} 开启计算静音、过载和反相等报警的线程 ****************** ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 开启计算静音、过载和反相等报警的线程 ", m_logBase);
     while(m_isRunning)
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -104,7 +104,7 @@ void CalculateDBThread::task()
     /* 清理数据 */
     clearData();
 
-    SPDLOG_LOGGER_INFO(m_logger, " ****************** {} 计算静音、过载和反相等报警的线程结束 ****************** ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, "★ {} 计算静音、过载和反相等报警的线程结束 ", m_logBase);
 }
 
 /* 初始化数据 */

Server/ThreadCalculate/CompareDoubleThread.cpp

@@ -62,11 +62,14 @@ void CompareDoubleThread::task()
         SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
         return;
     }
-    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 计算一致性对比的线程开始运行 ******************* ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 计算一致性对比的线程开始运行  ", m_logBase);
     while(m_isRunning)
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
+        /* 使用比对动态库比对一致性 */
+        m_pConsistencyCompareThread->compareConsistencyData();
+
         /* 更新数据 */
         if(!updateData())
         {
@@ -86,7 +89,7 @@ void CompareDoubleThread::task()
 
     /* 清理数据 */
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 计算双通道对比的线程结束 ******************* ", m_logBase);
+    SPDLOG_LOGGER_WARN(m_logger, " ★ {} 计算双通道对比的线程结束 ", m_logBase);
     m_threadInfo.threadState = EThreadState::State_Stopped; // 更新线程状态
 }
 
@@ -149,14 +152,16 @@ bool CompareDoubleThread::initData()
         return false;
     }
     
-    /* 创建一致性比较的线程 */
+    /* 创建一致性比较的线程，这里不再单独开线程了，合并到这个线程中执行 */
     m_pConsistencyCompareThread = new ConsistencyCompareThread(m_threadInfo);
-    if(m_pConsistencyCompareThread == nullptr)
-    {
-        SPDLOG_LOGGER_ERROR(m_logger, "{} 创建一致性比较线程失败", m_logBase);
-        return false;
-    }
-    CPPTP.add_task(&ConsistencyCompareThread::threadTask, m_pConsistencyCompareThread);
+    // if(m_pConsistencyCompareThread == nullptr)
+    // {
+    //     SPDLOG_LOGGER_ERROR(m_logger, "{} 创建一致性比较线程失败", m_logBase);
+    //     return false;
+    // }
+    // CPPTP.add_task(&ConsistencyCompareThread::threadTask, m_pConsistencyCompareThread);
+    /* 初始化对比功能 */
+    m_pConsistencyCompareThread->initConsistencyCompare();
 
 
     return true;
@@ -165,10 +170,16 @@ bool CompareDoubleThread::initData()
 /* 清理数据 */
 void CompareDoubleThread::clearData()
 {
+    // if(m_pConsistencyCompareThread != nullptr)
+    // {
+    //     m_pConsistencyCompareThread->stopThreadBlock(); // 停止线程
+    //     delete m_pConsistencyCompareThread; 
+    //     m_pConsistencyCompareThread = nullptr;
+    // }
     if(m_pConsistencyCompareThread != nullptr)
     {
-        m_pConsistencyCompareThread->stopThreadBlock(); // 停止线程
-        delete m_pConsistencyCompareThread; 
+        m_pConsistencyCompareThread->clearConsistencyCompareData();
+        delete m_pConsistencyCompareThread;
         m_pConsistencyCompareThread = nullptr;
     }
 }

Server/ThreadCalculate/CompareItemThread.cpp

@@ -8,13 +8,12 @@
 #include "CompareDoubleThread.h"
 #include "ThreadPool.h"
 #include "commonDefine.h"
-#include "spdlog.h"
-#include <qt5/QtCore/qchar.h>
-#include <qt5/QtCore/qglobal.h>
+#include "ThreadAlarmManager.h"
+
 
 
 CompareItemThread::CompareItemThread(CalculateThreadInfo_t& threadInfo)
-    : BaseCalculateThread(threadInfo)
+    : QObject(nullptr), BaseCalculateThread(threadInfo)
 {
 
 }
@@ -24,6 +23,88 @@ CompareItemThread::~CompareItemThread()
 
 }
 
+/* 重写父类的线程函数，这里重新实现 */
+void CompareItemThread::threadTask()
+{
+    m_logBase = fmt::format("对比项: {}", m_threadInfo.compareItemInfo.strName.toStdString());
+    SPDLOG_LOGGER_INFO(m_logger, "----------------------------------------------------------------");
+    SPDLOG_LOGGER_INFO(m_logger, "{} 线程开始运行, 对比通道: ", m_logBase);
+    for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
+    {
+        SPDLOG_LOGGER_INFO(m_logger, "      通道名称: {}, 通道编号: {}, 声卡通道: {}:{}",
+                           road.strCompareRoadName.toStdString(), road.nCompareRoadNum, road.scRoadInfo.strSoundCardName.toStdString(), road.scRoadInfo.roadInfo.nRoadNum);
+    }
+    SPDLOG_LOGGER_INFO(m_logger, "----------------------------------------------------------------");
+
+    /* 初始化数据 */
+    if(!initData())
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
+        return;
+    }
+    
+    /* 更新线程状态标志 */
+    m_threadInfo.threadState = EThreadState::State_Running;
+    m_isStop = false;
+
+
+
+    m_pTimer = new QTimer();
+    if(m_pTimer == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "{} 创建定时器失败", m_logBase);
+    }
+    
+        // SPDLOG_LOGGER_WARN(m_logger, "{} 创建定时器成功，开启定时器", m_logBase);
+    m_pTimer->setTimerType(Qt::PreciseTimer);
+    m_pTimer->setSingleShot(false); // 设置为非单次定时器
+    m_pTimer->setInterval(50);
+    m_eventLoop.connect(m_pTimer, &QTimer::timeout, this, &CompareItemThread::do_timeout);
+    m_pTimer->start();
+    
+
+    /* 开启事件循环 */
+    m_eventLoop.exec();
+
+    /* 等待 */
+    // std::this_thread::sleep_for(std::chrono::seconds(20));
+
+    /* 线程结束，清理数据 */
+    clearData();
+    m_threadInfo.threadState = EThreadState::State_Stopped;
+    m_isStop = true;
+    SPDLOG_LOGGER_WARN(m_logger, "★ {} 线程结束运行", m_logBase);
+}
+
+
+/* 停止线程函数 */
+void CompareItemThread::stopThread()
+{
+    if(m_pTimer != nullptr)
+    {
+        if(m_pTimer->isActive())
+        {
+            m_pTimer->stop();
+        }
+        disconnect(m_pTimer, &QTimer::timeout, this, &CompareItemThread::do_timeout);
+        delete m_pTimer;
+        m_pTimer = nullptr;
+    }
+    /* 停止事件循环 */
+    m_eventLoop.quit();
+    
+}
+
+void CompareItemThread::stopThreadBlock()
+{
+    stopThread();
+    while(!m_isStop) // 等待线程停止
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+
 
 /* 线程功能函数 */
 void CompareItemThread::task()
@@ -38,23 +119,13 @@ void CompareItemThread::task()
     }
     SPDLOG_LOGGER_INFO(m_logger, "----------------------------------------------------------------");
 
-    /* 测试录音通道用 */
-    // for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
-    // {
-    //     ThreadMan.createRecordThread(road.scRoadInfo, m_threadInfo.compareItemInfo.nID);
-    // }
-    // while(true)
-    // {
-    //     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    // }
-
-
     /* 初始化数据 */
     if(!initData())
     {
         SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
         return;
     }
+    // SPDLOG_LOGGER_WARN(m_logger, "{} 初始化数据完成，开始对比检测, isRunning: {}", m_logBase, m_isRunning.load());
 
     while (m_isRunning)
     {
@@ -78,6 +149,7 @@ void CompareItemThread::task()
         if(!updateResultData())
         {
             continue;
+            // return;
         }
 
         /* -------------------------------------------------------------------------------------
@@ -92,11 +164,44 @@ void CompareItemThread::task()
 
         /* 清除标志位 */
         clearUpdateFlags();
-        // SPDLOG_LOGGER_WARN(m_logger, "{} 发送对比项数据到MQTT中", m_logBase);
+        SPDLOG_LOGGER_WARN(m_logger, "{} 发送对比项数据到MQTT中", m_logBase);
     }
     /* 清理数据 */
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, "{} 线程结束运行", m_logBase);
+    SPDLOG_LOGGER_WARN(m_logger, "★ {} 线程结束运行", m_logBase);
+}
+
+/* 定时器任务 */
+void CompareItemThread::timerTask()
+{
+    /* -------------------------------------------------------------------------------------
+     * 更新对比项信息
+     * ------------------------------------------------------------------------------------- */
+    if(updateThreadInfoInternal())
+    {
+        SPDLOG_LOGGER_INFO(m_logger, "{} 暂停对比检测，更新对比项信息");
+        m_threadInfo.compareItemInfo = m_threadInfoNew.compareItemInfo;
+        initData();
+        SPDLOG_LOGGER_INFO(m_logger, "{} 更新对比项信息完成，继续检测对比");
+    }
+    /* -------------------------------------------------------------------------------------
+     * 更新数据
+     * ------------------------------------------------------------------------------------- */
+    if(!updateResultData())
+    {
+        return;
+    }
+    /* -------------------------------------------------------------------------------------
+     * 处理数据，将报警信息给写报警数据的线程
+     * ------------------------------------------------------------------------------------- */
+    processAlarmData();
+    /* -------------------------------------------------------------------------------------
+     * 将音量包数据发送到MQTT中
+     * ------------------------------------------------------------------------------------- */
+    sendResultData();
+    /* 清除标志位 */
+    clearUpdateFlags();
+    // SPDLOG_LOGGER_WARN(m_logger, "{} 发送对比项数据到MQTT中", m_logBase);
 }
 
 /* 初始化数据 */
@@ -118,7 +223,7 @@ bool CompareItemThread::initData()
 
     /* 获取计算噪音的线程 */
     removeNoiseDetectThreads(); // 清理之前的噪音检测线程
-    getNoiseDetectThreads();
+    // getNoiseDetectThreads();
 
     /* 初始化存储结果的数据结构 */
     m_compareResult = CompareResult_t();
@@ -161,35 +266,7 @@ bool CompareItemThread::initData()
         m_mapAlarmOverloadLast.insert({road.nCompareRoadNum, AlarmInfo_t()});
         m_mapAlarmPhaseLast.insert({road.nCompareRoadNum, AlarmInfo_t()});
     }
-
-    /* 登陆MQTT */
-    m_pubTopic = QString("%1/%2").arg(GInfo.mqttPubTopicDB()).arg(QString::number(m_threadInfo.compareItemInfo.nID));
-    m_pFromMQTT = new FromMQTT;
-    m_pFromMQTT->setIPAndPort(GInfo.mqttIP(), GInfo.mqttPort());
-    m_pFromMQTT->connectToServer();
-    /* 等待连接成功 */
-    auto startTime = std::chrono::steady_clock::now(); // 记录开始时间
-    while(true)
-    {
-        if(m_pFromMQTT->connectState() == QMQTT::ConnectionState::STATE_CONNECTED)
-        {
-            break; // 连接成功
-        }
-        /* 超过10秒还没有连接成功，返回失败 */
-        if(std::chrono::steady_clock::now() - startTime > std::chrono::seconds(10))
-        {
-            SPDLOG_LOGGER_ERROR(m_logger, "{} 连接MQTT服务器超时", m_logBase);
-            if(m_pFromMQTT != nullptr)
-            {
-                delete m_pFromMQTT; // 删除MQTT对象
-                m_pFromMQTT = nullptr; // 设置为nullptr
-            }
-            return false;
-        }
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    }
-
-    SPDLOG_LOGGER_INFO(m_logger, "☆ {} 音量包订阅主题: {}", m_logBase, m_pubTopic.toStdString());
+    
 
     return true;
 }
@@ -198,16 +275,12 @@ bool CompareItemThread::initData()
 void CompareItemThread::clearData()
 {
     /* 停止所有的比对线程 */
-    for(auto& pair : m_mapCompareDoubleThreads)
-    {
-        if(pair.second != nullptr)
-        {
-            pair.second->stopThreadBlock();
-            delete pair.second;
-            pair.second = nullptr;
-        }
-    }
-    m_mapCompareDoubleThreads.clear();
+    destroyCompareThreads();
+    /* 销毁音量报警线程 */
+    destroyCalculateDBThreads();
+    /* 移除噪音检测线程 */
+    removeNoiseDetectThreads();
+
     /* 移除使用到的录音通道 */
     for(auto& it : m_threadInfo.compareItemInfo.mapRoad)
     {
@@ -225,6 +298,40 @@ void CompareItemThread::clearData()
     }
 }
 
+/* 定时器槽函数 */
+void CompareItemThread::do_timeout()
+{
+    // SPDLOG_LOGGER_WARN(m_logger, "{} 定时器触发，开始执行定时任务", m_logBase);
+    if(m_pFromMQTT == nullptr)
+    {
+        initMQTT();
+    }
+    timerTask();
+}
+
+/* 初始化MQTT */
+void CompareItemThread::initMQTT()
+{
+    if(m_pFromMQTT == nullptr)
+    {
+        m_pFromMQTT = new FromMQTT();
+        if(m_pFromMQTT == nullptr)
+        {
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 创建MQTT对象失败", m_logBase);
+            return; // 创建MQTT对象失败
+        }
+    }
+    /* 登陆MQTT */
+    m_pFromMQTT->setIPAndPort(GInfo.mqttIP(), GInfo.mqttPort());
+    m_pFromMQTT->connectToServer();
+
+    m_pubTopic = QString("%1/%2").arg(GInfo.mqttPubTopicDB()).arg(QString::number(m_threadInfo.compareItemInfo.nID));
+    SPDLOG_LOGGER_INFO(m_logger, "☆ {} 连接MQTT服务器: {}:{}, 音量包订阅主题: {}", m_logBase, GInfo.mqttIP().toStdString(), GInfo.mqttPort(), m_pubTopic.toStdString());
+}
+
+
+
+
 
 /* 创建两个对比线程，主通道是第一个通道，其他都需要和主通道进行对比 */
 bool CompareItemThread::createCompareThreads()
@@ -510,11 +617,17 @@ void CompareItemThread::processAlarmData()
     }
     
     /* 将报警列表写入到处理报警数据的线程中 */
+    AlarmManager.addAlarmInfo(m_listAlarm);
 }
 
 /* 发送数据 */
 void CompareItemThread::sendResultData()
 {
+    if(m_pFromMQTT == nullptr)
+    {
+        SPDLOG_LOGGER_WARN(m_logger, "{} MQTT连接未初始化，无法发送数据", m_logBase);
+        return;
+    }
     /* 生成json数据 */
     QByteArray jsonData;
     if(!generateMQTTJsonData(m_compareResult, jsonData))

Server/ThreadCalculate/CompareItemThread.h

@@ -2,12 +2,16 @@
 #define _COMPAREITEMTHREAD_H_
 
 #include <map>
-#include <qt5/QtCore/qchar.h>
+#include <QObject>
+#include <QEventLoop>
+#include <QTimer>
 
 #include "BaseCalculateThread.h"
 #include "CompareResult.h"
 #include "AlarmInfo.h"
 #include "FromMQTT.h"
+// #include "mqtt_client_cpp.hpp"
+
 
 class CalculateDBThread;
 class NoiseDetectThread;
@@ -22,22 +26,43 @@ class CompareDoubleThread;
             3、从这里开启各个比对线程，获取比对结果信息，并组合
             4、这里创建的线程包含：两两对比线程、音量检测线程，这两个都和对比项相关联
             5、噪音检测线程从线程管理器中获取的，这里不负责创建和销毁
+        其他说明：
+            1、这个线程由于需要使用qmqtt发布数据，需要使用到Qt的事件循环，所以多继承了 QObject，
+               线程的使用权会交给 Qt 的事件循环来管理，通过定时器定时调用 task() 函数
  
  */
-class CompareItemThread : public BaseCalculateThread
+class CompareItemThread : public QObject, public BaseCalculateThread
 {
+    Q_OBJECT
 public:
     CompareItemThread(CalculateThreadInfo_t& threadInfo);
     ~CompareItemThread() override;
 
+    /* 开启线程 */
+    void threadTask() override;
+
+    /* 停止线程 */
+    void stopThread() override;
+    void stopThreadBlock() override;
+
 protected:
-    /* 线程功能函数 */
+    /* 线程功能函数，未使用这个函数 */
     void task() override;
+    /* 功能函数，使用的是这个函数 */
+    void timerTask();
     /* 初始化数据 */
     bool initData() override;
     /* 清理数据 */
     void clearData() override;
 
+    /* 初始化MQTT */
+    void initMQTT();
+
+private slots:
+    /* 定时器槽函数 */
+    void do_timeout();
+    
+
 private:
     /* 创建两个对比线程，主通道是第一个通道，其他都需要和主通道进行对比 */
     bool createCompareThreads();
@@ -67,6 +92,10 @@ private:
     bool generateMQTTJsonData(const CompareResult_t& compareResult, QByteArray& jsonData);
 
 private:
+    /* 事件循环 */
+    QEventLoop m_eventLoop;
+    /* 定时器 */
+    QTimer* m_pTimer = nullptr;
     /* 发送音量包信息到mqtt中 */
     FromMQTT* m_pFromMQTT = nullptr;
     /* 发布的主题 */
@@ -84,7 +113,7 @@ private:
     /* 计算的数据结果 */
     CompareResult_t m_compareResult;
 
-    /* 存储报警信息 */
+    /* 存储报警信息，int是对比项中的通道编号 */
     std::map<int, AlarmInfo_t> m_mapAlarmSilence;           /* 静音报警信息 */
     std::map<int, AlarmInfo_t> m_mapAlarmOverload;          /* 过载报警信息 */
     std::map<int, AlarmInfo_t> m_mapAlarmPhase;             /* 反相报警信息 */

Server/ThreadCalculate/ConsistencyCompareThread.cpp

@@ -1,5 +1,6 @@
 #include "ConsistencyCompareThread.h"
 
+#include "GlobalVariable.h"
 #include "ThreadManager.h"
 
 #include "CreateWAVThread.h"
@@ -43,6 +44,55 @@ bool ConsistencyCompareThread::isRoadEqual(const SoundCardRoadInfo_t& roadInfo1,
     return false;
 }
 
+/* 初始化 */
+bool ConsistencyCompareThread::initConsistencyCompare()
+{
+    /* 初始化数据 */
+    if(!initData())
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "{} 初始化数据失败", m_logBase);
+        return false;
+    }
+
+    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 一致性对比功能(调用动态库)初始化完成  ", m_logBase);
+
+    return true;
+}
+
+/* 比对函数 */
+bool ConsistencyCompareThread::compareConsistencyData()
+{
+    /*--------------------------------------------------------------
+     * 更新最新数据
+     *--------------------------------------------------------------*/
+    m_pCreateWAVThread1->getLatestFileName(m_wavFilePath1);
+    m_pCreateWAVThread2->getLatestFileName(m_wavFilePath2);
+    /* 检查是否有新的数据 */
+    if(m_wavFilePath1 == m_prevWavFilePath1 || m_wavFilePath2 == m_prevWavFilePath2)
+    {
+        // SPDLOG_LOGGER_INFO(m_logger, "{} 检测到文件路径未变化", m_logBase);
+        return true;
+    }
+    /*--------------------------------------------------------------
+     * 开始比对计算，并保存计算结果
+     *--------------------------------------------------------------*/
+    if(!compareConsistency())
+    {
+        return false;
+    }
+    m_prevWavFilePath1 = m_wavFilePath1; // 更新上一个wav文件路径
+    m_prevWavFilePath2 = m_wavFilePath2; // 更新上一个wav文件路径
+
+    return true;
+}
+
+/* 清理数据 */
+void ConsistencyCompareThread::clearConsistencyCompareData()
+{
+    clearData();
+    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 一致性对比功能(调用动态库)清理完成  ", m_logBase);
+}
+
 
 /* 线程功能函数 */
 void ConsistencyCompareThread::task()
@@ -55,7 +105,7 @@ void ConsistencyCompareThread::task()
         return;
     }
 
-    SPDLOG_LOGGER_INFO(m_logger, "******************* {} 一致性对比线程(调用动态库)开始运行 ******************* ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 一致性对比线程(调用动态库)开始运行  ", m_logBase);
     
 
     while(m_isRunning)
@@ -87,7 +137,7 @@ void ConsistencyCompareThread::task()
         m_prevWavFilePath2 = m_wavFilePath2; // 更新上一个wav文件路径
     }
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 一致性对比线程(调用动态库)已结束运行 ******************* ", m_logBase);
+    SPDLOG_LOGGER_WARN(m_logger, " ★ {} 一致性对比线程(调用动态库)已结束运行  ", m_logBase);
     
 }
 
@@ -146,7 +196,14 @@ bool ConsistencyCompareThread::initData()
 /* 清理数据 */
 void ConsistencyCompareThread::clearData()
 {
-
+    m_isRunning = false;
+    m_pCreateWAVThread1 = nullptr;
+    m_pCreateWAVThread2 = nullptr;
+
+    /* 设置标志位 */
+    m_isRunning = false;
+    m_isStop.store(true);
+    m_threadInfo.threadState = EThreadState::State_Stopped;
 }
 
 /* 比对两个wav文件的一致性 */

Server/ThreadCalculate/ConsistencyCompareThread.h

@@ -13,9 +13,9 @@ class CreateWAVThread;
 
 
 /**
- * @brief 计算一致性的线程类
- *          1、一致性对比线程是调用动态库对比，没有对比参数，不和对比项有关联
- * 
+    @brief 计算一致性的线程类
+            1、一致性对比线程是调用动态库对比，没有对比参数，不和对比项有关联
+            2、这线程计算速度很快，8秒的对比文件20ms即可计算完成，可以将其合并到其他线程中
  */
 class ConsistencyCompareThread : public BaseCalculateThread
 {
@@ -29,6 +29,15 @@ public:
     /* 判断录音通道是否相等 */
     bool isRoadEqual(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2);
 
+    /* 这几个函数给外部线程调用，无需单独开启子线程了 */
+    /* 初始化 */
+    bool initConsistencyCompare();
+    /* 比对函数 */
+    bool compareConsistencyData();
+    /* 清理数据 */
+    void clearConsistencyCompareData();
+
+
 protected:
     /* 线程功能函数 */
     void task() override;

Server/ThreadCalculate/NoiseDetectThread.cpp

@@ -38,7 +38,7 @@ void NoiseDetectThread::task()
         return;
     }
 
-    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 噪音检测线程开始运行 ******************* ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 噪音检测线程开始运行  ", m_logBase);
     while(m_isRunning)
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
@@ -67,7 +67,7 @@ void NoiseDetectThread::task()
 
     }
     clearData(); // 清理数据
-    SPDLOG_LOGGER_INFO(m_logger, " ******************* {} 噪音检测线程结束 ******************* ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, " ★ {} 噪音检测线程结束  ", m_logBase);
 }
 
 /* 初始化数据 */

Server/ThreadManager/ThreadAlarmManager.cpp

@@ -0,0 +1,125 @@
+#include "ThreadAlarmManager.h"
+
+
+#include "GlobalInfo.h"
+#include "spdlog.h"
+#include <mutex>
+#include <thread>
+
+ThreadAlarmManager::~ThreadAlarmManager()
+{
+
+}
+
+
+
+/* 线程工作函数 */
+void ThreadAlarmManager::thread_task()
+{
+    /* 初始化信息 */
+    if(!initData())
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "报警信息处理线程初始化数据失败");
+        return;
+    }
+
+    /* 设置标志位 */
+    m_isRunning = true;
+    m_isStop = false;
+    m_threadState = EThreadState::State_Running;
+
+    SPDLOG_LOGGER_INFO(m_logger, "⚡ 报警信息处理线程开始运行");
+
+    /* 运行线程功能 */
+    task();
+
+    /* 清理数据 */
+    clearData();
+    m_threadState = EThreadState::State_Stopped;
+    m_isStop = true;
+    SPDLOG_LOGGER_WARN(m_logger, "⚡ 报警信息处理线程结束运行");
+}
+
+/* 停止线程 */
+void ThreadAlarmManager::thread_stop()
+{
+    m_isRunning = false; // 设置线程停止标志位
+}
+
+void ThreadAlarmManager::thread_stopBlock()
+{
+    thread_stop();
+    while(m_threadState != EThreadState::State_Stopped) // 等待线程停止
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+
+/* 添加报警内容 */
+void ThreadAlarmManager::addAlarmInfo(const AlarmInfo_t& alarmInfo)
+{
+    std::lock_guard<std::mutex> lock(m_mutexListAlarm);
+    m_listAlarm.push_back(alarmInfo);
+}
+
+void ThreadAlarmManager::addAlarmInfo(const std::list<AlarmInfo_t>& listAlarm)
+{
+    std::lock_guard<std::mutex> lock(m_mutexListAlarm);
+    m_listAlarm.insert(m_listAlarm.end(), listAlarm.begin(), listAlarm.end());
+}
+
+
+/* 线程工作函数 */
+void ThreadAlarmManager::task()
+{
+    while(m_isRunning.load())
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 每100毫秒执行一次
+
+        /* 检查列表是否有报警信息 */
+        {
+            std::lock_guard<std::mutex> lock(m_mutexListAlarm);
+            if(m_listAlarm.empty())
+            {
+                continue; // 如果没有报警信息，继续循环
+            }
+
+
+
+        }
+
+    }
+}
+
+/* 初始化数据 */
+bool ThreadAlarmManager::initData()
+{
+    if(m_logger == nullptr)
+    {
+        m_logger = spdlog::get("Alarm");
+        if(m_logger == nullptr)
+        {
+            fmt::print("Alarm is nullptr");
+            return false; // 日志记录器获取失败
+        }
+    }
+
+    /* 登陆WebAPI */
+    if(!m_fromWebAPI.initWebApi(GInfo.webAPIUrl(), GInfo.webAPIID(), GInfo.appType()))
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "报警信息处理线程登录WebAPI失败");
+        return false;
+    }
+    SPDLOG_LOGGER_INFO(m_logger, "报警信息处理线程登录WebAPI成功");
+
+
+    return true;
+}
+
+/* 清理数据 */
+void ThreadAlarmManager::clearData()
+{
+
+}
+

Server/ThreadManager/ThreadAlarmManager.h

@@ -0,0 +1,92 @@
+#ifndef __THREADALARMMANAGER_H__
+#define __THREADALARMMANAGER_H__
+
+/**
+ * @file ThreadAlarmManager.h
+ * @author your name (you@domain.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-07-19
+ * 
+ * @copyright Copyright (c) 2025
+ *
+ * 处理报警信息 
+ */
+
+ #include "FromWebAPI.h"
+#include "AlarmInfo.h"
+#include "GlobalVariable.h"
+#include "spdlog/spdlog.h"
+
+#include <list>
+#include <atomic>
+#include <memory>
+#include <mutex>
+
+/**
+ * @brief 处理报警信息，所有的报警信息都由这个线程写入数据库
+ * 
+ */
+
+
+
+#define AlarmManager ThreadAlarmManager::instance()
+
+class ThreadAlarmManager
+{
+    
+    ThreadAlarmManager() = default;
+    ThreadAlarmManager(const ThreadAlarmManager&) = delete;
+    ThreadAlarmManager& operator=(const ThreadAlarmManager&) = delete;
+public:
+    ~ThreadAlarmManager();
+    static ThreadAlarmManager& instance()
+    {
+        static ThreadAlarmManager instance;
+        return instance;
+    }
+
+    /* 线程工作函数 */
+    void thread_task();
+    /* 停止线程 */
+    void thread_stop();
+    void thread_stopBlock();
+    /* 获取线程状态 */
+    EThreadState getThreadState() const { return m_threadState; }
+
+
+    /* 添加报警内容 */
+    void addAlarmInfo(const AlarmInfo_t& alarmInfo);
+    void addAlarmInfo(const std::list<AlarmInfo_t>& listAlarm);
+    
+
+private:
+    /* 线程工作函数 */
+    void task();
+    /* 初始化数据 */
+    bool initData();
+    /* 清理数据 */
+    void clearData();
+
+
+private:
+    std::shared_ptr<spdlog::logger> m_logger = nullptr;
+    /* 线程基础信息 */
+    std::atomic_bool m_isRunning = false;           /* 线程运行标志位 */
+    std::atomic_bool m_isStop = false;              /* 线程停止标志位 */
+    EThreadState m_threadState = EThreadState::State_None; /* 线程状态 */
+
+    FromWebAPI m_fromWebAPI;
+
+    /* 存储报警信息 */
+    std::mutex m_mutexListAlarm;                    /* 报警信息列表的互斥锁 */
+    std::list<AlarmInfo_t> m_listAlarm;                 /* 报警信息列表 */
+    
+
+    
+
+};
+
+
+
+#endif // __THREADALARMMANAGER_H__

Server/ThreadManager/ThreadCompareItemManager.cpp

@@ -4,16 +4,30 @@
 #include "SystemConfig.h"
 #include "CompareItemThread.h"
 #include "ThreadPool.h"
+#include "OneThread.h"
 
 
-ThreadCompareItemManager::ThreadCompareItemManager()
+/* 给对比项套一层壳，这个函数就是新的线程，在里面new出新的对比项实例，防止Qt报线程归属权错误
+   在函数中将对比项实例插入到线程管理器中 */
+void ThreadCompareItemManager::thread_compareItem(CalculateThreadInfo_t threadInfo)
 {
-    m_logger = spdlog::get("CompareItemManager");
-    if(m_logger == nullptr)
+    auto pThread = new CompareItemThread(threadInfo);
+    if(pThread == nullptr)
     {
-        fmt::print("ThreadCompareItemManager: CompareItemManager Logger not found.\n");
+        SPDLOG_ERROR("ThreadCompareItemManager: 创建对比项线程失败");
         return;
     }
+    CompareItemManager.addCompareItemThread(pThread);
+    /* 启动线程，就会一直阻塞在这里了 */
+    pThread->threadTask();
+}
+
+
+
+
+ThreadCompareItemManager::ThreadCompareItemManager()
+{
+    
     
     
 }
@@ -26,6 +40,13 @@ ThreadCompareItemManager::~ThreadCompareItemManager()
 /* 线程函数 */
 void ThreadCompareItemManager::thread_CompareItemManager()
 {
+    m_logger = spdlog::get("CompareItemManager");
+    if(m_logger == nullptr)
+    {
+        fmt::print("ThreadCompareItemManager: CompareItemManager Logger not found.\n");
+        return;
+    }
+    
     /* 初始化webapi */
     m_webAPIUrl = GInfo.webAPIUrl();
     m_webAPIID = GInfo.webAPIID();
@@ -79,6 +100,27 @@ void ThreadCompareItemManager::thread_CompareItemManager()
 
 }
 
+/* 添加对比项实例 */
+void ThreadCompareItemManager::addCompareItemThread(CompareItemThread* pThread)
+{
+    if(pThread == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "添加对比项线程失败，线程指针为空");
+        return;
+    }
+    
+    std::lock_guard<std::mutex> lock(m_mutexCompareItemThreads);
+    int compareItemID = pThread->getThreadInfo().compareItemInfo.nID;
+    if(m_mapThreads.contains(compareItemID))
+    {
+        SPDLOG_LOGGER_WARN(m_logger, "对比项线程已存在，ID: {}", compareItemID);
+        return; // 对比项线程已存在
+    }
+    
+    m_mapThreads.insert(compareItemID, pThread);
+    SPDLOG_LOGGER_INFO(m_logger, "添加对比项线程成功，ID: {}", compareItemID);
+}
+
 /* 更新基础设置信息，如数据库设置，噪音参数等 */
 bool ThreadCompareItemManager::updateBaseSettings()
 {
@@ -312,19 +354,21 @@ bool ThreadCompareItemManager::createNewCompareItemThreads(const QList<CompareIt
         threadInfo.threadType = EThreadType::Type_CompareItem;
         threadInfo.threadState = EThreadState::State_Inited;
 
+        CPPTP.add_task(&ThreadCompareItemManager::thread_compareItem, threadInfo);
+
         /* 创建线程对象 */
-        BaseCalculateThread* pThread = new CompareItemThread(threadInfo);
-        if(pThread == nullptr)
-        {
-            SPDLOG_LOGGER_ERROR(m_logger, "创建对比项线程 {} 失败", it.strName.toStdString());
-            return false;
-        }
+        // CompareItemThread* pThread = new CompareItemThread(threadInfo);
+        // if(pThread == nullptr)
+        // {
+        //     SPDLOG_LOGGER_ERROR(m_logger, "创建对比项线程 {} 失败", it.strName.toStdString());
+        //     return false;
+        // }
         
         /* 启动线程 */
-        CPPTP.add_task(&CompareItemThread::threadTask, pThread);
+        // CPPTP.add_task(&CompareItemThread::threadTask, pThread);
         
         /* 添加到线程列表中 */
-        m_mapThreads.insert(it.nID, pThread);
+        // m_mapThreads.insert(it.nID, pThread);
     }
 
     return true;

Server/ThreadManager/ThreadCompareItemManager.h

@@ -4,18 +4,34 @@
 
 #include "spdlog/spdlog.h"
 #include "FromWebAPI.h"
-#include "BaseCalculateThread.h"
+#include "CompareItemThread.h"
 
 
+
+
+
+#define CompareItemManager ThreadCompareItemManager::instance()
 class ThreadCompareItemManager
 {
-
-public:
     ThreadCompareItemManager();
+    ThreadCompareItemManager(const ThreadCompareItemManager&) = delete;
+    ThreadCompareItemManager& operator=(const ThreadCompareItemManager&) = delete;
+public:
     ~ThreadCompareItemManager();
+    static ThreadCompareItemManager& instance()
+    {
+        static ThreadCompareItemManager instance;
+        return instance;
+    }
 
     /* 线程函数 */
     void thread_CompareItemManager();
+    /* 添加对比项实例 */
+    void addCompareItemThread(CompareItemThread* pThread);
+
+    /*  给对比项套一层壳，这个函数就是新的线程，在里面new出新的对比项实例，防止Qt报线程归属权错误
+        在函数中将对比项实例插入到线程管理器中 */
+    static void thread_compareItem(CalculateThreadInfo_t threadInfo);
 
 private:
     /* 更新基础设置信息，如数据库设置，噪音参数等 */
@@ -40,8 +56,9 @@ private:
     QString m_appType;                      /* 应用类型 */
 
 
-    QList<CompareItemInfo_t> m_listNewItems;   /* 对比项列表 */
-    QMap<int, BaseCalculateThread*> m_mapThreads; /* 对比项线程列表，key是对比项ID，value是对应的线程指针 */
+    std::mutex m_mutexCompareItemThreads;       /* 对比项线程的互斥锁 */
+    QList<CompareItemInfo_t> m_listNewItems;    /* 对比项列表 */
+    QMap<int, CompareItemThread*> m_mapThreads; /* 对比项线程列表，key是对比项ID，value是对应的线程指针 */
 
 };
 

Server/ThreadManager/ThreadManager.cpp

@@ -121,17 +121,18 @@ bool ThreadManager::createRecordThread(const SoundCardRoadInfo_t& roadInfo, int
     
     /* 创建发送RTP数据的线程 */
     threadInfo.threadType = EThreadType::Type_RtpSend;
-    RTPOneRoadThread* pRtpSendThread = new RTPOneRoadThread(threadInfo);
-    if(pRtpSendThread == nullptr) 
-    {
-        SPDLOG_LOGGER_ERROR(m_logger, "{}:{} 创建发送RTP数据线程失败", roadInfo.strSoundCardName.toStdString(), roadInfo.roadInfo.nRoadNum);
-        // return false; // 创建失败
-    }else 
-    {
-        CPPTP.add_task(&RTPOneRoadThread::threadTask, pRtpSendThread);
-        std::lock_guard<std::mutex> lock(m_mutexRtpSendThreads);
-        m_rtpSendThreads.push_back(pRtpSendThread);
-    }
+    CPPTP.add_task(&ThreadManager::thread_RTPSend, threadInfo);
+
+    // RTPOneRoadThread* pRtpSendThread = new RTPOneRoadThread(threadInfo);
+    // if(pRtpSendThread == nullptr) 
+    // {
+    //     SPDLOG_LOGGER_ERROR(m_logger, "{}:{} 创建发送RTP数据线程失败", roadInfo.strSoundCardName.toStdString(), roadInfo.roadInfo.nRoadNum);
+    // }else 
+    // {
+    //     CPPTP.add_task(&RTPOneRoadThread::threadTask, pRtpSendThread);
+    //     std::lock_guard<std::mutex> lock(m_mutexRtpSendThreads);
+    //     m_rtpSendThreads.push_back(pRtpSendThread);
+    // }
 
     /* 创建录音线程 */
     threadInfo.threadType = EThreadType::Type_RecordSrc;
@@ -811,6 +812,8 @@ bool ThreadManager::removeNoiseDetectThread(const SoundCardRoadInfo_t& roadInfo,
     return true;
 }
 
+
+
 // /* 获取音量报警线程 */
 // CalculateDBPhaseThread* ThreadManager::getCalculateDBPhaseThread(const SoundCardRoadInfo_t& roadInfo)
 // {
@@ -878,3 +881,18 @@ bool ThreadManager::removeNoiseDetectThread(const SoundCardRoadInfo_t& roadInfo,
 //     return true;
 // }
 
+/* RTP线程函数，套一层壳 */
+void ThreadManager::thread_RTPSend(RecordThreadInfo_t& threadInfo)
+{
+    RTPOneRoadThread* pRtpSendThread = new RTPOneRoadThread(threadInfo);
+    if(pRtpSendThread == nullptr)
+    {
+        SPDLOG_ERROR("{}:{} 创建RTP发送线程失败", threadInfo.cardRoadInfo.strSoundCardName.toStdString(), threadInfo.cardRoadInfo.roadInfo.nRoadNum);
+        return;
+    }
+    /* 先加入队列，再开启线程 */
+    std::lock_guard<std::mutex> lock(ThreadMan.m_mutexRtpSendThreads);
+    ThreadMan.m_rtpSendThreads.push_back(pRtpSendThread);
+    // pRtpSendThread->threadTask();
+}
+

Server/ThreadManager/ThreadManager.h

@@ -97,6 +97,12 @@ public:
     // /* 去掉音量报警线程，线程使用的计数减一，计数为0则销毁该线程 */
     // bool removeCalculateDBPhaseThread(SoundCardRoadInfo_t& roadInfo);
 
+private:
+    /* RTP线程函数，套一层壳 */
+    static void thread_RTPSend(RecordThreadInfo_t& threadInfo);
+    
+    
+
 private:
     /* 记录每个录音通道的引用计数 */
     std::mutex m_mutexRecordThreadRefCount;

Server/ThreadRecord/AssignSrcDataThread.cpp

@@ -4,6 +4,7 @@
 #include "AudioData.h"
 #include "GlobalInfo.h"
 #include "RecordThread.h"
+#include "spdlog.h"
 
 #include <QReadWriteLock>
 #include <QWriteLocker>
@@ -78,7 +79,7 @@ bool AssignSrcDataThread::setSrcData(const char* srcData, int32_t dataSize, QDat
 
 void AssignSrcDataThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, "------------- {} 开始分派数据线程 -------------", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, "➢ {} 开始分派数据线程 ", m_logBase);
     /* 初始化数据 */
     if(!initData())
     {
@@ -133,7 +134,7 @@ void AssignSrcDataThread::task()
     }
     /* 清理数据 */
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, "------------- {} 结束分派数据线程 -------------", m_logBase);
+    SPDLOG_LOGGER_WARN(m_logger, "➢ {} 结束分派数据线程", m_logBase);
 }
 
 

Server/ThreadRecord/CreateDBThread.cpp

@@ -184,7 +184,7 @@ bool CreateDBThread::getLatestResult(RingQueueManualMutex<OneSecondData*>& resul
 /* 计算音量和反相的线程函数 */
 void CreateDBThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, " ------------- {} 开始计算音量线程 ------------- ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, "➢ {} 开始计算音量线程", m_logBase);
     /* 初始化一些数据 */
     if(!initData())
     {
@@ -231,7 +231,7 @@ void CreateDBThread::task()
     }
     /* 清理数据 */
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, " ------------- {} 计算音量线程结束 ------------- ", m_logBase);
+    SPDLOG_LOGGER_WARN(m_logger, "➢ {} 计算音量线程结束 ", m_logBase);
     
 }
 

Server/ThreadRecord/CreateLongFileThread.cpp

@@ -76,7 +76,7 @@ bool CreateLongFileThread::setData(const AudioSrcData& srcData)
  */
 void CreateLongFileThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, " ------------- {} 开启记录文件线程 ------------- ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, "➢ {} 开启记录文件线程 ", m_logBase);
     /* 计算一小时的文件大小 */
 
     while(m_isRunning)
@@ -195,6 +195,7 @@ void CreateLongFileThread::task()
         }
         
     }
+    SPDLOG_LOGGER_WARN(m_logger, "➢ {} 记录长文件线程结束运行", m_logBase);
 }
 
 

Server/ThreadRecord/CreateWAVThread.cpp

@@ -117,7 +117,7 @@ bool CreateWAVThread::getLatestLeftRightData(AudioLeftRightData& leftRightData)
 /* 生成WAV文件的线程函数 */
 void CreateWAVThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, "------------- {} 开启生成WAV文件线程 -------------", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, "➢ {} 开启生成WAV文件线程 ", m_logBase);
     /* 初始化数据 */
     if(!initData())
     {
@@ -174,7 +174,7 @@ void CreateWAVThread::task()
     }
     /* 清理数据 */
     clearData();
-    SPDLOG_LOGGER_INFO(m_logger, "------------- {} 生成WAV文件线程结束 -------------", m_logBase);
+    SPDLOG_LOGGER_WARN(m_logger, "➢ {} 生成WAV文件线程结束", m_logBase);
     m_isRunning = false;
 }
 

Server/ThreadRecord/RecordThread.cpp

@@ -3,6 +3,7 @@
 #include "GlobalInfo.h"
 #include "ThreadManager.h"
 #include "AssignSrcDataThread.h"
+#include "spdlog.h"
 #include <cstring>
 
 
@@ -43,7 +44,7 @@ void RecordThread::setAssignSrcDataThread(AssignSrcDataThread* pThread)
 /* 录制功能线程函数 */
 void RecordThread::task()
 {
-    SPDLOG_LOGGER_INFO(m_logger, " --------------------- {} 开始录音线程 --------------------- ", m_logBase);
+    SPDLOG_LOGGER_INFO(m_logger, "➢ {} 开始录音线程 ", m_logBase);
 
     /* 先初始化数据 */
     if(!initData())
@@ -94,7 +95,7 @@ void RecordThread::task()
         // SPDLOG_LOGGER_DEBUG(m_logger, "{} 录音数据已分派给AssignSrcDataThread线程", m_logBase);
     }
 
-    SPDLOG_LOGGER_INFO(m_logger, " --------------------- {} 结束录音 --------------------- ", m_logBase);
+    SPDLOG_LOGGER_WARN(m_logger, "➢ {} 结束录音", m_logBase);
     m_isRunning = false;
 }
 

Server/common/LHLog/LHLogInit.cpp

@@ -84,6 +84,8 @@ void initLog(QString ModuleName, CLHQLogApi& lhQLog)
         auto logger_rtpserver = std::make_shared<spdlog::logger>("RTPServer",begin(sinks),end(sinks));
         /* 创建一个对比项管理线程的logger */
         auto logger_compareitem = std::make_shared<spdlog::logger>("CompareItemManager",begin(sinks),end(sinks));
+        /* 创建一个处理日志的线程logger */
+        auto logger_threadAlarm = std::make_shared<spdlog::logger>("Alarm",begin(sinks),end(sinks));
 
 
         /* 注册到注册表 */
@@ -94,6 +96,7 @@ void initLog(QString ModuleName, CLHQLogApi& lhQLog)
         spdlog::register_logger(logger_rtpserver);
         spdlog::register_logger(logger_compareitem);
         spdlog::register_logger(logger_caculate);
+        spdlog::register_logger(logger_threadAlarm);
 
 
         /* 设置spdlog输出级别，默认的估计不输出debug这个级别

Server/main.cpp

@@ -45,7 +45,7 @@ int main(int argc, char* argv[])
     }
     SPDLOG_LOGGER_DEBUG(logger, "☆ 初始化噪音检测服务");
     /* 初始化噪音检测功能 */
-    signalstats_wrapper::initialize();
+    // signalstats_wrapper::initialize();
     SPDLOG_LOGGER_DEBUG(logger, "★ 噪音检测服务初始化完成");
 
     ACAServer acas;
@@ -73,7 +73,7 @@ int main(int argc, char* argv[])
     int result = a.exec();
 
     /* 释放资源 */
-    signalstats_wrapper::finalize();
+    // signalstats_wrapper::finalize();
     SPDLOG_LOGGER_INFO(logger, "ACAServer 结束运行");
 
     return result;

SettingLibrary/common/LHLog/LHLogInit.cpp

@@ -56,7 +56,7 @@ void initLog(QString ModuleName, CLHQLogApi& lhQLog)
 #elif defined(C_RELEASE)
         sink_consolse->set_pattern("%^[%Y-%m-%d %H:%M:%S:%e] [%l] [%n] %v%$");
         // sink_file->set_pattern("[%Y-%m-%d %H:%M:%S] [%^%n%$] [%^%l%$] %s %#: %v");
-        sink_custom->set_pattern("%v");
+        g_loggerFile->set_pattern("%v");
         sink_default->set_pattern("%^[%Y-%m-%d %H:%M:%S:%e] [%l] %v%$");
 #endif
 

common/GlobalInfo/GlobalVariable.h

@@ -223,77 +223,6 @@ struct NoDetectPlanApply_t
  * 线程信息相关枚举和结构体
  * =========================================================================================*/
 
-// enum class ERoadID
-// {
-//     RoadID_None = 0,      /* 无通道 */
-//     RoadID_1 = 1,         /* 通道1 */
-//     RoadID_2,             /* 通道2 */
-//     RoadID_3,             /* 通道3 */
-//     RoadID_4,             /* 通道4 */
-//     RoadID_5,             /* 通道5 */
-//     RoadID_6,             /* 通道6 */
-//     RoadID_7,             /* 通道7 */
-//     RoadID_8,             /* 通道8 */
-//     RoadID_9,             /* 通道9 */
-//     RoadID_10,            /* 通道10 */
-//     RoadID_11,            /* 通道11 */
-//     RoadID_12,            /* 通道12 */
-//     RoadID_13,            /* 通道13 */
-//     RoadID_14,            /* 通道14 */
-//     RoadID_15,            /* 通道15 */
-//     RoadID_16,            /* 通道16 */
-//     RoadID_17,            /* 通道17 */
-//     RoadID_18,            /* 通道18 */
-//     RoadID_19,            /* 通道19 */
-//     RoadID_20,            /* 通道20 */
-//     RoadID_21,            /* 通道21 */
-//     RoadID_22,            /* 通道22 */
-//     RoadID_23,            /* 通道23 */
-//     RoadID_24,            /* 通道24 */
-//     RoadID_25,            /* 通道25 */
-//     RoadID_26,            /* 通道26 */
-//     RoadID_27,            /* 通道27 */
-//     RoadID_28,            /* 通道28 */
-//     RoadID_29,            /* 通道29 */
-//     RoadID_30,            /* 通道30 */
-//     RoadID_31,            /* 通道31 */
-//     RoadID_32,            /* 通道32 */
-//     RoadID_33,            /* 通道33 */
-//     RoadID_34,            /* 通道34 */
-//     RoadID_35,            /* 通道35 */
-//     RoadID_36,            /* 通道36 */
-//     RoadID_37,            /* 通道37 */
-//     RoadID_38,            /* 通道38 */
-//     RoadID_39,            /* 通道39 */
-//     RoadID_40,            /* 通道40 */
-//     RoadID_41,            /* 通道41 */
-//     RoadID_42,            /* 通道42 */
-//     RoadID_43,            /* 通道43 */
-//     RoadID_44,            /* 通道44 */
-//     RoadID_45,            /* 通道45 */
-//     RoadID_46,            /* 通道46 */
-//     RoadID_47,            /* 通道47 */
-//     RoadID_48,            /* 通道48 */
-//     RoadID_49,            /* 通道49 */
-//     RoadID_50,            /* 通道50 */
-//     RoadID_51,            /* 通道51 */
-//     RoadID_52,            /* 通道52 */
-//     RoadID_53,            /* 通道53 */
-//     RoadID_54,            /* 通道54 */
-//     RoadID_55,            /* 通道55 */
-//     RoadID_56,            /* 通道56 */
-//     RoadID_57,            /* 通道57 */
-//     RoadID_58,            /* 通道58 */
-//     RoadID_59,            /* 通道59 */
-//     RoadID_60,            /* 通道60 */
-//     RoadID_61,            /* 通道61 */
-//     RoadID_62,            /* 通道62 */
-//     RoadID_63,            /* 通道63 */
-//     RoadID_64,            /* 通道64 */
-//     RoadID_MAX = RoadID_64, /* 最大通道数 */
-// };
-
-
 
  /**
  * @brief 线程状态枚举
@@ -327,30 +256,6 @@ enum class EThreadType
     Type_CompareItem,           /* 对比项线程 */
 };
 
-/**
- * @brief 录音通道信息
- * 
- */
-// struct RoadNumberInfo_t
-// {
-//     ERoadID roadID;                             /* 录音通道编号 */
-//     std::string strRoadName;                    /* 录音通道名称 */
-//     int roadNum;                                /* 录音通道编号，在对比项里的编号 */
-
-//     RoadNumberInfo_t() = default;
-//     RoadNumberInfo_t(const RoadNumberInfo_t& info)
-//         : roadID(info.roadID), strRoadName(info.strRoadName), roadNum(info.roadNum) {}
-//     RoadNumberInfo_t& operator=(const RoadNumberInfo_t& info)
-//     {
-//         if (this == &info) return *this; // 防止自赋值
-//         roadID = info.roadID;
-//         strRoadName = info.strRoadName;
-//         roadNum = info.roadNum;
-//         return *this;
-//     }
-// };
-
-
 
 /**
  * @brief 录音线程信息结构体

show3/main.cpp

@@ -11,7 +11,7 @@ void test2();
 
 int main() {
     // 初始化Python解释器
-    signalstats_wrapper::initialize();
+    // signalstats_wrapper::initialize();
     
     // try {
     //     // 创建测试音频信号 (C++版本)
@@ -64,6 +64,10 @@ int main() {
     // }
     // test1();
 
+
+    // 初始化Python解释器
+    // signalstats_wrapper::initialize();
+
     CPPTP.add_task(test1);
     // std::this_thread::sleep_for(std::chrono::seconds(1));
     CPPTP.add_task(test2);
@@ -73,14 +77,14 @@ int main() {
 
     std::this_thread::sleep_for(std::chrono::seconds(10)); // 等待任务执行
 
-    signalstats_wrapper::finalize();
+    // signalstats_wrapper::finalize();
     
     return 0;
 }
 
 void test1()
 {
-    // signalstats_wrapper::initialize();
+    signalstats_wrapper::initialize();
     try {
         // 创建测试音频信号 (C++版本)
         const int sample_rate = 44100;
@@ -131,12 +135,12 @@ void test1()
         return;
     }
 
-    // signalstats_wrapper::finalize();
+    signalstats_wrapper::finalize();
 }
 
 void test2()
 {
-    // signalstats_wrapper::initialize();
+    signalstats_wrapper::initialize();
     try {
         // 创建测试音频信号 (C++版本)
         const int sample_rate = 44100;
@@ -187,5 +191,5 @@ void test2()
         return;
     }
 
-    // signalstats_wrapper::finalize();
+    signalstats_wrapper::finalize();
 }