V0.5.5

1、修复了计算静音、过载、反相不准的问题
2、修复了噪音检测未启动的问题
3、添加了写入一致性报警到数据库的功能，暂未写入成功

RTPServer/RtpOneRoadThread.cpp

@@ -302,9 +302,9 @@ bool RTPOneRoadThread::sendData()
                 SPDLOG_LOGGER_ERROR(m_logger, "{} 发送数据失败: {}:{}", m_logBase, session.clientIP.toStdString(), session.clientPort);
             } else
             {
-                SPDLOG_LOGGER_TRACE(m_logger, "{} 发送数据成功: {}:{}, 本地IP: {}:{}, 大小: {}", m_logBase, 
-                        session.clientIP.toStdString(), session.clientPort, 
-                        m_udpSocket->localAddress().toString().toStdString(), m_udpSocket->localPort(), bytesSent);
+                // SPDLOG_LOGGER_TRACE(m_logger, "{} 发送数据成功: {}:{}, 本地IP: {}:{}, 大小: {}", m_logBase, 
+                //         session.clientIP.toStdString(), session.clientPort, 
+                //         m_udpSocket->localAddress().toString().toStdString(), m_udpSocket->localPort(), bytesSent);
             }
         }
         /* 发送完数据后，删除这个数据 */

SQL/ACAServer.sql

@@ -36,10 +36,28 @@ DELETE FROM tACAAlarmInfo;
 #插入报警信息
 INSERT INTO tACAAlarmInfo (
     ItemID, ItemName, AlarmType, SoundCardNum, SoundCardName, SoundCardRoadNum, CompareRoadNum, CompareRoadName, CompareRoadType, 
-    AlarmStartTime, AlarmEndTime, AlarmDuration, AlarmFilePath, FileAlarmStartPos )
+    AlarmStartTime, AlarmEndTime, AlarmDuration, AlarmFilePath, FileAlarmStartPos, MainRoadPKID )
 VALUES (
     @itemID, @itemName, @alarmType, @soundCardNum, @soundCardName, @soundCardRoadNum, @compareRoadNum, @compareRoadName, @compareRoadType, 
-    @alarmStartTime, @alarmEndTime, @alarmDuration, @alarmFilePath, @fileAlarmStartPos );
+    @alarmStartTime, @alarmEndTime, @alarmDuration, @alarmFilePath, @fileAlarmStartPos, @mainRoadPKID);
+SELECT LAST_INSERT_ID() AS pkid;
 
+#同时插入两条报警信息
+-- 先插入主通道报警信息, 获取其主键 pkid
+INSERT INTO tACAAlarmInfo (
+    ItemID, ItemName, AlarmType, SoundCardNum, SoundCardName, SoundCardRoadNum, CompareRoadNum, CompareRoadName, CompareRoadType, 
+    AlarmStartTime, AlarmEndTime, AlarmDuration, AlarmFilePath, FileAlarmStartPos)
+VALUES (
+    @itemID1, @itemName1, @alarmType1, @soundCardNum1, @soundCardName1, @soundCardRoadNum1, @compareRoadNum1, @compareRoadName1, @compareRoadType1, 
+    @alarmStartTime1, @alarmEndTime1, @alarmDuration1, @alarmFilePath1, @fileAlarmStartPos1);
+-- 获取主通道报警信息的
+SELECT SCOPE_IDENTITY() AS pkid;
+-- 插入第二条报警信息，MainRoadPKID 就是上面获取的 pkid
+INSERT INTO tACAAlarmInfo (
+    ItemID, ItemName, AlarmType, SoundCardNum, SoundCardName, SoundCardRoadNum, CompareRoadNum, CompareRoadName, CompareRoadType, 
+    AlarmStartTime, AlarmEndTime, AlarmDuration, AlarmFilePath, FileAlarmStartPos, MainRoadPKID)
+VALUES (
+    @itemID2, @itemName2, @alarmType2, @soundCardNum2, @soundCardName2, @soundCardRoadNum2, @compareRoadNum2, @compareRoadName2, @compareRoadType2,
+    @alarmStartTime2, @alarmEndTime2, @alarmDuration2, @alarmFilePath2, @fileAlarmStartPos2, pkid);
 
 

SQL/ACASetting.sqlbook

@@ -149,7 +149,7 @@ 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-噪音
+    AlarmType INT NOT NULL, -- 报警类型，1-静音，2-过载，3-反相，4-噪音，5-不一致
     SoundCardNum VARCHAR(64) NOT NULL, -- 声卡编号（在系统中的编号）
     SoundCardName VARCHAR(64), -- 声卡名称
     SoundCardRoadNum INT NOT NULL, -- 声卡通道编号
@@ -160,7 +160,7 @@ CREATE TABLE tACAAlarmInfo
     AlarmEndTime VARCHAR(32), -- 报警结束时间 (格式：YYYY-MM-DD HH:MM:SS)
     AlarmDuration INT, -- 报警持续时间（秒数）
     AlarmFilePath VARCHAR(256), -- 报警录音文件路径
-    FileAlarmStartPos int -- 在报警录音文件中报警开始的时间
+    FileAlarmStartPos int, -- 在报警录音文件中报警开始的时间
     MainRoadPKID INT, -- 主通道的PKID
     FOREIGN KEY (ItemID) REFERENCES tACACompareItems(ItemID)
 )
@@ -171,7 +171,7 @@ COMMENT ON TABLE tACAAlarmInfo IS 'ACA报警记录表';
 COMMENT ON COLUMN tACAAlarmInfo.PKID IS '主键ID';
 COMMENT ON COLUMN tACAAlarmInfo.ItemID IS '对比项ID';
 COMMENT ON COLUMN tACAAlarmInfo.ItemName IS '对比项名称';
-COMMENT ON COLUMN tACAAlarmInfo.AlarmType IS '报警类型，1-静音，2-过载，3-反相，4-噪音';
+COMMENT ON COLUMN tACAAlarmInfo.AlarmType IS '报警类型，1-静音，2-过载，3-反相，4-噪音，5-不一致';
 COMMENT ON COLUMN tACAAlarmInfo.SoundCardNum IS '声卡编号（在系统中的编号）';
 COMMENT ON COLUMN tACAAlarmInfo.SoundCardName IS '声卡名称';
 COMMENT ON COLUMN tACAAlarmInfo.SoundCardRoadNum IS '声卡通道编号';

Server/ACAServer.cpp

@@ -1,7 +1,7 @@
 #include "ACAServer.h"
 
 
-#include "GlobalInfo.h"
+#include "GlobalInfo/GlobalInfo.h"
 #include "commonDefine.h"
 #include "SoundCardData.h"
 #include "SystemConfig.h"
@@ -116,8 +116,14 @@ bool ACAServer::initGlobalInfo()
     GInfo.setRootPath(recordFilePath);
 
     /*------------------------------------------------------------------------------------*/
-    /* 初始化全局数据信息 */
-    GInfo.initGlobalInfo();
+    /* 初始化全局数据信息，主要是为了初始化文件夹 */
+    GInfo.init();
+    /* 判断是否需要清空文件夹 */
+    const auto& baseConfig = SysConfig.getBaseConfigSrc();
+    if(baseConfig.isClearDirSystemOn)
+    {
+        GInfo.clearHistoryDirectories();
+    }
 
     /*------------------------------------------------------------------------------------*/
     /* 应用一些配置选项 */

Server/DataStruct/AudioData.cpp

@@ -94,9 +94,10 @@ void OneSecondData::Init()
     }
 }
 
+/* 计算出有多少个静音音量值 */
 int OneSecondData::calSilentDB(const StVolumeParam &param)
 {
-	if(!param.GetSilentSwitch()) return 0;
+	// if(!param.GetSilentSwitch()) return 0;
 
 	int nNum = VOLUME_INFO_NUM;
 	for(int i = 0; i < VOLUME_INFO_NUM; ++i)
@@ -105,13 +106,15 @@ int OneSecondData::calSilentDB(const StVolumeParam &param)
 		{
 			--nNum;
 		}
+		// fmt::print("LDB:{}, RDB:{}, threshold:{}\n", aryLeftDB[i], aryRightDB[i], param.GetSilentThreshold());
 	}
+	// fmt::print("一秒有 {} 个静音音量值\n", nNum);
 	return nNum;
 }
-
+/* 判断是否是静音 */
 bool OneSecondData::CalcDBOneSecond(const StVolumeParam &param)
 {
-	if(!param.GetSilentSwitch()) return false;
+	// if(!param.GetSilentSwitch()) return false;
 
 	bool bSilence = false;
 	int nNum = calSilentDB(param);
@@ -121,6 +124,7 @@ bool OneSecondData::CalcDBOneSecond(const StVolumeParam &param)
 	{
 		bSilence = true;
 	}
+	// SPDLOG_TRACE("静音计算: num: {}, threshold: {}, bSilence: {}", nNum, param.GetSilentSensitivity() * VOLUME_INFO_NUM, bSilence);
 	return bSilence;
 }
 
@@ -201,7 +205,7 @@ void OneSecondData::CalcPhase(const StVolumeParam &param, StPhase &phase, bool b
 // 判定反相: 每秒都有一个是否反相的值，持续时间内每秒都反相，就表示反相
 bool OneSecondData::CalcPhaseOneSecond(const StVolumeParam &param, bool bLastReversed)
 {
-	if(!param.GetPhaseSwitch()) return false;
+	// if(!param.GetPhaseSwitch()) return false;
 
 	StPhase phase;
 	CalcPhase(param, phase, bLastReversed);

Server/DataStruct/AudioData.h

@@ -7,7 +7,7 @@
 #include <vector>
 
 #include "GlobalVariable.h"
-#include "ChannelParam.h"
+#include "CalculateAudio.h"
 
 
 
@@ -98,7 +98,7 @@ struct OneSecondData
 	// 音频是否有错误
 	// bool AudioLeftRightDiff();
 
-    // 判定静音
+    /* 计算出有多少个静音音量值 */
     int calSilentDB(const StVolumeParam &param);
 	bool CalcDBOneSecond(const StVolumeParam &param);
     

Server/DataStruct/CalculateAudio.cpp

@@ -6,6 +6,87 @@
 #include <string>
 
 
+
+/* --------------------------------------------------------------------------------
+ * 音量设置相关参数
+ * -------------------------------------------------------------------------------- */
+StVolumeParam::StVolumeParam()
+{
+    Init();
+}
+
+void StVolumeParam::Init()
+{
+    m_bSilentSwitch = false;
+    m_iSilentThreshold = 0;
+    m_iSilentDuration = 0;
+	m_nSilentSensitivity = 80;
+
+    m_bOverloadSwitch = false;
+    m_iOverloadThreshold = 0;
+    m_iOverloadDuration = 0;
+	// 100% 全部过载才表示过载
+	m_nOverloadSensitivity = 40;
+
+    m_bPhaseSwitch = false;
+    m_iPhaseThreshold = 0.0;
+    m_iPhaseDuration = 0;
+    m_iPhaseSensitivity = 40;
+}
+
+StVolumeParam::StVolumeParam(const StVolumeParam& obj)
+{
+    *this = obj;
+}
+
+StVolumeParam& StVolumeParam::operator=(const StVolumeParam& obj)
+{
+    m_bSilentSwitch = obj.m_bSilentSwitch;
+    m_iSilentThreshold = obj.m_iSilentThreshold;
+    m_iSilentDuration = obj.m_iSilentDuration;
+	m_nSilentSensitivity = obj.m_nSilentSensitivity;
+
+    m_bOverloadSwitch = obj.m_bOverloadSwitch;
+    m_iOverloadThreshold = obj.m_iOverloadThreshold;
+    m_iOverloadDuration = obj.m_iOverloadDuration;
+	m_nOverloadSensitivity = obj.m_nOverloadSensitivity;
+
+    m_bPhaseSwitch = obj.m_bPhaseSwitch;
+    m_iPhaseThreshold = obj.m_iPhaseThreshold;
+    m_iPhaseDuration = obj.m_iPhaseDuration;
+    m_iPhaseSensitivity = obj.m_iPhaseSensitivity;
+
+    return *this;
+}
+
+int StVolumeParam::GetSilentNum() const
+{
+	// return m_iSilentDuration * GInfo.silentSensitivity();
+	return m_iSilentDuration * m_nSilentSensitivity;
+}
+
+int StVolumeParam::GetOverloadNum() const
+{
+	// return m_iOverloadDuration * GInfo.overloadSensitivity();
+	return m_iOverloadDuration * m_nOverloadSensitivity;
+}
+
+int StVolumeParam::GetPhaseNum() const
+{
+	// return m_iPhaseDuration * GInfo.iPhaseSensitivity();
+	return m_iPhaseDuration * m_iPhaseSensitivity;
+}
+
+
+
+
+
+
+
+
+
+
+
 StAudioNum::StAudioNum()
 {
 	nTotal = 0;
@@ -402,65 +483,64 @@ void CaculateDBData::setOffset(long offset)
  * @param avgDBSeconds 计算静音的平均音量秒数
  * @param startPos 开始位置
  * @param endPos 结束位置
- * @return true 
- * @return false 
+ * @return true 静音
+ * @return false 非静音
  */
-bool CaculateDBData::calculateSilent(const StVolumeParam& param, const int avgDBSeconds, int& startPos, int& endPos)
+bool CaculateDBData::calculateSilent(const StVolumeParam& param, int& startPos, int& endPos)
 {
     startPos = -1;
     endPos = -1;
-    if(param.GetSilentSwitch())
+    if(!param.GetSilentSwitch())
     {
-        const int silentDuration = param.GetSilentDuration();
-        if (silentDuration >= CACHE_DATA_SECOND_MAX)
-        {
-            SPDLOG_WARN("静音持续时间({})不能大于等于最大缓存{}秒", silentDuration, CACHE_DATA_SECOND_MAX);
-            return false;
-        }
-
-        if (ringQueue.QueueSize() < (silentDuration + m_offset) || silentDuration <= 0)
-        {
-            SPDLOG_INFO("队列中数据暂不满足静音持续时间检测({})的要求，当前队列大小为{}", silentDuration + m_offset, ringQueue.QueueSize());
-            return false;
-        }
-        if (silentDuration >= avgDBSeconds)
+		return false;
+	}
+    const int silentDuration = param.GetSilentDuration();
+    if (silentDuration >= CACHE_DATA_SECOND_MAX)
+    {
+        SPDLOG_WARN("静音持续时间 {}秒 不能大于等于最大缓存{}秒", silentDuration, CACHE_DATA_SECOND_MAX);
+        return false;
+    }
+    if (ringQueue.QueueSize() < (silentDuration + m_offset) || silentDuration <= 0)
+    {
+        SPDLOG_DEBUG("队列中数据暂不满足静音持续时间检测 {}秒 的要求，当前队列大小为{}秒", silentDuration + m_offset, ringQueue.QueueSize());
+        return false;
+    }
+    // if (silentDuration >= avgDBSeconds)
+    // {
+    //     SPDLOG_WARN("静音持续时间({})不能大于等于{}秒", silentDuration, avgDBSeconds);
+    //     return false;
+    // }
+    int nNum = 0;
+    /* 计算起始位置，获取最新的需要用到的silentDuration个数据，环形队列数据永远从0开始获取，
+     * 如果需要获取最新的数据，那么需要从队列的尾部开始获取
+     * 如果有偏移，那么起始点就是如下计算方式 */
+	int queueSize = ringQueue.QueueSize();
+    int startIndex = queueSize - silentDuration - m_offset;
+    for(int j = startIndex; j < queueSize; ++j)
+    {
+        OneSecondData *data = ringQueue[j];
+        if(data == nullptr)
         {
-            SPDLOG_WARN("静音持续时间({})不能大于等于{}秒", silentDuration, avgDBSeconds);
-            return false;
+            continue;
         }
-        int nNum = 0;
-        /* 计算起始位置，获取最新的需要用到的silentDuration个数据，环形队列数据永远从0开始获取，
-         * 如果需要获取最新的数据，那么需要从队列的尾部开始获取
-         * 如果有偏移，那么起始点就是如下计算方式 */
-		int queueSize = ringQueue.QueueSize();
-        int startIndex = queueSize - silentDuration - m_offset;
-        for(int j = startIndex; j < queueSize; ++j)
+        if (data->CalcDBOneSecond(param))
         {
-            OneSecondData *data = ringQueue[j];
-            if(data == nullptr)
-            {
-                continue;
-            }
-
-            if (data->CalcDBOneSecond(param))
+            endPos = j;
+            if (startPos < 0)
             {
-                endPos = j;
-                if (startPos < 0)
-                {
-                    startPos = j;
-                }
-                ++nNum;
+                startPos = j;
             }
-
-        }
-
-        nNum = nNum * 100;
-        if (nNum >= param.GetSilentNum())
-        {
-            return true;
+            ++nNum;
         }
     }
-    return false;
+    nNum = nNum * 100;
+	// SPDLOG_TRACE("num: {}, threhold: {}, startPos: {}, endPos: {}", nNum, param.GetSilentNum(), startPos, endPos);
+    if (nNum >= param.GetSilentNum())
+    {
+        return true;
+    }else {
+		return false;
+	}
 }
 
 /**
@@ -474,7 +554,7 @@ bool CaculateDBData::calculateSilent(const StVolumeParam& param, const int avgDB
  * @return true 
  * @return false 
  */
-bool CaculateDBData::calculateOverload(const StVolumeParam& param, const int avgDBSeconds, int& startPos, int& endPos, bool bLastOverload)
+bool CaculateDBData::calculateOverload(const StVolumeParam& param, int& startPos, int& endPos, bool bLastOverload)
 {
 	startPos = -1;
 	endPos = -1;
@@ -487,20 +567,20 @@ bool CaculateDBData::calculateOverload(const StVolumeParam& param, const int avg
 	
 	if (calculateDuration >= CACHE_DATA_SECOND_MAX)
 	{
-		SPDLOG_WARN("过载持续时间({})不能大于等于最大缓存{}秒", calculateDuration, CACHE_DATA_SECOND_MAX);		
+		SPDLOG_WARN("过载持续时间 {}秒 不能大于等于最大缓存 {}秒", calculateDuration, CACHE_DATA_SECOND_MAX);		
 		return false;
 	}
 	/* 判断队列中数据数量是否满足计算需要的数目 */
 	if(ringQueue.QueueSize() < calculateDuration || calculateDuration <= 0)
 	{
-		SPDLOG_INFO("队列中数据暂不满足过载持续时间检测({})的要求，当前队列大小为{}", calculateDuration, ringQueue.QueueSize());
-		return false;
-	}
-	if (calculateDuration >= avgDBSeconds)
-	{
-		SPDLOG_WARN("过载持续时间({})不能大于等于{}秒", calculateDuration, avgDBSeconds);
+		SPDLOG_DEBUG("队列中数据暂不满足过载持续时间检测 {}秒 的要求，当前队列大小为 {}秒", calculateDuration, ringQueue.QueueSize());
 		return false;
 	}
+	// if (calculateDuration >= avgDBSeconds)
+	// {
+	// 	SPDLOG_WARN("过载持续时间({})不能大于等于{}秒", calculateDuration, avgDBSeconds);
+	// 	return false;
+	// }
 
 	/* 计算起始位置，获取最新的需要用到的 overloadDuration 个数据，环形队列数据永远从0开始获取，
      * 如果需要获取最新的数据，那么需要从队列的尾部开始获取 */
@@ -553,13 +633,13 @@ bool CaculateDBData::calculateOverload(const StVolumeParam& param, const int avg
 	if (nOverloadNum >= param.GetOverloadNum())
 	{
 		return true;
+	}else {
+		return false;
 	}
-
-	return false;
 }
 
 /* 计算反相 */
-bool CaculateDBData::calculatePhase(const StVolumeParam& param, const int avgDBSeconds, int& startPos, int& endPos, bool isLastReversed)
+bool CaculateDBData::calculatePhase(const StVolumeParam& param, int& startPos, int& endPos, bool isLastReversed)
 {
 	startPos = -1;
 	endPos = -1;
@@ -572,20 +652,20 @@ bool CaculateDBData::calculatePhase(const StVolumeParam& param, const int avgDBS
 	const int calculateDuration = param.GetPhaseDuration();
 	if (calculateDuration >= CACHE_DATA_SECOND_MAX)
 	{
-		SPDLOG_WARN("反相持续时间({})不能大于等于最大缓存{}秒", calculateDuration, CACHE_DATA_SECOND_MAX);
+		SPDLOG_WARN("反相持续时间 {}秒 不能大于等于最大缓存{}秒", calculateDuration, CACHE_DATA_SECOND_MAX);
 		return false;
 	}
 	/* 判断队列中数据数量是否满足计算需要的数目 */
 	if(ringQueue.QueueSize() < calculateDuration || calculateDuration <= 0)
 	{
-		SPDLOG_INFO("队列中数据暂不满足反相持续时间检测({})的要求，当前队列大小为{}", calculateDuration, ringQueue.QueueSize());
-		return false;
-	}
-	if (calculateDuration >= avgDBSeconds)
-	{
-		SPDLOG_WARN("反相持续时间({})不能大于等于{}秒", calculateDuration, avgDBSeconds);
+		SPDLOG_DEBUG("队列中数据暂不满足反相持续时间检测 {}秒 的要求，当前队列大小为 {}秒", calculateDuration, ringQueue.QueueSize());
 		return false;
 	}
+	// if (calculateDuration >= avgDBSeconds)
+	// {
+	// 	SPDLOG_WARN("反相持续时间({})不能大于等于{}秒", calculateDuration, avgDBSeconds);
+	// 	return false;
+	// }
 
 	StPhase phaseData;
 

Server/DataStruct/CalculateAudio.h

@@ -4,12 +4,139 @@
 #include <string>
 
 #include "GlobalVariable.h"
-#include "ChannelParam.h"
 #include "RingQueueManualMutex.hpp"
 
 struct OneSecondData;
 
 
+
+
+
+/* =========================================================================================
+ * 宏定义
+ * =========================================================================================*/
+
+// 1秒钟30个音量值，相位值同样是30个
+#define VOLUME_INFO_NUM  30
+
+// 音量有效范围
+#define VOLUME_MAX_BD 0
+#define VOLUME_MIN_BD -90
+
+// 反相值范围
+#define REVERSED_MAX_VALUE 100
+#define REVERSED_MIN_VALUE -100
+
+// 数据库字符串长度
+#define DB_VARCHAR_LEN 32
+
+// 一次比较最多可得到多少个值（相似度）
+#define RESULT_NUM_OF_ONETIME_COMPARE 1
+
+
+/************************** 缩放比较相关宏 **************************/
+
+// 静音默认值
+#define SILENCE_DEF_VALUE true
+
+// 最大缓存180秒，3分钟
+#define CACHE_DATA_SECOND_MAX 180
+
+
+
+/**
+ * @brief 音量设置参数
+ * 
+ */
+struct StVolumeParam
+{
+    StVolumeParam();
+    StVolumeParam(const StVolumeParam& obj);
+    StVolumeParam& operator=(const StVolumeParam& obj);
+
+    void Init();
+
+	/* -------------------- 静音 -------------------- */
+	void SetSilentSwitch(bool b) { m_bSilentSwitch = b; }
+    // 静音持续时间为0不进行静音判定
+	bool GetSilentSwitch() const { return m_bSilentSwitch && m_iSilentDuration > 0; }
+
+	int GetSilentThreshold() const { return m_iSilentThreshold; }
+	void SetSilentThreshold(int ival) { m_iSilentThreshold = ival; }
+
+	int GetSilentDuration() const { return m_iSilentDuration; }
+	void SetSilentDuration(int ival) { m_iSilentDuration = ival; }
+	int GetSilentNum() const;
+
+	int GetSilentSensitivity() const { return m_nSilentSensitivity; }
+	void SetSilentSensitivity(int ival) { m_nSilentSensitivity = ival; }
+
+
+	/* -------------------- 过载 -------------------- */
+	void SetOverloadSwitch(bool b) { m_bOverloadSwitch = b; }
+	bool GetOverloadSwitch() const { return m_bOverloadSwitch && m_iOverloadDuration > 0; }
+
+	int GetOverloadThreshold() const { return m_iOverloadThreshold; }
+	void SetOverloadThreshold(int ival) { m_iOverloadThreshold = ival; }
+
+	int GetOverloadDuration() const { return m_iOverloadDuration; }
+	void SetOverloadDuration(int ival) { m_iOverloadDuration = ival; }
+
+	int GetOverloadSensitivity() const { return m_nOverloadSensitivity; }
+	void SetOverloadSensitivity(int ival) { m_nOverloadSensitivity = ival; }
+	int GetOverloadNum() const;
+
+
+	/* -------------------- 反相 -------------------- */
+	void SetPhaseSwitch(bool b) { m_bPhaseSwitch = b; }
+	bool GetPhaseSwitch() const { return m_bPhaseSwitch && m_iPhaseSensitivity > 0; }
+
+	float GetPhaseThreshold() const { return m_iPhaseThreshold; }
+	void SetPhaseThreshold(float ival) { m_iPhaseThreshold = ival; }
+
+	int GetPhaseDuration() const { return m_iPhaseDuration; }
+	void SetPhaseDuration(int ival) { m_iPhaseDuration = ival; }
+
+	int GetPhaseSensitivity() const { return m_iPhaseSensitivity; }
+	void SetPhaseSensitivity(int ival) { m_iPhaseSensitivity = ival; }
+	int GetPhaseNum() const;
+
+
+	int GetNoiseDuration() const { return 3; }
+
+private:
+	/* -------------------- 静音 -------------------- */
+	// 静音监测开关
+	bool m_bSilentSwitch;
+	int	m_iSilentThreshold;
+	// 持续时间(秒)
+	int m_iSilentDuration;
+	// 静音灵敏度（百分比）
+	int m_nSilentSensitivity;
+
+	/* -------------------- 过载 -------------------- */
+	// 过载监测开关
+	bool m_bOverloadSwitch;
+	int	m_iOverloadThreshold;
+	// 持续时间(秒)
+	int m_iOverloadDuration;
+	// 过载灵敏度（百分比）
+	int m_nOverloadSensitivity;
+
+
+	/* -------------------- 反相 -------------------- */
+	// 反相监测开关
+	bool m_bPhaseSwitch;
+	// 反相阀值(-1.0 – 1.0)
+	float	m_iPhaseThreshold;
+	// 持续时间(秒)
+	int m_iPhaseDuration;
+	// 反相灵敏度(0 - 100%)
+	int m_iPhaseSensitivity;
+};
+
+
+
 /**
  * @brief 音频数据数量信息
  * 
@@ -100,11 +227,11 @@ public:
     void setOffset(long offset);
 
     /* 计算静音 */
-    bool calculateSilent(const StVolumeParam& param, const int avgDBSeconds, int& startPos, int& endPos);
+    bool calculateSilent(const StVolumeParam& param, int& startPos, int& endPos);
     /* 计算过载 */
-    bool calculateOverload(const StVolumeParam& param, const int avgDBSeconds, int& startPos, int& endPos, bool isLastOverload);
+    bool calculateOverload(const StVolumeParam& param, int& startPos, int& endPos, bool isLastOverload);
     /* 计算反相 */
-    bool calculatePhase(const StVolumeParam& param, const int avgDBSeconds, int& startPos, int& endPos, bool isLastReversed);
+    bool calculatePhase(const StVolumeParam& param, int& startPos, int& endPos, bool isLastReversed);
 
 
     /* 判断平均音量是否低于设置的值 */

Server/DataStruct/ChannelParam.cpp

@@ -1,79 +0,0 @@
-#include "ChannelParam.h"
-
-#include <string>
-#include "spdlog/spdlog.h"
-#include "GlobalInfo.h"
-
-
-/* --------------------------------------------------------------------------------
- * 音量设置相关参数
- * -------------------------------------------------------------------------------- */
-StVolumeParam::StVolumeParam()
-{
-    Init();
-}
-
-void StVolumeParam::Init()
-{
-    m_bSilentSwitch = false;
-    m_iSilentThreshold = 0;
-    m_iSilentDuration = 0;
-	m_nSilentSensitivity = 80;
-
-    m_bOverloadSwitch = false;
-    m_iOverloadThreshold = 0;
-    m_iOverloadDuration = 0;
-	// 100% 全部过载才表示过载
-	m_nOverloadSensitivity = 40;
-
-    m_bPhaseSwitch = false;
-    m_iPhaseThreshold = 0.0;
-    m_iPhaseDuration = 0;
-    m_iPhaseSensitivity = 40;
-}
-
-StVolumeParam::StVolumeParam(const StVolumeParam& obj)
-{
-    *this = obj;
-}
-
-StVolumeParam& StVolumeParam::operator=(const StVolumeParam& obj)
-{
-    m_bSilentSwitch = obj.m_bSilentSwitch;
-    m_iSilentThreshold = obj.m_iSilentThreshold;
-    m_iSilentDuration = obj.m_iSilentDuration;
-	m_nSilentSensitivity = obj.m_nSilentSensitivity;
-
-    m_bOverloadSwitch = obj.m_bOverloadSwitch;
-    m_iOverloadThreshold = obj.m_iOverloadThreshold;
-    m_iOverloadDuration = obj.m_iOverloadDuration;
-	m_nOverloadSensitivity = obj.m_nOverloadSensitivity;
-
-    m_bPhaseSwitch = obj.m_bPhaseSwitch;
-    m_iPhaseThreshold = obj.m_iPhaseThreshold;
-    m_iPhaseDuration = obj.m_iPhaseDuration;
-    m_iPhaseSensitivity = obj.m_iPhaseSensitivity;
-
-    return *this;
-}
-
-int StVolumeParam::GetSilentNum() const
-{
-	return m_iSilentDuration * GInfo.silentSensitivity();
-}
-
-int StVolumeParam::GetOverloadNum() const
-{
-	return m_iOverloadDuration * GInfo.overloadSensitivity();
-}
-
-int StVolumeParam::GetPhaseNum() const
-{
-	return m_iPhaseDuration * GInfo.iPhaseSensitivity();
-}
-
-
-
-
-
-

Server/DataStruct/ChannelParam.h

@@ -1,132 +0,0 @@
-#ifndef _CHANNEL_PARAM_H_
-#define _CHANNEL_PARAM_H_
-
-/* =========================================================================================
- * 宏定义
- * =========================================================================================*/
-
-// 1秒钟30个音量值，相位值同样是30个
-#define VOLUME_INFO_NUM  30
-
-// 音量有效范围
-#define VOLUME_MAX_BD 0
-#define VOLUME_MIN_BD -90
-
-// 反相值范围
-#define REVERSED_MAX_VALUE 100
-#define REVERSED_MIN_VALUE -100
-
-// 数据库字符串长度
-#define DB_VARCHAR_LEN 32
-
-// 一次比较最多可得到多少个值（相似度）
-#define RESULT_NUM_OF_ONETIME_COMPARE 1
-
-
-/************************** 缩放比较相关宏 **************************/
-
-// 静音默认值
-#define SILENCE_DEF_VALUE true
-
-// 最大缓存180秒，3分钟
-#define CACHE_DATA_SECOND_MAX 180
-
-
-
-/**
- * @brief 音量设置参数
- * 
- */
-struct StVolumeParam
-{
-    StVolumeParam();
-    StVolumeParam(const StVolumeParam& obj);
-    StVolumeParam& operator=(const StVolumeParam& obj);
-
-    void Init();
-
-	/* -------------------- 静音 -------------------- */
-	void SetSilentSwitch(bool b) { m_bSilentSwitch = b; }
-    // 静音持续时间为0不进行静音判定
-	bool GetSilentSwitch() const { return m_bSilentSwitch && m_iSilentDuration > 0; }
-
-	int GetSilentThreshold() const { return m_iSilentThreshold; }
-	void SetSilentThreshold(int ival) { m_iSilentThreshold = ival; }
-
-	int GetSilentDuration() const { return m_iSilentDuration; }
-	void SetSilentDuration(int ival) { m_iSilentDuration = ival; }
-	int GetSilentNum() const;
-
-	int GetSilentSensitivity() const { return m_nSilentSensitivity; }
-	void SetSilentSensitivity(int ival) { m_nSilentSensitivity = ival; }
-
-
-	/* -------------------- 过载 -------------------- */
-	void SetOverloadSwitch(bool b) { m_bOverloadSwitch = b; }
-	bool GetOverloadSwitch() const { return m_bOverloadSwitch && m_iOverloadDuration > 0; }
-
-	int GetOverloadThreshold() const { return m_iOverloadThreshold; }
-	void SetOverloadThreshold(int ival) { m_iOverloadThreshold = ival; }
-
-	int GetOverloadDuration() const { return m_iOverloadDuration; }
-	void SetOverloadDuration(int ival) { m_iOverloadDuration = ival; }
-
-	int GetOverloadSensitivity() const { return m_nOverloadSensitivity; }
-	void SetOverloadSensitivity(int ival) { m_nOverloadSensitivity = ival; }
-	int GetOverloadNum() const;
-
-
-	/* -------------------- 反相 -------------------- */
-	void SetPhaseSwitch(bool b) { m_bPhaseSwitch = b; }
-	bool GetPhaseSwitch() const { return m_bPhaseSwitch && m_iPhaseSensitivity > 0; }
-
-	float GetPhaseThreshold() const { return m_iPhaseThreshold; }
-	void SetPhaseThreshold(float ival) { m_iPhaseThreshold = ival; }
-
-	int GetPhaseDuration() const { return m_iPhaseDuration; }
-	void SetPhaseDuration(int ival) { m_iPhaseDuration = ival; }
-
-	int GetPhaseSensitivity() const { return m_iPhaseSensitivity; }
-	void SetPhaseSensitivity(int ival) { m_iPhaseSensitivity = ival; }
-	int GetPhaseNum() const;
-
-
-	int GetNoiseDuration() const { return 3; }
-
-private:
-	/* -------------------- 静音 -------------------- */
-	// 静音监测开关
-	bool m_bSilentSwitch;
-	int	m_iSilentThreshold;
-	// 持续时间(秒)
-	int m_iSilentDuration;
-	// 过载灵敏度（百分比）
-	int m_nSilentSensitivity;
-
-	/* -------------------- 过载 -------------------- */
-	// 过载监测开关
-	bool m_bOverloadSwitch;
-	int	m_iOverloadThreshold;
-	// 持续时间(秒)
-	int m_iOverloadDuration;
-	// 过载灵敏度（百分比）
-	int m_nOverloadSensitivity;
-
-
-	/* -------------------- 反相 -------------------- */
-	// 反相监测开关
-	bool m_bPhaseSwitch;
-	// 反相阀值(-1.0 – 1.0)
-	float	m_iPhaseThreshold;
-	// 持续时间(秒)
-	int m_iPhaseDuration;
-	// 反相灵敏度(0 - 100%)
-	int m_iPhaseSensitivity;
-};
-
-
-
-
-
-
-#endif /* _CHANNEL_PARAM_H_ */

Server/DataStruct/CompareResult.cpp → Server/DataStruct/CompareItemResult.cpp

@@ -1,4 +1,4 @@
-#include "CompareResult.h"
+#include "CompareItemResult.h"
 
 OneRoadVolume_t::OneRoadVolume_t()
     : isSilence(false), isOverload(false), 

Server/DataStruct/CompareResult.h → Server/DataStruct/CompareItemResult.h

@@ -1,9 +1,9 @@
-#ifndef COMPARERESULT_H_
-#define COMPARERESULT_H_
+#ifndef COMPAREITEMRESULT_H_
+#define COMPAREITEMRESULT_H_
 
 
 #include "GlobalVariable.h"
-#include "ChannelParam.h"
+#include "CalculateAudio.h"
 #include <QDateTime>
 
 /**
@@ -57,4 +57,4 @@ struct CompareResult_t
 
 
 
-#endif // COMPARERESULT_H_
+#endif // COMPAREITEMRESULT_H_

Server/DataStruct/ConsistencyResult.h

@@ -2,7 +2,7 @@
 #define CONSISTENCYRESULT_H_
 
 #include "GlobalVariable.h"
-#include "ChannelParam.h"
+#include "CalculateAudio.h"
 
 #include <QDateTime>
 

Server/DataStruct/SendStruct.h

@@ -6,7 +6,7 @@
 #include <map>
 
 #include "GlobalVariable.h"
-#include "ChannelParam.h"
+#include "CalculateAudio.h"
 
 /**
  * @brief 对比项信息结构体

Server/GlobalInfo/GlobalInfo.cpp

@@ -11,7 +11,7 @@ GlobalInfo::~GlobalInfo()
 
 
 /* 初始化全局信息 */
-void GlobalInfo::initGlobalInfo()
+void GlobalInfo::init()
 {
     /* 初始化文件夹 */
     initDirectories();
@@ -19,6 +19,31 @@ void GlobalInfo::initGlobalInfo()
     initData();
 }
 
+/* 清空历史文件夹 */
+void GlobalInfo::clearHistoryDirectories()
+{
+    QDir dir(m_wavPath);
+    if(dir.exists())
+    {
+        dir.removeRecursively(); // 删除整个目录及其内容
+    }
+    dir.mkpath(m_wavPath); // 重新创建目录
+
+    dir.setPath(m_longWavPath);
+    if(dir.exists())
+    {
+        dir.removeRecursively();
+    }
+    dir.mkpath(m_longWavPath);
+
+    dir.setPath(m_alarmWavPath);
+    if(dir.exists())
+    {
+        dir.removeRecursively();
+    }
+    dir.mkpath(m_alarmWavPath);
+}
+
 void GlobalInfo::setMqttInfo(const QString& ip, int port)
 {
     m_mqttIP = ip;          /* 设置MQTT服务器IP */

Server/GlobalInfo/GlobalInfo.h

@@ -37,15 +37,17 @@ class GlobalInfo
 public:
     ~GlobalInfo();
 
-    /* 获取全局信息单例 */
-    static GlobalInfo& getInstance()
+    /* 获取全局信息单例 */ static GlobalInfo& getInstance()
     {
         static GlobalInfo instance; // 局部静态变量，线程安全
         return instance;
     }
 
     /* 初始化全局信息 */
-    void initGlobalInfo();
+    void init();
+    /* 清空历史文件夹 */
+    void clearHistoryDirectories();
+
 
     /* 获取mqtt信息 */
     QString mqttIP() const {return m_mqttIP;}
@@ -69,14 +71,11 @@ public:
 
     /* 获取环形队列元素数目 */
     int32_t queueElementCount() const {return m_queueElementCount;}
-    /* 获取一秒音频字节大小 */
-    // int32_t oneSecondCount() const {return m_oneSecondCount;}
     /* 获取wav文件时长 */
     int32_t wavFileDuration() const {return m_wavFileDuration;}
     /* 获取噪音检测元素大小，单位：秒 */
     int32_t noiseElementDuration() const {return m_noiseElementDuration;}
-    /* 获取计算音量和反相的环形队列元素数目 */
-    // int32_t DBQueueElementCount() const {return m_DBQueueElementCount;}
+
 
     /* 设置根目录 */
     void setRootPath(const QString& path) { m_rootPath = path; }
@@ -117,21 +116,9 @@ public:
     /* 获取正弦波有效数据个数 */
     int sinEffectiveNum() const {return m_sinEffectiveNum;}
 
-    /* 获取杭州台是否按上面的逻辑来 */
-    // bool isAINotConsistencyAlone() const {return m_isAINotConsistencyAlone; }
     /* 获取是否需要等待静音状态 */
     int nIsSameBothMinDBWaitNum() const {return m_nIsSameBothMinDBWaitNum;}
-    /* 获取一致性对比时间间隔 */
-    // int compareTimeSpan() const {return m_nCompareTimeSpan <= 500 ? 500 : m_nCompareTimeSpan; } // 最小500毫秒
-
-    /* 获取AI对比持续次数 */
-    // int AICMPThresholdNum() const {return m_nAICMPThresholdNum;}
-    // /* 获取AI对比相似度阀值 */
-    // float AICMPThresholdNot() const {return m_fAICMPThresholdNot;}
-    // /* 获取音频错位百分比 */
-    // float AICMPOffset() const {return m_fAICMPOffset;}
-    // /* 获取AI对比相似度阀值 */
-    // float AICMPThreshold() const {return m_fAICMPThresholdNot > 0.99 ? 0.99 : m_fAICMPThresholdNot; } //
+
 
 private:
     /* 初始化文件夹 */
@@ -164,7 +151,6 @@ private:
     uint16_t m_bitsPerSample = 16;              /* 每个采样点的位数 */
 
     /******************** 一些默认的设置 *********************/
-    // int32_t m_oneSecondCount = 0;              /* 这里使用一秒音频的字节个数 */
     int32_t m_queueElementCount = 180;          /* 默认缓冲区的大小，也就是音频处理线程的环形队列的大小，单位是秒 */
     int32_t m_wavFileDuration = 60;             /* 一个wav小文件有多少秒的数据 */
 
@@ -210,21 +196,6 @@ private:
     /* 因为音频播放存在时间偏移，判断两个都是静音，或者判断一个静音一个非静音时，
      * 需要有延时时间(次数)，CalcRefreshDataThread线程一秒一次 */
     int m_nIsSameBothMinDBWaitNum = 3;
-
-    
-
-    /******************** AI比对参数（动态库比对参数） *********************/
-    // // AI对比持续次数
-    // int m_nAICMPThresholdNum = 3;
-    // // AI对比相似度阀值，比这个阀值小，就表示不一致性
-    // float m_fAICMPThresholdNot = 0.6;
-    // // 音频错位百分比(比如0.5就是错位不能超过一半，超过一半判断为不一致)：
-    // float m_fAICMPOffset = 0.5;
-    // // AI对比相似度阀值，比这个阀值大，就表示一致性
-    // float m_fAICMPThreshold = 0.7;
-
-    // // 一致性对比时间间隔（单位毫秒）；8000采样时建议1000毫秒，48000采样时建议3000；DoubleCompare比较时时间会自动翻倍
-    // int m_nCompareTimeSpan = 3000;
     
 };
 

Server/ThreadCalculate/CalculateDBThread.cpp

@@ -100,6 +100,7 @@ void CalculateDBThread::task()
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(10));
 
+        std::chrono::steady_clock::time_point startTime = std::chrono::steady_clock::now();
         /* --------------------------------------------------------------------------------
          * 更新最新数据
          * --------------------------------------------------------------------------------*/
@@ -115,7 +116,12 @@ void CalculateDBThread::task()
         /* --------------------------------------------------------------------------------
          * 计算数据
          * --------------------------------------------------------------------------------*/
+        
         calcuDBData();
+
+        std::chrono::steady_clock::time_point endTime = std::chrono::steady_clock::now();
+        std::chrono::microseconds duration = std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime);
+        // SPDLOG_LOGGER_TRACE(m_logger, "{} 计算静音、过载和反相结束, 线程耗时: {}us", m_logBase, duration.count());
     }
     /* 停止所有的报警 */
     endAllAlarm();
@@ -210,9 +216,11 @@ void CalculateDBThread::clearData()
  */
 void CalculateDBThread::calcuDBData()
 {
+    
     /* 有最新数据，进行计算 */
     m_mutexVolumeInfo.lock();
     
+    /* 拷贝音量包 */
     for(int i = 0; i < VOLUME_INFO_NUM; ++i)
     {
         m_roadVolumeInfo.vecleftDB[i] = m_currSecondData.aryLeftDB[i];
@@ -226,8 +234,7 @@ void CalculateDBThread::calcuDBData()
     /* 计算静音 */
     if(m_isSilenceInDetectPeriod)
     {
-        m_roadVolumeInfo.isSilence = m_caculateDBData.calculateSilent(m_volumeParam, m_avgCalculateDBSeconds, 
-                                    m_silentStartPos, m_silentEndPos);
+        m_roadVolumeInfo.isSilence = m_caculateDBData.calculateSilent(m_volumeParam, m_silentStartPos, m_silentEndPos);
     }else {
         m_roadVolumeInfo.isSilence = false;
     }
@@ -235,8 +242,7 @@ void CalculateDBThread::calcuDBData()
     /* 计算过载 */
     if(m_isOverloadInDetectPeriod)
     {
-        m_roadVolumeInfo.isOverload = m_caculateDBData.calculateOverload(m_volumeParam, m_avgCalculateDBSeconds, 
-                                    m_overloadStartPos, m_overloadEndPos, m_bLastOverload);
+        m_roadVolumeInfo.isOverload = m_caculateDBData.calculateOverload(m_volumeParam, m_overloadStartPos, m_overloadEndPos, m_bLastOverload);
     }else {
         m_roadVolumeInfo.isOverload = false;
     }
@@ -244,8 +250,7 @@ void CalculateDBThread::calcuDBData()
     /* 计算反相 */
     if(m_isPhaseInDetectPeriod)
     {
-        m_roadVolumeInfo.isReversed = m_caculateDBData.calculatePhase(m_volumeParam, m_avgCalculateDBSeconds, 
-                                    m_phaseStartPos, m_phaseEndPos, m_bLastReversed);
+        m_roadVolumeInfo.isReversed = m_caculateDBData.calculatePhase(m_volumeParam, m_phaseStartPos, m_phaseEndPos, m_bLastReversed);
     }else {
         m_roadVolumeInfo.isReversed = false;
     }
@@ -286,6 +291,15 @@ void CalculateDBThread::processSilence()
         if(!m_alarmSilence.isAlarm)
         {
             /* 开启静音报警 */
+            m_alarmSilence.CompareItemID = m_threadInfo.compareItemInfo.nID;
+            m_alarmSilence.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
+            if(m_alarmSilence.CompareItemID == 1)
+            {
+                m_alarmSilence.RoadType = ERoadType::RoadType_Main;
+            }else {
+                m_alarmSilence.RoadType = ERoadType::RoadType_SpaceReceive;
+            }
+
             m_alarmSilence.isAlarm = true;
             m_alarmSilence.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
             m_alarmSilence.RoadInfo = m_roadInfo; // 设置通道信息
@@ -355,25 +369,6 @@ void CalculateDBThread::processSilence()
         }
     }
 
-    /* 更新结果，实时更新 */
-    // if(m_alarmSilence.AlarmType != EAlarmType::EAT_None)
-    // {
-    //     /* 有报警类型，进一步判断是否有报警 */
-    //     if(m_alarmSilence.isAlarm)
-    //     {
-    //         /* 有报警，更新报警信息，判断一下上次的报警是否被取走 */
-    //         if(m_alarmLastSilence.AlarmType == EAlarmType::EAT_None || m_alarmLastSilence.isAlarm == true)
-    //         {
-    //             /* 报警结束信息被取走了，清空了结果，或者正在报警中，更新信息 */
-    //             m_alarmLastSilence = m_alarmSilence;
-    //         }
-    //     }else 
-    //     {
-    //         /* 有报警类型无报警，说明是报警结束了 */
-    //         m_alarmLastSilence = m_alarmSilence;
-    //         m_alarmSilence = AlarmInfo_t(); // 清空报警信息
-    //     }
-    // }
 }
 
 /* 处理过载报警 */
@@ -385,6 +380,15 @@ void CalculateDBThread::processOverload()
         if(!m_alarmOverload.isAlarm)
         {
             /* 开启过载报警 */
+            m_alarmOverload.CompareItemID = m_threadInfo.compareItemInfo.nID;
+            m_alarmOverload.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
+            if(m_alarmOverload.CompareItemID == 1)
+            {
+                m_alarmOverload.RoadType = ERoadType::RoadType_Main;
+            }else {
+                m_alarmOverload.RoadType = ERoadType::RoadType_SpaceReceive;
+            }
+
             m_alarmOverload.isAlarm = true;
             m_alarmOverload.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
             m_alarmOverload.RoadInfo = m_roadInfo; // 设置通道信息
@@ -455,26 +459,6 @@ void CalculateDBThread::processOverload()
             m_alarmOverload = AlarmInfo_t();
         }
     }
-
-    /* 更新结果，实时更新 */
-    // if(m_alarmOverload.AlarmType != EAlarmType::EAT_None)
-    // {
-    //     /* 有报警类型，进一步判断是否有报警 */
-    //     if(m_alarmOverload.isAlarm)
-    //     {
-    //         /* 有报警，更新报警信息，判断一下上次的报警是否被取走 */
-    //         if(m_alarmLastOverload.AlarmType == EAlarmType::EAT_None || m_alarmLastOverload.isAlarm == true)
-    //         {
-    //             /* 报警结束信息被取走了，或者正在报警中，更新信息 */
-    //             m_alarmLastOverload = m_alarmOverload;
-    //         }
-    //     }else 
-    //     {
-    //         /* 有报警类型无报警，说明是报警结束了 */
-    //         m_alarmLastOverload = m_alarmOverload;
-    //         m_alarmOverload = AlarmInfo_t(); // 清空报警信息
-    //     }
-    // }
     
 }
 
@@ -487,8 +471,16 @@ void CalculateDBThread::processPhase()
         if(!m_alarmPhase.isAlarm)
         {
             /* 开启反相报警 */
-            m_alarmPhase.isAlarm = true;
+            m_alarmPhase.CompareItemID = m_threadInfo.compareItemInfo.nID;
             m_alarmPhase.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
+            if(m_alarmPhase.CompareItemID == 1)
+            {
+                m_alarmPhase.RoadType = ERoadType::RoadType_Main;
+            }else {
+                m_alarmPhase.RoadType = ERoadType::RoadType_SpaceReceive;
+            }
+            
+            m_alarmPhase.isAlarm = true;
             m_alarmPhase.RoadInfo = m_roadInfo; // 设置通道信息
             m_alarmPhase.AlarmType = EAlarmType::EAT_Reversed; // 反相报警
             /* 计算开始时间，往前推设置的反相时长 */

Server/ThreadCalculate/CalculateDBThread.h

@@ -7,7 +7,7 @@
 #include "CreateRecordFileThread.h"
 #include "SendStruct.h"
 #include "CalculateAudio.h"
-#include "CompareResult.h"
+#include "CompareItemResult.h"
 
 
 /**
@@ -86,7 +86,6 @@ private:
     /* 生成音量的线程 */
     CreateDBThread* m_threadCreateDB = nullptr;             /* 生成音量的线程 */
     OneSecondData m_currSecondData;                         /* 最新一秒的数据 */
-    StVolumeParam m_volumeParam;                            /* 音量计算的参数 */
 
     /* 录制报警文件的线程 */
     CreateRecordFileThread* m_threadCreateAlarmFile = nullptr;
@@ -97,7 +96,8 @@ private:
     bool m_bLastReversed = false;                           /* 上一次的反相状态 */
     bool m_bLastOverload = false;                           /* 上一次的过载状态 */
 
-    /* 计算需要的相关参数 */
+    /* ----------------------------- 计算需要的相关参数 ----------------------------- */
+    StVolumeParam m_volumeParam;                            /* 音量计算的参数 */
     int32_t m_avgCalculateDBSeconds = 0;                   /* 计算平均音量需要的秒数 */
 
     int m_silentStartPos = -1;                              /* 静音开始位置 */
@@ -111,12 +111,6 @@ private:
     AlarmInfo_t m_alarmOverload;                            /* 过载报警信息 */
     AlarmInfo_t m_alarmPhase;                               /* 反相报警信息 */
 
-    /* 这里的报警信息作为返回给对比项线程的中介，防止刚结束报警，结果还未取出，又来了一个报警，
-     * 报警时间粘连的问题 */
-    // AlarmInfo_t m_alarmLastSilence;                         /* 上一次静音报警信息 */
-    // AlarmInfo_t m_alarmLastOverload;                        /* 上一次过载报警信息 */
-    // AlarmInfo_t m_alarmLastPhase;                           /* 上一次反相报警信息 */
-    AlarmInfo_t m_alarmNull;                                /* 空报警信息 */
 };
 
 

Server/ThreadCalculate/CompareItemThread.cpp

@@ -1,6 +1,6 @@
 #include "CompareItemThread.h"
 
-#include "ChannelParam.h"
+#include "CalculateAudio.h"
 #include "CreateRecordFileThread.h"
 #include "FromMQTT.h"
 #include "GlobalInfo.h"
@@ -464,9 +464,17 @@ bool CompareItemThread::createCalculateDBThreads()
     for(const auto& road : m_threadInfo.compareItemInfo.mapRoad)
     {
         CalculateThreadInfo_t threadInfo;
+        threadInfo.compareItemInfo.nID = m_threadInfo.compareItemInfo.nID;
+        threadInfo.compareItemInfo.strName = m_threadInfo.compareItemInfo.strName;
         threadInfo.compareItemInfo.mapRoad.clear(); // 清空通道信息
-        threadInfo.compareItemInfo.mapRoad.insert(road.nCompareRoadNum, road); // 添加当前通道
-        threadInfo.threadState = EThreadState::State_Inited; // 初始化线程状态
+        /* 添加通道信息 */
+        threadInfo.compareItemInfo.mapRoad.insert(road.nCompareRoadNum, road);
+        /* 添加静音、过载、反相的检测状态 */
+        threadInfo.compareItemInfo.paramMute = m_threadInfo.compareItemInfo.paramMute;
+        threadInfo.compareItemInfo.paramOverload = m_threadInfo.compareItemInfo.paramOverload;
+        threadInfo.compareItemInfo.paramPhase = m_threadInfo.compareItemInfo.paramPhase;
+        /* 添加线程信息 */
+        threadInfo.threadState = EThreadState::State_Inited;
         threadInfo.threadType = EThreadType::Type_CalculateDB;
         CalculateDBThread* pThread = new CalculateDBThread(threadInfo);
         if(pThread == nullptr)
@@ -520,6 +528,8 @@ void CompareItemThread::createNoiseDetectThreads()
         }
         CalculateThreadInfo_t threadInfo;
         threadInfo.compareItemInfo.mapRoad.clear(); // 清空通道信息
+        threadInfo.compareItemInfo.nID = m_threadInfo.compareItemInfo.nID;
+        threadInfo.compareItemInfo.strName = m_threadInfo.compareItemInfo.strName;
         threadInfo.compareItemInfo.mapRoad.insert(road.nCompareRoadNum, road); // 添加当前通道
         threadInfo.threadState = EThreadState::State_Inited; // 初始化线程状态
         threadInfo.threadType = EThreadType::Type_CalculateDB;
@@ -529,6 +539,7 @@ void CompareItemThread::createNoiseDetectThreads()
             SPDLOG_LOGGER_ERROR(m_logger, "{} 创建噪音检测线程失败", m_logBase);
             return; // 获取线程失败
         }
+        CPPTP.add_task(&NoiseDetectThread::threadTask, pThread);
         m_mapNoiseDetectThreads.insert({road.nCompareRoadNum, pThread});
     }
 }
@@ -735,15 +746,6 @@ bool CompareItemThread::updateResultData()
 /* 发送数据 */
 void CompareItemThread::sendResultData()
 {
-    // for(const auto& roadVolume : m_compareResult.mapRoadVolumes)
-    // {
-    //     const OneRoadVolume_t& volume = roadVolume.second;
-    //     for(int i = 0; i < VOLUME_INFO_NUM; ++i)
-    //     {
-    //         fmt::print("LDB:{}, RDB:{}\n", volume.vecleftDB[i], volume.vecrightDB[i]);
-    //     }
-    // }
-
     if(m_pFromMQTT == nullptr)
     {
         SPDLOG_LOGGER_WARN(m_logger, "{} MQTT连接未初始化，无法发送数据", m_logBase);
@@ -790,7 +792,7 @@ bool CompareItemThread::generateMQTTJsonData(const CompareResult_t& compareResul
         json0["compareItem_id"] = compareResult.compareItemID;
         json0["compareItem_name"] = compareResult.compareItemName.c_str();
         json0["date_time"] = compareResult.dateTime.toString("yyyy-MM-dd hh:mm:ss").toStdString();
-        json0["is_client_alarm"] = compareResult.isClientAlarm;
+        // json0["is_client_alarm"] = compareResult.isClientAlarm;
         
         for(const auto& roadVolume : compareResult.mapRoadVolumes)
         {

Server/ThreadCalculate/CompareItemThread.h

@@ -7,7 +7,7 @@
 #include <QTimer>
 
 #include "BaseCalculateThread.h"
-#include "CompareResult.h"
+#include "CompareItemResult.h"
 #include "FromMQTT.h"
 #include "AudioData.h"
 #include "SystemConfigStruct.h"

Server/ThreadCalculate/ConsistencyCompareThread.cpp

@@ -109,7 +109,9 @@ void ConsistencyCompareThread::task()
 
     SPDLOG_LOGGER_INFO(m_logger, " ★ {} 一致性对比线程(调用动态库)开始运行  ", m_logBase);
     
-
+    std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now();
+    int nCompareCount = 0; // 计算次数
+    bool isConsistency = true;
     while(m_isRunning)
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -132,12 +134,35 @@ void ConsistencyCompareThread::task()
             /* 如果此时还在非一致性报警中，结束报警 */
             if(m_alarmConsistencyMain.isAlarm || m_alarmConsistencySub.isAlarm)
             {
-                saveAlarmInfo();
+                endAlarm();
             }
             continue;
         }
-
+        /* 计算一致性 */
         compareConsistencyData();
+
+        /* 模拟不一致报警，启动检测五次开始报警，报警5次取消报警，间隔5次继续报警 */
+        if(isConsistency)
+        {
+            if(nCompareCount > 5)
+            {
+                isConsistency = false;
+                m_isConsistency = false;
+                m_isConsistencyWarning = true;
+                
+            }
+        }else {
+            if(nCompareCount > 5)
+            {
+                isConsistency = true;
+                m_isConsistency = true;
+                m_isConsistencyWarning = false;
+
+            }
+        }
+
+        /* 保存结果 */
+        saveAlarmInfo();
     }
     clearData();
     SPDLOG_LOGGER_WARN(m_logger, " ★ {} 一致性对比线程(调用动态库)已结束运行  ", m_logBase);
@@ -325,8 +350,8 @@ void ConsistencyCompareThread::saveAlarmInfo()
             m_threadCreateAlarmFile2->stopRecordAlarmFile(m_alarmConsistencySub);
 
             /* 将报警信息写入数据库 */
-            AlarmManager.addAlarmInfo(m_alarmConsistencyMain);
-            AlarmManager.addAlarmInfo(m_alarmConsistencySub);
+            AlarmManager.addAlarmInfo(m_alarmConsistencyMain, m_alarmConsistencySub);
+
             
             SPDLOG_LOGGER_INFO(m_logger, "{}: 一致性报警结束", m_logBase);
             /* 清除报警信息 */
@@ -345,6 +370,8 @@ void ConsistencyCompareThread::saveAlarmInfo()
             m_alarmConsistencySub.CompareItemID = m_threadInfo.compareItemInfo.nID;
             m_alarmConsistencyMain.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
             m_alarmConsistencySub.strCompareItemName = m_threadInfo.compareItemInfo.strName.toStdString();
+            m_alarmConsistencyMain.RoadType = ERoadType::RoadType_Main;
+            m_alarmConsistencySub.RoadType = ERoadType::RoadType_SpaceReceive;
             m_alarmConsistencyMain.RoadInfo = m_itemRoadInfo1;
             m_alarmConsistencySub.RoadInfo = m_itemRoadInfo2;
 

Server/ThreadCalculate/NoiseDetectThread.cpp

@@ -181,6 +181,11 @@ bool NoiseDetectThread::initData()
     m_noiseDetectParam = SysConfig.getNoiseDetectParam();
     m_baseNoiseDetectConfig = SysConfig.getNoiseDetectBaseConfig();
 
+    /* 设置给计算的参数变量 */
+    m_silence_threshold = m_noiseDetectParam.dThresholdSlient;
+    m_db_threshold = m_noiseDetectParam.dThresholdDB;
+    m_cv_threshold = m_noiseDetectParam.dThresholdCV;
+
     /* 设置噪音检测参数 */
     m_ringQueueIsNoise.setQueueCapacity(m_noiseDetectParam.nNoiseDetectContinueCount);
 
@@ -244,7 +249,7 @@ bool NoiseDetectThread::detectNoise()
         isNoiseRight = jsonOutput["noise"].is_null() ? false : jsonOutput["noise"].get<bool>();
 
         // SPDLOG_LOGGER_DEBUG(m_logger, "{} 右声道噪音检测结果: {}", m_logBase, jsonOutput["silence_state"].dump(4));
-        // SPDLOG_LOGGER_DEBUG(m_logger, "{} 右声道噪音检测结果: {}", m_logBase, jsonOutput.dump(4));
+        SPDLOG_LOGGER_DEBUG(m_logger, "{} 右声道噪音检测结果: {}, silence_state: {}", m_logBase, isNoiseRight, jsonOutput["silence_state"].dump(4));
 
 
     }

Server/ThreadCalculate/NoiseDetectThread.h

@@ -92,10 +92,10 @@ private:
     /* ------------------------------------ 噪音检测的一些参数 ------------------------------------ */
     
 
-    /* 噪音检测动态库需要的参数 */
+    /* 噪音检测动态库需要的参数，这些是默认参数，实际启动后会从数据库中获取，就是 NoiseDetectParam_t 中的参数 */
     const std::vector<std::string> m_window_params = {"tukey", "0.25"};
     double m_sample_rate = 48000;                   /* 采样率 */
-    double m_silence_threshold = 3e-3;          /* 静音检测阈值 */
+    double m_silence_threshold = -60.0;          /* 静音检测阈值 */
     double m_db_threshold = -70.0;              /* 分贝阈值 */
     double m_cv_threshold = -70.0;              /* 变异系数阈值 */
     int m_nperseg = 256;                        /* 每段样本数 */

Server/ThreadManager/ThreadAlarmManager.cpp

@@ -70,6 +70,14 @@ void ThreadAlarmManager::addAlarmInfo(const std::list<AlarmInfo_t>& listAlarm)
 }
 
 
+/* 添加一致性报警信息，键为主通道信息，值为次通道信息 */
+void ThreadAlarmManager::addAlarmInfo(const AlarmInfo_t& mainAlarm, const AlarmInfo_t& subAlarm)
+{
+    std::lock_guard<std::mutex> lock(m_mutexListAlarmConsistency);
+    m_listAlarmConsistency.push_back(std::make_pair(mainAlarm, subAlarm));
+}
+
+
 /* 线程工作函数 */
 void ThreadAlarmManager::task()
 {
@@ -77,18 +85,13 @@ void ThreadAlarmManager::task()
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 每100毫秒执行一次
 
-        /* 检查列表是否有报警信息 */
         {
+            /* 普通的报警数据写入数据库 */
             std::lock_guard<std::mutex> lock(m_mutexListAlarm);
             if(m_listAlarm.empty())
             {
                 continue; // 如果没有报警信息，继续循环
             }
-
-            /* 处理报警信息，拼接报警文件字符串，拼接出报警文件 */
-
-
-            /* 写入数据库 */
             if(!m_fromWebAPI.insertAlarmInfo(m_listAlarm))
             {
                 SPDLOG_LOGGER_ERROR(m_logger, "写入报警信息失败");
@@ -97,6 +100,24 @@ void ThreadAlarmManager::task()
             m_listAlarm.clear();
         }
 
+        {
+            /* 写入一致性报警信息 */
+            std::lock_guard<std::mutex> lock(m_mutexListAlarmConsistency);
+            if(m_listAlarmConsistency.empty())
+            {
+                continue; // 如果没有一致性报警信息，继续循环
+            }
+            for(const auto& alarmPair : m_listAlarmConsistency)
+            {
+                if(!m_fromWebAPI.insertConsistencyAlarmInfo(alarmPair.first, alarmPair.second))
+                {
+                    SPDLOG_LOGGER_ERROR(m_logger, "写入一致性报警信息失败");
+                }
+            }
+            /* 清空报警信息 */
+            m_listAlarmConsistency.clear();
+        }
+
     }
 }
 

Server/ThreadManager/ThreadAlarmManager.h

@@ -62,6 +62,9 @@ public:
     void addAlarmInfo(const AlarmInfo_t& alarmInfo);
     void addAlarmInfo(const std::list<AlarmInfo_t>& listAlarm);
     
+    /* 添加一致性报警信息，键为主通道信息，值为次通道信息 */
+    void addAlarmInfo(const AlarmInfo_t& mainAlarm, const AlarmInfo_t& subAlarm);
+    
 
 private:
     /* 线程工作函数 */
@@ -83,11 +86,12 @@ private:
 
     /* 存储一般的报警信息 */
     std::mutex m_mutexListAlarm;                    /* 报警信息列表的互斥锁 */
-    std::list<AlarmInfo_t> m_listAlarm;                 /* 报警信息列表 */
+    std::list<AlarmInfo_t> m_listAlarm;             /* 报警信息列表 */
     
     /* 存储一致性报警信息 */
-    
-
+    std::mutex m_mutexListAlarmConsistency;         /* 一致性报警信息列表的互斥锁 */
+    /* 一致性报警信息列表，键是主通道信息，值是次通道信息 */
+    std::list<std::pair<AlarmInfo_t, AlarmInfo_t>> m_listAlarmConsistency;
 };
 
 

Server/ThreadRecord/CreateRecordFileThread.cpp

@@ -148,7 +148,8 @@ bool CreateRecordFileThread::startRecordAlarmFile(const AlarmInfo_t& alarmInfo)
                         alarmInfo.AlarmType, alarmInfo.StartTime};
     if(m_mapAlarmFile.find(key) != m_mapAlarmFile.end())
     {
-        SPDLOG_LOGGER_WARN(m_logger, "{} 已经在报警录制队列中，无法重复添加", m_logBase);
+        SPDLOG_LOGGER_WARN(m_logger, "{} 通道:{}, {}, 报警类型: {}, 已经在报警录制队列中，无法重复添加", m_logBase, 
+                                        alarmInfo.CompareItemID, alarmInfo.strCompareItemName, static_cast<int>(alarmInfo.AlarmType));
         return true;
     }
 
@@ -549,7 +550,7 @@ QString CreateRecordFileThread::generateAlarmFileName(const AlarmValue_t& value,
         }
         /* 生成文件名, 格式: Alarm_RoadNum_AlarmType_yyyyMMdd_hhmmss-yyyyMMdd_hhmmss.wav
            这里创建的录音文件只有开始日期，没有结束日期，等报警结束之后才会有结束日期 */
-        QString fileName = QString("Alarm_%1_%2_%3-.wav")
+        QString fileName = QString("Road%1_%2_%3-.wav")
             .arg(QString::number(value.itemRoadInfo.nCompareRoadNum))
             .arg(getAlarmTypeString(value.alarmType))
             .arg(value.startTime.toString("yyyyMMdd_hhmmss"));
@@ -693,7 +694,7 @@ void CreateRecordFileThread::createNewAlarmFile(AlarmValue_t& value, const std::
     /* 新的报警录音，生成文件名 */
     value.fileName = generateAlarmFileName(value, true);
     value.state = eRecordState::eAlarm_Recording; // 设置为录音状态
-    SPDLOG_LOGGER_DEBUG(m_logger, "{} 开始写入报警文件: {}", m_logBase, value.fileName.toStdString());
+    SPDLOG_LOGGER_INFO(m_logger, "{} 开始写入报警文件: {}", m_logBase, value.fileName.toStdString());
     
     /* 计算出报警开始位置在报警文件中的偏移，这个偏移值在设置结束的时候取出 */
     for(const auto& audioData : dataList)

SettingLibrary/Modules/Basic/compareitemdialog.cpp

@@ -5,6 +5,7 @@
 #include "UIStyleManager.h"
 #include "SoundCardData.h"
 #include "tipwidget.h"
+#include "commonFunc.h"
 
 #include <QIntValidator>
 
@@ -73,23 +74,23 @@ void CompareItemDialog::setDefaultParams(const CompareItemInfo_t& item)
     /* 设置对比项状态 */
     ui->checkBox_enable->setChecked(item.isEnable);
 
-    /* 设置静音检测参数 */
+    /* 设置静音检测参数，设置文本需要取绝对值 */
     ui->checkBoxMute->setChecked(item.paramMute.isEnable);
     ui->lineEditMuteLen->setText(QString::number(item.paramMute.nLen));
     ui->lineEditMuteSensibility->setText(QString::number(item.paramMute.nSensitivity));
-    ui->lineEditMuteThreshold->setText(QString::number(item.paramMute.threshold.nThreshold));
+    ui->lineEditMuteThreshold->setText(QString::number(std::abs(item.paramMute.threshold.nThreshold)));
 
     /* 设置过载检测参数 */
     ui->checkBoxOverload->setChecked(item.paramOverload.isEnable);
     ui->lineEditOverloadLen->setText(QString::number(item.paramOverload.nLen));
     ui->lineEditOverloadSensibility->setText(QString::number(item.paramOverload.nSensitivity));
-    ui->lineEditOverloadThreshold->setText(QString::number(item.paramOverload.threshold.nThreshold));
+    ui->lineEditOverloadThreshold->setText(QString::number(std::abs(item.paramOverload.threshold.nThreshold)));
 
     /* 设置反相检测参数 */
     ui->checkBoxPhase->setChecked(item.paramPhase.isEnable);
     ui->lineEditPhaseLen->setText(QString::number(item.paramPhase.nLen));
     ui->lineEditPhaseSensibility->setText(QString::number(item.paramPhase.nSensitivity));
-    ui->lineEditPhaseThreshold->setText(QString::number(item.paramPhase.threshold.dThreshold));
+    ui->lineEditPhaseThreshold->setText(QString::number(std::abs(item.paramPhase.threshold.dThreshold)));
 
     /* 先设置主通道和第二通道 */
     for(const auto& road : item.mapRoad)
@@ -254,6 +255,8 @@ void CompareItemDialog::setMOPEditable(EDBType type, bool editable)
 void CompareItemDialog::setDetectParamInputOnlyNumber()
 {
     // 静音参数，只允许输入1~1000的整数
+    // QRegularExpression rx1("-[4-8][0-9]");
+    // ui->lineEditMuteThreshold->setValidator(new QRegularExpressionValidator(rx1, this));
     ui->lineEditMuteThreshold->setValidator(new QIntValidator(40, 84, this));
     ui->lineEditMuteLen->setValidator(new QIntValidator(2, 90, this));
     ui->lineEditMuteSensibility->setValidator(new QIntValidator(22, 100, this));
@@ -263,8 +266,8 @@ void CompareItemDialog::setDetectParamInputOnlyNumber()
     ui->lineEditOverloadLen->setValidator(new QIntValidator(2, 90, this));
     ui->lineEditOverloadSensibility->setValidator(new QIntValidator(22, 100, this));
 
-    // 反相参数，阈值为浮点数，范围0.0~100.0
-    ui->lineEditPhaseThreshold->setValidator(new QDoubleValidator(0.0, 0.99, 2, this));
+    // 反相参数，阈值为浮点数，范围0.0~0.99
+    ui->lineEditPhaseThreshold->setValidator(new StrictDoubleValidator(0.0, 0.99, 3, this));
     ui->lineEditPhaseLen->setValidator(new QIntValidator(10, 90, this));
     ui->lineEditPhaseSensibility->setValidator(new QIntValidator(20, 99, this));
 
@@ -387,21 +390,21 @@ bool CompareItemDialog::getCompareRoadInfo(CompareItemInfo_t& compareItemInfo)
 /* 获取音频检测信息 */
 bool CompareItemDialog::getAudioDetectInfo(CompareItemInfo_t& compareItemInfo)
 {
-    /* 静音检测 */
+    /* 静音检测，注意阈值是负数，在输入框中是正数，这里需要转换一下 */
     compareItemInfo.paramMute.isEnable = ui->checkBoxMute->isChecked();
-    compareItemInfo.paramMute.threshold.nThreshold = ui->lineEditMuteThreshold->text().toULongLong();
+    compareItemInfo.paramMute.threshold.nThreshold = -ui->lineEditMuteThreshold->text().toULongLong();
     compareItemInfo.paramMute.nLen = ui->lineEditMuteLen->text().toInt();
     compareItemInfo.paramMute.nSensitivity = ui->lineEditMuteSensibility->text().toInt();
 
     /* 过载检测 */
     compareItemInfo.paramOverload.isEnable = ui->checkBoxOverload->isChecked();
-    compareItemInfo.paramOverload.threshold.nThreshold = ui->lineEditOverloadThreshold->text().toULongLong();
+    compareItemInfo.paramOverload.threshold.nThreshold = -ui->lineEditOverloadThreshold->text().toULongLong();
     compareItemInfo.paramOverload.nLen = ui->lineEditOverloadLen->text().toInt();
     compareItemInfo.paramOverload.nSensitivity = ui->lineEditOverloadSensibility->text().toInt();
 
     /* 反相检测 */
     compareItemInfo.paramPhase.isEnable = ui->checkBoxPhase->isChecked();
-    compareItemInfo.paramPhase.threshold.dThreshold = ui->lineEditPhaseThreshold->text().toDouble();
+    compareItemInfo.paramPhase.threshold.dThreshold = -ui->lineEditPhaseThreshold->text().toDouble();
     compareItemInfo.paramPhase.nLen = ui->lineEditPhaseLen->text().toInt();
     compareItemInfo.paramPhase.nSensitivity = ui->lineEditPhaseSensibility->text().toInt();
 

SettingLibrary/Modules/Basic/compareitemwidget.ui

@@ -488,7 +488,7 @@
              </rect>
             </property>
             <property name="text">
-             <string>(40~84)dBFS</string>
+             <string>(-84~-40)dBFS</string>
             </property>
            </widget>
            <widget class="QLabel" name="label_6">
@@ -664,7 +664,7 @@
              </rect>
             </property>
             <property name="text">
-             <string>(0~40)dBFS</string>
+             <string>(-40~0)dBFS</string>
             </property>
            </widget>
            <widget class="QLabel" name="label_16">

common/GlobalInfo/GlobalVariable.h

@@ -198,8 +198,8 @@ struct OneCompareItemRoadInfo_t
 /* 检测阈值，静音和过载是整数，反相是小数 */
 union Threshold_t
 {
-    uint64_t nThreshold;  /* 静音和过载的阈值 */
-    double dThreshold;    /* 反相的阈值 */
+    int64_t nThreshold;     /* 静音和过载的阈值 */
+    double dThreshold;      /* 反相的阈值 */
 };
 
 /**

common/Network/FromWebAPI.cpp

@@ -763,7 +763,61 @@ bool FromWebAPI::insertAlarmInfo(const std::list<AlarmInfo_t>& listAlarm)
         int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_BatchTransAction, strSend, strRet);
         if(ret != 0)
         {
-            SPDLOG_LOGGER_ERROR(m_logger, "删除对比项检测时段信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
+            SPDLOG_LOGGER_ERROR(m_logger, "写入报警数据失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
+            return false;
+        }
+    }nJsonCatch
+
+    return true;
+}
+
+
+
+/* 写入一致性报警信息，先写入主通道报警，获取返回的PKID，再写入次通道数据 */
+bool FromWebAPI::insertConsistencyAlarmInfo(const AlarmInfo_t& mainAlarm, const AlarmInfo_t& subAlarm)
+{
+    try
+    {
+        nJson json0;
+        json0["opName"] = "ACAS_InsertConsistencyAlarmInfo";
+        nJson json1;
+        json1["itemID1"] = mainAlarm.CompareItemID;
+        json1["itemName1"] = mainAlarm.strCompareItemName;
+        json1["alarmType1"] = static_cast<int>(mainAlarm.AlarmType);
+        json1["soundCardNum1"] = mainAlarm.RoadInfo.nCompareRoadNum;
+        json1["soundCardName1"] = mainAlarm.RoadInfo.strCompareRoadName.toStdString();
+        json1["soundCardRoadNum1"] = mainAlarm.RoadInfo.scRoadInfo.roadInfo.nRoadNum;
+        json1["compareRoadNum1"] = mainAlarm.RoadInfo.nCompareRoadNum;
+        json1["compareRoadName1"] = mainAlarm.RoadInfo.strCompareRoadName.toStdString();
+        json1["compareRoadType1"] = static_cast<int>(mainAlarm.RoadType);
+        json1["alarmStartTime1"] = mainAlarm.StartTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
+        json1["alarmEndTime1"] = mainAlarm.EndTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
+        json1["alarmDuration1"] = mainAlarm.StartTime.secsTo(mainAlarm.EndTime);
+        json1["alarmFilePath1"] = mainAlarm.strAlarmFilePath;
+        json1["fileAlarmStartPos1"] = mainAlarm.AlarmStartPos;
+
+        json1["itemID2"] = subAlarm.CompareItemID;
+        json1["itemName2"] = subAlarm.strCompareItemName;
+        json1["alarmType2"] = static_cast<int>(subAlarm.AlarmType);
+        json1["soundCardNum2"] = subAlarm.RoadInfo.nCompareRoadNum;
+        json1["soundCardName2"] = subAlarm.RoadInfo.strCompareRoadName.toStdString();
+        json1["soundCardRoadNum2"] = subAlarm.RoadInfo.scRoadInfo.roadInfo.nRoadNum;
+        json1["compareRoadNum2"] = subAlarm.RoadInfo.nCompareRoadNum;
+        json1["compareRoadName2"] = subAlarm.RoadInfo.strCompareRoadName.toStdString();
+        json1["compareRoadType2"] = static_cast<int>(subAlarm.RoadType);
+        json1["alarmStartTime2"] = subAlarm.StartTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
+        json1["alarmEndTime2"] = subAlarm.EndTime.toString("yyyy-MM-dd HH:mm:ss").toStdString();
+        json1["alarmDuration2"] = subAlarm.StartTime.secsTo(subAlarm.EndTime);
+        json1["alarmFilePath2"] = subAlarm.strAlarmFilePath;
+        json1["fileAlarmStartPos2"] = subAlarm.AlarmStartPos;
+
+        json0["paramList"] = json1;
+        QString strSend = QString::fromStdString(json0.dump());
+        QString strRet;
+        int ret = m_httpApi->DBDoInterface(enDBOperatorType::EDBOT_Insert, strSend, strRet);
+        if(ret != 0)
+        {
+            SPDLOG_LOGGER_ERROR(m_logger, "写入一致性报警信息失败: {}, {}", ret, m_httpApi->DoGetLastError(&ret).toStdString());
             return false;
         }
     }nJsonCatch

common/Network/FromWebAPI.h

@@ -53,6 +53,8 @@ public:
     /* ================================================================================== */
     /* 写入报警信息 */
     bool insertAlarmInfo(const std::list<AlarmInfo_t>& listAlarm);
+    /* 写入一致性报警信息，先写入主通道报警，获取返回的PKID，再写入次通道数据 */
+    bool insertConsistencyAlarmInfo(const AlarmInfo_t& mainAlarm, const AlarmInfo_t& subAlarm);
 
 private:
     std::shared_ptr<spdlog::logger> m_logger = nullptr;