V0.5

1、修改了音量包的内容，完成了所有音量包内容的获取
2、将噪音检测的基础配置应用于了服务中

Server/ThreadCalculate/CalculateDBThread.cpp

@@ -70,50 +70,22 @@ bool CalculateDBThread::getlastVolumeInfo(OneRoadVolume_t& volumeInfo)
     return true;
 }
 
-/* 获取报警数据 */
-// AlarmInfo_t CalculateDBThread::getAlarm(EAlarmType alarmType)
-// {
-//     std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
-//     switch(alarmType)
-//     {
-//         case EAlarmType::EAT_Silent:
-//             {
-//                 if(m_alarmSilence.AlarmType != EAlarmType::EAT_None && m_alarmLastSilence.isAlarm == false)
-//                 {
-//                     /* 报警结束了，返回报警信息，并清空 */
-//                     AlarmInfo_t alarmInfo = m_alarmLastSilence;
-//                     m_alarmLastSilence = AlarmInfo_t(); // 清空报警信息
-//                     return alarmInfo;
-//                 }
-//                 return m_alarmSilence;
-//             }
-//         case EAlarmType::EAT_Overload:
-//             {
-//                 if(m_alarmOverload.AlarmType != EAlarmType::EAT_None && m_alarmLastOverload.isAlarm == false)
-//                 {
-//                     /* 报警结束了，返回报警信息，并清空 */
-//                     AlarmInfo_t alarmInfo = m_alarmLastOverload;
-//                     m_alarmLastOverload = AlarmInfo_t(); // 清空报警信息
-//                     return alarmInfo;
-//                 }
-//                 return m_alarmOverload;
-//             }
-//         case EAlarmType::EAT_Reversed:
-//             {
-//                 if(m_alarmPhase.AlarmType != EAlarmType::EAT_None && m_alarmLastPhase.isAlarm == false)
-//                 {
-//                     /* 报警结束了，返回报警信息，并清空 */
-//                     AlarmInfo_t alarmInfo = m_alarmLastPhase;
-//                     m_alarmLastPhase = AlarmInfo_t(); // 清空报警信息
-//                     return alarmInfo;
-//                 }
-//                 return m_alarmPhase;
-//             }
-//         default:
-//             SPDLOG_LOGGER_ERROR(m_logger, "{} 获取报警数据失败，未知报警类型: {}", m_logBase, static_cast<int>(alarmType));
-//             return m_alarmNull; // 返回一个空的报警信息
-//     }
-// }
+
+/* 获取最新的静音、过载等报警信息，不包含音量包信息 */
+bool CalculateDBThread::getAlarmInfo(OneRoadVolume_t& oneVolumeInfo)
+{
+    std::lock_guard<std::mutex> lock(m_mutexVolumeInfo);
+    oneVolumeInfo.isSilence = m_roadVolumeInfo.isSilence;
+    oneVolumeInfo.isOverload = m_roadVolumeInfo.isOverload;
+    oneVolumeInfo.isReversed = m_roadVolumeInfo.isReversed;
+    oneVolumeInfo.isNoise = false;                  // 没有噪音信息
+    oneVolumeInfo.isConsistency = false;            // 没有一致性信息
+    oneVolumeInfo.isNotConsistencyWarning = false;  // 没有不一致性警告信息
+
+    return true;
+}
+
+
 
 /* 线程功能函数 */
 void CalculateDBThread::task()

Server/ThreadCalculate/CalculateDBThread.h

@@ -37,8 +37,9 @@ public:
     OneRoadVolume_t getVolumeInfo();
     /* 获取最新音量值计算的结果 */
     bool getlastVolumeInfo(OneRoadVolume_t& volumeInfo);
-    /* 获取最新的结果，实时结果 */
-    // AlarmInfo_t getAlarm(EAlarmType alarmType);
+    /* 获取最新的静音、过载等报警信息，不包含音量包信息 */
+    bool getAlarmInfo(OneRoadVolume_t& oneVolumeInfo);
+    
 
     /* 设置是否在检测时段内 */
     void setSilenceInDetectPeriod(bool isInPeriod) { m_isSilenceInDetectPeriod = isInPeriod; }

Server/ThreadCalculate/CompareItemThread.cpp

@@ -1,7 +1,9 @@
 #include "CompareItemThread.h"
 
+#include "ChannelParam.h"
 #include "FromMQTT.h"
 #include "GlobalInfo.h"
+#include "SystemConfig.h"
 #include "ThreadManager.h"
 #include "CalculateDBThread.h"
 #include "NoiseDetectThread.h"
@@ -60,7 +62,9 @@ void CompareItemThread::threadTask()
     // SPDLOG_LOGGER_WARN(m_logger, "{} 创建定时器成功，开启定时器", m_logBase);
     m_pTimer->setTimerType(Qt::PreciseTimer);
     m_pTimer->setSingleShot(false); // 设置为非单次定时器
-    m_pTimer->setInterval(30);
+    /* 计算定时时间，根据每次需要发送的音量包大小设置定时时间，-3是让定时器提前3ms溢出 */
+    int interval = (1000 / VOLUME_INFO_NUM) * m_sendVolumeCount - 3;
+    m_pTimer->setInterval(interval);
     m_eventLoop.connect(m_pTimer, &QTimer::timeout, this, &CompareItemThread::do_timeout, Qt::DirectConnection);
     m_pTimer->start();
     
@@ -195,6 +199,10 @@ void CompareItemThread::timerTask()
 /* 初始化数据 */
 bool CompareItemThread::initData()
 {
+    /* 获取参数 */
+    m_noiseDetectConfig = SysConfig.getNoiseDetectBaseConfig();
+
+
     /* 创建录音通道线程 */
     for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
     {
@@ -210,8 +218,12 @@ bool CompareItemThread::initData()
     createCompareThreads();
 
     /* 创建计算噪音的线程 */
-    destroyNoiseDetectThreads();
-    createNoiseDetectThreads();
+    if(m_noiseDetectConfig.isEnableNoiseDetect)
+    {
+        destroyNoiseDetectThreads();
+        createNoiseDetectThreads();
+    }
+    
 
     /* 获取创建实时音量包的线程 */
     if(!getCreateDBThread())
@@ -229,6 +241,8 @@ bool CompareItemThread::initData()
     //     }
     // }
 
+    
+
     /* 初始化存储结果的数据结构 */
     m_compareResult = CompareResult_t();
     m_compareResult.compareItemID = m_threadInfo.compareItemInfo.nID;
@@ -255,6 +269,8 @@ bool CompareItemThread::initData()
     QDateTime currentTime = QDateTime::currentDateTime();
     m_lastDetectPeriodUpdateTime = currentTime;
 
+    m_nowTimePoint = std::chrono::steady_clock::now();
+
     return true;
 }
 
@@ -288,7 +304,7 @@ void CompareItemThread::clearData()
 /* 定时器槽函数 */
 void CompareItemThread::do_timeout()
 {
-    std::chrono::steady_clock::time_point startTime = std::chrono::steady_clock::now();
+    // std::chrono::steady_clock::time_point startTime = std::chrono::steady_clock::now();
     // SPDLOG_LOGGER_WARN(m_logger, "{} 定时器触发，开始执行定时任务", m_logBase);
     if(m_pFromMQTT == nullptr)
     {
@@ -297,8 +313,9 @@ void CompareItemThread::do_timeout()
     timerTask();
 
     std::chrono::steady_clock::time_point endTime = std::chrono::steady_clock::now();
-    std::chrono::milliseconds duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
+    std::chrono::milliseconds duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - m_nowTimePoint);
     SPDLOG_LOGGER_DEBUG(m_logger, "{} 定时器任务完成，耗时: {} ms", m_logBase, duration.count());
+    m_nowTimePoint = endTime; // 更新当前时间点
 }
 
 /* 初始化MQTT */
@@ -467,6 +484,15 @@ void CompareItemThread::createNoiseDetectThreads()
 {
     for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
     {
+        if(road.nCompareRoadNum == 1)
+        {
+            /* 是主通道，判断主通道是否开启了噪音检测计划 */
+            if(!m_noiseDetectConfig.isEnableMainRoadDetect)
+            {
+                SPDLOG_LOGGER_INFO(m_logger, "{} 主通道 {} 不开启噪音检测", m_logBase, road.strCompareRoadName.toStdString());
+                continue;
+            }
+        }
         CalculateThreadInfo_t threadInfo;
         threadInfo.compareItemInfo.mapRoad.clear(); // 清空通道信息
         threadInfo.compareItemInfo.mapRoad.insert(road.nCompareRoadNum, road); // 添加当前通道
@@ -556,6 +582,7 @@ void CompareItemThread::destroyNoiseDetectThreads()
  */
 bool CompareItemThread::updateResultData()
 {
+    // std::chrono::steady_clock::time_point startTime = std::chrono::steady_clock::now();
     /* -------------------------------------------------------------------------------------
      * 先从音量计算数据中获取音量包信息，循环等待获取完成
      * ------------------------------------------------------------------------------------- */
@@ -570,30 +597,26 @@ bool CompareItemThread::updateResultData()
                 /* 已经更新过了 */
                 continue;
             }
-            // CalculateDBThread* pThread = m_mapCalculateDBThreads[pair.first];
-            // if(pThread == nullptr)
-            // {
-            //     SPDLOG_LOGGER_ERROR(m_logger, "{} 音量计算线程失效", m_logBase);
-            //     continue;
-            // }
-            // /* 获取最新的音量包数据 */
-            // if(!pThread->getlastVolumeInfo(m_compareResult.mapRoadVolumes[pair.first]))
-            // {
-            //     continue; // 没有获取到最新数据，继续等待
-            // }
+
             CreateDBThread* pThread = m_mapCreateDBThreads[pair.first];
+            // CreateDBThread* pThread = m_mapCreateDBThreads[2];
             if(pThread == nullptr)
             {
                 SPDLOG_LOGGER_WARN(m_logger, "{} 获取音量创建线程失败，通道: {}", m_logBase, pair.first);
                 continue;
             }
             /* 获取最新的音量包数据 */
-            if(!pThread->getLatestRealTimeResult(m_mapRealTimeData[pair.first], 3))
+            if(!pThread->getLatestRealTimeResult(m_mapRealTimeData[pair.first], m_sendVolumeCount))
             {
                 // SPDLOG_LOGGER_WARN(m_logger, "{} 获取最新音量值失败，通道: {}", m_logBase, pair.first);
                 continue;
             }
 
+            // std::chrono::steady_clock::time_point oneTime = std::chrono::steady_clock::now();
+            // std::chrono::milliseconds oneDuration = std::chrono::duration_cast<std::chrono::milliseconds>(oneTime - startTime);
+            // SPDLOG_LOGGER_DEBUG(m_logger, "{} 获取音量包数据成功，通道: {}, 耗时: {} ms", m_logBase, pair.first, oneDuration.count());
+            
+
             pair.second = true;
         }
         /* 判断是否全部更新，如果没有则返回，等待下次再次获取 */
@@ -609,9 +632,33 @@ bool CompareItemThread::updateResultData()
         }
     }
 
+    // std::chrono::steady_clock::time_point updateTime = std::chrono::steady_clock::now();
+    // std::chrono::milliseconds updateDuration = std::chrono::duration_cast<std::chrono::milliseconds>(updateTime - startTime);
+    // SPDLOG_LOGGER_DEBUG(m_logger, "{} 音量计算线程数据全部更新，耗时: {} ms", m_logBase, updateDuration.count());
+
     /* -------------------------------------------------------------------------------------
      * 获取静音、过载、反相的结果
      * ------------------------------------------------------------------------------------- */
+    for(auto& pair : m_mapCalculateDBThreads)
+    {
+        CalculateDBThread* pThread = pair.second;
+        if(pThread == nullptr)
+        {
+            SPDLOG_LOGGER_ERROR(m_logger, "{} 音量计算线程失效", m_logBase);
+            continue; // 跳过这个线程
+        }
+        /* 获取最新的音量数据 */
+        OneRoadVolume_t roadVolume;
+        if(pThread->getAlarmInfo(roadVolume))
+        {
+            m_compareResult.mapRoadVolumes[pair.first].similarity = roadVolume.similarity;
+            m_compareResult.mapRoadVolumes[pair.first].isSilence = roadVolume.isSilence;
+            m_compareResult.mapRoadVolumes[pair.first].isOverload = roadVolume.isOverload;
+            m_compareResult.mapRoadVolumes[pair.first].roadInfo = pThread->getRoadInfo();
+        }else {
+            SPDLOG_LOGGER_WARN(m_logger, "{} 获取音量计算结果失败，通道: {}", m_logBase, pair.first);
+        }
+    }
 
 
     /* -------------------------------------------------------------------------------------
@@ -749,7 +796,6 @@ bool CompareItemThread::generateMQTTJsonData(const CompareResult_t& compareResul
                 json1["right_db_array"].push_back(db.rightDB);
                 // fmt::print("left_db_array: {}\n", db);
             }
-            listRTData.clear();
 
             // json1["left_real_time_db"] = m_mapRealTimeData[roadNum].leftDB;
             // json1["right_real_time_db"] = m_mapRealTimeData[roadNum].rightDB;
@@ -854,7 +900,7 @@ bool CompareItemThread::checkDetectPeriod()
             pThread.second->setPhaseInDetectPeriod(true);
         }
     }
-    /* 应用于噪音检测 */
+    /* 应用于噪音检测，如果没开启噪音检测计划，这个map就是空的 */
     for(auto& pThread : m_mapNoiseDetectThreads)
     {
         if(m_detectPeriod.isApplyNoise)

Server/ThreadCalculate/CompareItemThread.h

@@ -10,6 +10,7 @@
 #include "CompareResult.h"
 #include "FromMQTT.h"
 #include "AudioData.h"
+#include "SystemConfigStruct.h"
 
 
 
@@ -34,9 +35,10 @@ class CreateDBThread;
             1、这个线程由于需要使用qmqtt发布数据，需要使用到Qt的事件循环，所以多继承了 QObject，
                线程的使用权会交给 Qt 的事件循环来管理，通过定时器定时调用 task() 函数
         
-       检测时间段说明
+       检测计划段说明
             1、在这里判断是否是检测时间段，如果不是某一项的检测时间段，则设置对应的线程为非检测时间段，对应的检测线程
                 输出的结果会做对应的处理（如噪音检测会设置为非噪音，一致性检测设置为一致）
+            2、噪音检测是否开启取决于SysConfig中的噪音检测配置
  
  */
 class CompareItemThread : public QObject, public BaseCalculateThread
@@ -122,6 +124,10 @@ private:
     /* 发布的主题 */
     QString m_pubTopic;
 
+    /* ---------------------- DEBUG ---------------------- */
+    std::chrono::steady_clock::time_point m_nowTimePoint;
+    
+    
     /* ---------------------- 对比项 ---------------------- */
 
     /* 计算音量信息的线程指针，第一个是主通道线程，int是对比项中的通道号 */
@@ -140,12 +146,17 @@ private:
     CompareResult_t m_compareResult;
     /* 实时音频数据 */
     std::map<int, std::list<OneDBData>> m_mapRealTimeData;
+    /* 每次发送的音量包数量 */
+    int m_sendVolumeCount = 3;
 
-    /* ---------------------- 检测时段 ---------------------- */
+    /* ---------------------- 检测计划 ---------------------- */
     std::mutex m_mutexDetectPeriod;         /* 检测时段互斥锁 */
     // std::atomic_bool m_isDetectPeriodUpdated = false; /* 检测时段更新标志 */
     DetectPeriodConfig_t m_detectPeriod;    /* 检测时段配置 */
     QDateTime m_lastDetectPeriodUpdateTime; /* 上次检测时段更新时间 */
+
+    /* 噪音检测参数 */
+    NoiseDetectBaseConfig_t m_noiseDetectConfig;
 };
 
 

Server/ThreadCalculate/NoiseDetectThread.cpp

@@ -75,11 +75,19 @@ void NoiseDetectThread::task()
         return;
     }
 
+    /* 计算检测间隔，转换为毫秒 */
+    int detectInterval = m_baseNoiseDetectConfig.nNoiseDetectInterval * 1000;
+    if(detectInterval <= 0)
+    {
+        SPDLOG_LOGGER_WARN(m_logger, "{} 噪音检测间隔配置错误: {}秒，设置为默认1秒", m_logBase, m_baseNoiseDetectConfig.nNoiseDetectInterval);
+        detectInterval = 1000; // 默认1秒
+    }
+
     SPDLOG_LOGGER_INFO(m_logger, " ★ {} 噪音检测线程开始运行  ", m_logBase);
     // std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now();
     while(m_isRunning)
     {
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        std::this_thread::sleep_for(std::chrono::milliseconds(detectInterval));
 
         /* 判断是否还在噪音检测时间段内，如果还在噪音报警中，
             则继续保存数据 */
@@ -171,6 +179,7 @@ bool NoiseDetectThread::initData()
 
     /* 获取噪音检测参数 */
     m_noiseDetectParam = SysConfig.getNoiseDetectParam();
+    m_baseNoiseDetectConfig = SysConfig.getNoiseDetectBaseConfig();
 
     /* 设置噪音检测参数 */
     m_ringQueueIsNoise.setQueueCapacity(m_noiseDetectParam.nNoiseDetectContinueCount);

Server/ThreadCalculate/NoiseDetectThread.h

@@ -77,6 +77,9 @@ private:
     CreateLongFileThread * m_pThreadCreateAlarm = nullptr; /* 生成报警文件的线程 */
     std::atomic_bool m_isInDetectPeriod = true;     /* 是否在检测时间段内 */
 
+    NoiseDetectBaseConfig_t m_baseNoiseDetectConfig;/* 噪音检测的基础配置 */
+    NoiseDetectParam_t m_noiseDetectParam;          /* 噪音检测参数，这个是从数据库中读取过来的 */
+
     AudioLeftRightData m_leftRightData;             /* 左右声道数据 */
 
     /* 计算的结果变量 */
@@ -87,7 +90,7 @@ private:
     bool m_isNoiseLast = false;                     /* 上一次的噪音检测结果 */
 
     /* ------------------------------------ 噪音检测的一些参数 ------------------------------------ */
-    NoiseDetectParam_t m_noiseDetectParam;      /* 噪音检测参数，这个是从数据库中读取过来的 */
+    
 
     /* 噪音检测动态库需要的参数 */
     const std::vector<std::string> m_window_params = {"tukey", "0.25"};

Server/ThreadRecord/CreateDBThread.cpp

@@ -4,6 +4,7 @@
 #include "GlobalInfo.h"
 
 #include "CalculateAudio.h"
+#include "spdlog.h"
 
 CreateDBThread::CreateDBThread(RecordThreadInfo_t& threadInfo)
     : BaseRecordThread(threadInfo)
@@ -200,34 +201,87 @@ bool CreateDBThread::getLatestResult(RingQueueManualMutex<OneSecondData*>& resul
  * @brief 获取最新的音量包结果
  * 
  * @param listData 
- * @param count 等于负数是获取所有数据，等于正数，如果暂时没有这么多数据，则返回false
+ * @param count 需要拷贝的数目，如果暂时没有这么多数据，则返回false
  * @return true 获取成功
  * @return false 无数据或者数据不足
  */
-bool CreateDBThread::getLatestRealTimeResult(std::list<OneDBData>& listData, int count)
+bool CreateDBThread::getLatestRealTimeResult(std::list<OneDBData>& listData, const int getCount)
 {
     std::lock_guard<std::mutex> lock(m_mutexRealTimeResult);
-    if(m_listRealTimeResult.empty())
+    if(getCount <= 0)
     {
-        // SPDLOG_LOGGER_TRACE(m_logger, "{} 最新实时音量数据为空", m_logBase);
         return false;
     }
-    if(count <= 0)
+
+    if(m_listRealTimeResult.empty() || static_cast<int>(m_listRealTimeResult.size()) < getCount)
     {
-        count = m_listRealTimeResult.size();
+        // SPDLOG_LOGGER_TRACE(m_logger, "{} 最新实时音量数据为空", m_logBase);
+        return false;
     }
-    if(count > static_cast<int>(m_listRealTimeResult.size()))
+
+    auto it = m_listRealTimeResult.end();
+    if(listData.empty())
     {
-        // SPDLOG_LOGGER_WARN(m_logger, "{} 最新实时音量数据不足，要求: {}, 实际: {}", m_logBase, count, m_listRealTimeResult.size());
-        return false;
+        SPDLOG_LOGGER_TRACE(m_logger, "{} 获取最新实时音量数据，列表为空，拷贝最新的{}个数据", m_logBase, getCount);
+        for(int i = 0; i < getCount; ++i)
+        {
+            it--;
+        }
+    }else 
+    {
+        /* 先向前移动getCount个数据，判断新数据是否满足 */
+        auto oldData = listData.back();
+        for(int i = 0; i < getCount; ++i)
+        {
+            it--;
+        }
+        if(it->startTime <= oldData.startTime)
+        {
+            return false;
+        }
+        /* 继续向前查找已发送的时间点 */
+        /* 找到需要开始拷贝的元素位置 */
+        while(it != m_listRealTimeResult.begin())
+        {
+            if(it->startTime <= oldData.startTime)
+            {
+                break; // 找到需要开始拷贝的元素位置
+            }
+            it--;
+        }
+        /* 上面的循环无法判断begin()，这里单独判断一下 */
+        if(it == m_listRealTimeResult.begin())
+        {
+            if(it->startTime <= oldData.startTime)
+            {
+                /* begin()是最新的，指向下一个可以拷贝的数据 */
+                it++;
+            }else 
+            {
+                /* 列表中所有的数据都比已发送的数据新，只拷贝最新的getCount个数据 */
+                it = m_listRealTimeResult.end();
+                for(int i = 0; i < getCount; ++i)
+                {
+                    it--;
+                }
+            }
+        }else 
+        {
+            /* 移动到下一个可以拷贝的新数据位置 */
+            it++;
+        }
+        
     }
-    /* 获取最新的count个数据 */
-    for(int i = 0; i < count; ++i)
+    
+    /* 拷贝数据 */
+    listData.clear();
+    for(int i = 0; it != m_listRealTimeResult.end() && i < getCount; ++it, ++i)
     {
-        listData.push_back(m_listRealTimeResult.front());
-        m_listRealTimeResult.pop_front();
+        listData.push_back(*it);
     }
 
+    // SPDLOG_LOGGER_TRACE(m_logger, "{} 获取最新实时音量数据成功，数量: {}", m_logBase, listData.size());
+
     return true;
 }
 
@@ -356,6 +410,8 @@ bool CreateDBThread::initData()
     m_queueResultData->setDefaultValue(nullptr);
     m_queueResultData->mutex.unlock();
 
+    m_numMaxResultData = 60;
+
     return true;
 }
 
@@ -479,6 +535,13 @@ bool CreateDBThread::calculateRealTimeVolume()
         /* 保存结果 */
         std::lock_guard<std::mutex> lock(m_mutexRealTimeResult);
         m_listRealTimeResult.push_back(oneDBData);
+        
+        while(static_cast<int>(m_listRealTimeResult.size()) > m_numMaxResultData)
+        {
+            /* 超过最大数量，删除最早的一个 */
+            m_listRealTimeResult.pop_front();
+        }
+        
     }
 
     return true;

Server/ThreadRecord/CreateDBThread.h

@@ -35,7 +35,7 @@ public:
     bool getLatestResult(RingQueueManualMutex<OneSecondData*>& resultQueue);
 
     /* 获取最新的音量包结果，count等于负数是获取所有数据，等于正数，如果暂时没有这么多数据，则返回false */
-    bool getLatestRealTimeResult(std::list<OneDBData>& listData, int count = -1);
+    bool getLatestRealTimeResult(std::list<OneDBData>& listData, const int getCount);
     /* 获取一个最新音量值 */
     bool getLatestRealTimeResult(OneDBData& resultData);
 
@@ -67,10 +67,11 @@ private:
     /* 计算结果环形队列，存储每秒钟的音量和反相数据 */
     RingQueueManualMutex<OneSecondData*>* m_queueResultData = nullptr;
 
-    /* --------------------------- 正常音量值的数据 --------------------------- */
+    /* --------------------------- 实时音量值的数据 --------------------------- */
     RingQueue<AudioSrcData*> m_queueRealTimeData;   /* 存储小于1秒的音频数据，应该是33m的 */
     std::mutex m_mutexRealTimeResult;               /* 实时结果的互斥锁 */
     std::list<OneDBData> m_listRealTimeResult;          /* 实时音量数据 */
+    int m_numMaxResultData = 0;                     /* 最大实时音量数据的数量 */
 };
 
 

SettingLibrary/Modules/Noise/noisemonitorparamdialog.cpp

@@ -33,10 +33,8 @@ NoiseMonitorParamDialog::NoiseMonitorParamDialog(QWidget *parent) :
     ui->lineEdit_noiseContinueCountIsWarn->setValidator(new QIntValidator(1, 10, this));
     ui->lineEdit_noiseContinueCountPercent->setValidator(new QIntValidator(1, 100, this));
 
-    /* 限制小数的正则表达式，0.0-1.0，小数点后6位 */
-    QRegExp regExp1(R"(^(0\.\d{1,6})|(1\.0{0,6})?$)");
-    QRegExpValidator* validator = new QRegExpValidator(regExp1, this);
-    ui->lineEdit_thresholdSlient->setValidator(validator);
+
+    ui->lineEdit_thresholdSlient->setValidator(new StrictDoubleValidator(-99.99, 0, 2, this));
 
     ui->lineEdit_thresholdDB->setValidator(new StrictDoubleValidator(-100, 0, 2, this));
     ui->lineEdit_thresholdCV->setValidator(new StrictDoubleValidator(-100, 0, 2, this));
@@ -46,6 +44,36 @@ NoiseMonitorParamDialog::NoiseMonitorParamDialog(QWidget *parent) :
     ui->lineEdit_noverlap->setValidator(new QIntValidator(0, 4096, this));
     ui->lineEdit_nfft->setValidator(new QIntValidator(1, 4096, this));
 
+    /* 隐藏计算参数 */
+    ui->label_computeParam->hide();
+
+    ui->label_10->hide();
+    ui->lineEdit_nperseg->hide();
+    ui->label_11->hide();
+    ui->lineEdit_noverlap->hide();
+    ui->label_13->hide();
+    ui->lineEdit_nfft->hide();
+
+
+    /* 连接信号和槽 */
+    connect(ui->pBtn_restoreDefault, &QPushButton::clicked, this, &NoiseMonitorParamDialog::do_pBtn_restoreDefault_clicked);
+
+
+    /* 设置噪音检测参数默认值 */
+    m_defaultNoiseDetectParam.nNoiseContinueCountIsWarn = 5;        /* 连续监测次数是否预警 */
+    m_defaultNoiseDetectParam.nNoiseDetectContinueCount = 10;       /* 持续监测次数 */
+    m_defaultNoiseDetectParam.nNoiseOneDetectDuration = 1;          /* 单次噪音检测时长 */
+    m_defaultNoiseDetectParam.nNoiseContinueCountPercent = 80;      /* 连续监测次数百分比 */
+    m_defaultNoiseDetectParam.dThresholdSlient = -60.0;             /* 静音阈值 */
+    m_defaultNoiseDetectParam.dThresholdDB = -70.0;                 /* 噪音分贝阈值 */
+    m_defaultNoiseDetectParam.dThresholdCV = -70.0;                 /* 变异系数阈值 */
+    m_defaultNoiseDetectParam.nPerseg = 256;                        /* 分段长度 */
+    m_defaultNoiseDetectParam.nOverlap = 32;                        /* 重叠长度 */
+    m_defaultNoiseDetectParam.nFFT = 256;                           /* FFT点数 */
+
+    /* 设置默认参数 */
+    m_noiseDetectParam = m_defaultNoiseDetectParam;
+    setInitialParams(m_noiseDetectParam);
 
     /* 设置qss */
     setQss();
@@ -76,6 +104,15 @@ void NoiseMonitorParamDialog::setInitialParams(NoiseDetectParam_t& noiseDetectPa
 }
 
 
+/* 恢复默认值 */
+void NoiseMonitorParamDialog::do_pBtn_restoreDefault_clicked()
+{
+    m_noiseDetectParam = m_defaultNoiseDetectParam;
+    setInitialParams(m_noiseDetectParam);
+}
+
+
+
 /* 设置qss */
 void NoiseMonitorParamDialog::setQss()
 {

SettingLibrary/Modules/Noise/noisemonitorparamdialog.h

@@ -24,6 +24,10 @@ public:
     /* 获取当前参数 */
     NoiseDetectParam_t getCurrentParams() const { return m_noiseDetectParam; }
 
+private slots:
+    /* 恢复默认值 */
+    void do_pBtn_restoreDefault_clicked();
+
 private:
     /* 设置qss */
     void setQss();
@@ -37,6 +41,7 @@ private:
     std::shared_ptr<spdlog::logger> m_logger = nullptr;
 
     NoiseDetectParam_t m_noiseDetectParam; // 噪音检测参数
+    NoiseDetectParam_t m_defaultNoiseDetectParam;
 };
 
 #endif // NOISEMONITORPARAMDIALOG_H

SettingLibrary/Modules/Noise/noisemonitorparamwidget.ui

@@ -65,7 +65,7 @@
       <item row="4" column="3">
        <widget class="QLabel" name="label_21">
         <property name="text">
-         <string>(0.0~1.0)</string>
+         <string>(-100~0]</string>
         </property>
        </widget>
       </item>
@@ -412,7 +412,7 @@
       <item row="5" column="3">
        <widget class="QLabel" name="label_22">
         <property name="text">
-         <string>(-100~0)</string>
+         <string>[-100~0]</string>
         </property>
        </widget>
       </item>
@@ -441,7 +441,20 @@
       <item row="4" column="6">
        <widget class="QLabel" name="label_25">
         <property name="text">
-         <string>(-100~0)</string>
+         <string>[-100~0]</string>
+        </property>
+       </widget>
+      </item>
+      <item row="5" column="5">
+       <widget class="QPushButton" name="pBtn_restoreDefault">
+        <property name="minimumSize">
+         <size>
+          <width>0</width>
+          <height>32</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>恢复默认值</string>
         </property>
        </widget>
       </item>

SettingLibrary/Modules/Noise/noisewidget.cpp

@@ -84,7 +84,7 @@ void NoiseWidget::do_pBtn_restore_clicked()
     ui->lineEdit_noiseFileDir->setText(noiseConfig.strNoiseDetectDir);
     ui->lineEdit_serverPath->setText(noiseConfig.strServerPath);
     ui->lineEdit_serverPath->setText(noiseConfig.strServerPath);
-    ui->lineEdit_detectInternal->setText(QString::number(noiseConfig.nNoiseDetectDuration));
+    ui->lineEdit_detectInternal->setText(QString::number(noiseConfig.nNoiseDetectInterval));
     ui->checkBox_enableNoiseDetect->setChecked(noiseConfig.isEnableNoiseDetect);
     ui->checkBox_mainRoadEnable->setChecked(noiseConfig.isEnableMainRoadDetect);
 }
@@ -117,7 +117,7 @@ bool NoiseWidget::saveBaseConfig()
     noiseConfig.strNoiseServerAddr = ui->lineEdit_serverAddr->text();
     noiseConfig.strNoiseDetectDir = ui->lineEdit_noiseFileDir->text();
     noiseConfig.strServerPath = ui->lineEdit_serverPath->text();
-    noiseConfig.nNoiseDetectDuration = ui->lineEdit_detectInternal->text().toInt();
+    noiseConfig.nNoiseDetectInterval = ui->lineEdit_detectInternal->text().toInt();
     noiseConfig.isEnableNoiseDetect = ui->checkBox_enableNoiseDetect->isChecked();
     noiseConfig.isEnableMainRoadDetect = ui->checkBox_mainRoadEnable->isChecked();
 

SettingLibrary/Resources/qss/white/noisemonitorparamwidget.qss

@@ -97,14 +97,14 @@ QPushButton#pBtn_ok:hover
 } */
 
 /********* 普通方框按钮三种状态效果 *********/
-QPushButton#pBtn_defaultSetting
+QPushButton#pBtn_restoreDefault
 {
     background: transparent;
     color: #3A3F63;
 	border: 1px solid #E6E9F4;
     border-radius: 4px;
 }
-QPushButton#pBtn_defaultSetting:hover
+QPushButton#pBtn_restoreDefault:hover
 {
     background: transparent;
     color: #4458FE;

ThreeLib/uos-20250731-01/include/signalstats.h

@@ -1,62 +0,0 @@
-#ifndef SIGNALSTATS_H
-#define SIGNALSTATS_H
-
-#include <nlohmann/json.hpp>
-
-// 定义导出宏
-#ifdef _WIN32
-#ifdef BUILDING_DLL
-#define EXPORT_API __declspec(dllexport)
-#else
-#define EXPORT_API __declspec(dllimport)
-#endif
-#else
-#define EXPORT_API __attribute__((visibility("default")))
-#endif
-
-namespace signalstats
-{
-    /**
-     * @brief 初始化
-     * 必须在使用前调用此函数。
-     *
-     * @param debug 是否输出调试信息
-     */
-    EXPORT_API void initialize(bool debug=false);
-
-    /**
-     * @brief 释放资源
-     *
-     * 应在程序结束时调用此函数。
-     */
-    EXPORT_API void finalize();
-
-    /**
-     * @brief 信号检测
-     *
-     * @param output 输出结果容器
-     * @param audio_signal 音频信号数据(vector)
-     * @param audio_samplerate 采样率(Hz)
-     * @param silence_threshold 信号强度之静音检测阈值(默认-60.0)，范围(-100,0]，单位dBFS(相对于满量程的分贝)
-     * @param db_threshold 能量强度之噪声分贝阈值(默认-70.0)，范围[-100,0]，单位dB
-     * @param cv_threshold 能量强度之变异系数阈值(默认-70.0)，范围[-100,0]，单位dB
-     * @param window_params 窗函数参数，窗函数类型和参数(默认("tukey", 0.25))，alpha (0.0,1.0)
-     * @param nperseg 每段样本数(默认256)，正整数
-     * @param noverlap 重叠样本数(默认32)，正整数
-     * @param nfft FFT点数(默认256)，正整数
-     * @return nlohmann::json& 输出结果容器
-     */
-    EXPORT_API nlohmann::json& detect_signal(
-        nlohmann::json &output,
-        const std::vector<double> &audio_signal,
-        double audio_samplerate,
-        double silence_threshold = -60.0,
-        double db_threshold = -70.0,
-        double cv_threshold = -70.0,
-        const std::vector<std::string> &window_params = {"tukey", "0.25"},
-        int nperseg = 256,
-        int noverlap = 32,
-        int nfft = 256);
-}
-
-#endif // SIGNALSTATS_H

ThreeLib/uos-20250731-01/lib/libsignalstats.so

@@ -1 +0,0 @@
-libsignalstats.so.1

ThreeLib/uos-20250731-01/lib/libsignalstats.so.1

@@ -1 +0,0 @@
-libsignalstats.so.1.0

ThreeLib/uos-20250731-01/run.sh

@@ -1,2 +0,0 @@
-#!/bin/bash
-LD_LIBRARY_PATH=./lib ./bin/test_main

common/DataManager/SystemConfig.cpp

@@ -155,7 +155,7 @@ bool SystemConfigInfo::getNoiseDetectBaseConfigFromJson(const std::string& jsonS
         m_noiseDetectBaseConfig.strNoiseServerAddr = jsonConfig["NoiseServerAddr"].is_null() ? "" : QString::fromStdString(jsonConfig["NoiseServerAddr"].get<std::string>());
         m_noiseDetectBaseConfig.strNoiseDetectDir = jsonConfig["NoiseDetectDir"].is_null() ? "" : QString::fromStdString(jsonConfig["NoiseDetectDir"].get<std::string>());
         m_noiseDetectBaseConfig.strServerPath = jsonConfig["ServerPath"].is_null() ? "" : QString::fromStdString(jsonConfig["ServerPath"].get<std::string>());
-        m_noiseDetectBaseConfig.nNoiseDetectDuration = jsonConfig["NoiseDetectDuration"].get<int>();
+        m_noiseDetectBaseConfig.nNoiseDetectInterval = jsonConfig["NoiseDetectInterval"].get<int>();
         m_noiseDetectBaseConfig.isEnableNoiseDetect = jsonConfig["EnableNoiseDetect"].get<bool>();
         m_noiseDetectBaseConfig.isEnableMainRoadDetect = jsonConfig["EnableMainRoadDetect"].get<bool>();
     }nJsonCatch
@@ -171,7 +171,7 @@ bool SystemConfigInfo::setNoiseDetectBaseConfigToJson(const NoiseDetectBaseConfi
         jsonConfig["NoiseServerAddr"] = noiseDetectBaseConfig.strNoiseServerAddr.toStdString();
         jsonConfig["NoiseDetectDir"] = noiseDetectBaseConfig.strNoiseDetectDir.toStdString();
         jsonConfig["ServerPath"] = noiseDetectBaseConfig.strServerPath.toStdString();
-        jsonConfig["NoiseDetectDuration"] = noiseDetectBaseConfig.nNoiseDetectDuration;
+        jsonConfig["NoiseDetectInterval"] = noiseDetectBaseConfig.nNoiseDetectInterval;
         jsonConfig["EnableNoiseDetect"] = noiseDetectBaseConfig.isEnableNoiseDetect;
         jsonConfig["EnableMainRoadDetect"] = noiseDetectBaseConfig.isEnableMainRoadDetect;
 

common/DataManager/SystemConfigStruct.cpp

@@ -56,7 +56,7 @@ bool NoiseDetectBaseConfig_t::operator==(const NoiseDetectBaseConfig_t &other) c
     if( strNoiseServerAddr == other.strNoiseServerAddr &&
         strNoiseDetectDir == other.strNoiseDetectDir &&
         strServerPath == other.strServerPath &&
-        nNoiseDetectDuration == other.nNoiseDetectDuration &&
+        nNoiseDetectInterval == other.nNoiseDetectInterval &&
         isEnableNoiseDetect == other.isEnableNoiseDetect &&
         isEnableMainRoadDetect == other.isEnableMainRoadDetect
     )

common/DataManager/SystemConfigStruct.h

@@ -66,7 +66,7 @@ struct NoiseDetectBaseConfig_t
     QString strNoiseServerAddr;         /* 噪音检测服务器地址 */
     QString strNoiseDetectDir;          /* 噪音检测文件夹 */
     QString strServerPath;              /* 噪音检测服务器路径 */
-    int nNoiseDetectDuration = 0;       /* 噪音检测间隔，单位为秒 */
+    int nNoiseDetectInterval = 0;       /* 噪音检测间隔，单位为秒 */
     
     bool isEnableNoiseDetect = false;   /* 是否启用噪音检测 */
     bool isEnableMainRoadDetect = false;/* 是否启用主通道噪音检测 */