V0.6.1

1、修改了每个眼图模块的数据方向

Common/warning/warning_dark.qss

@@ -27,7 +27,7 @@ QLabel#label_NC1
 
 QLabel#label_line
 {
-    background: #E6E9F4;
+    background: rgba(255,255,255,0.15);
 }
 
 QLabel#label_Warn

EyeMap/CMakeLists.txt

@@ -22,8 +22,8 @@ file(GLOB LOCAL_SRC
     ${CMAKE_CURRENT_SOURCE_DIR}/ParameterConfig/OneParamItem/*.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ParameterConfig/OneParamItem/*.ui
 
-    ${CMAKE_SOURCE_DIR}/*.cpp
-    ${CMAKE_SOURCE_DIR}/*.ui
+    # ${CMAKE_SOURCE_DIR}/*.cpp
+    # ${CMAKE_SOURCE_DIR}/*.ui
 
     ${CMAKE_SOURCE_DIR}/External/common/LHColorDialog/*.cpp
     ${CMAKE_SOURCE_DIR}/External/common/LHColorDialog/*.qrc

EyeMap/EyeMapWidget/eyemapwidget.cpp

@@ -75,7 +75,7 @@ EyeMapWidget::~EyeMapWidget()
 void EyeMapWidget::do_exit()
 {
     Warning warning;
-    warning.setText("是否退出？");
+    warning.setText("是否退出程序？");
     warning.exec();
     if(!warning.isOk())
     {
@@ -165,14 +165,6 @@ void EyeMapWidget::initEyeMap()
     m_column = GEyeMapInfo.column;
     eyeMapLayout();
 
-    /* 设置可用通道，实际需要根据连接到的示波器个数来设置 */
-    for(int i = 1; i <= 8; i++)
-    {
-        OneChannelInfo info;
-        info.channel = i;
-        info.channelName = "通道" + QString::number(i);
-        GEyeMapInfo.appendChannelInfo(info);
-    }
 }
 
 

EyeMap/GlobalInfo/EyeMapInfo.cpp

@@ -33,6 +33,14 @@ void AllEyeMapInfo::initEyeMapInfo()
     {
         readSaveFile(m_saveFileName);
     }
+    /* 设置可用通道，实际需要根据连接到的示波器个数来设置 */
+    for(int i = 1; i <= 8; i++)
+    {
+        OneChannelInfo info;
+        info.channel = i;
+        info.channelName = "通道" + QString::number(i);
+        GEyeMapInfo.appendChannelInfo(info);
+    }
 }
 
 /* 读取保存的文件 */

EyeMap/GlobalInfo/EyeMapInfo.h

@@ -4,10 +4,25 @@
 #include <QList>
 #include <QColor>
 #include "GlobalInfo.h"
+#include "OscDataInfo.h"
 
 
 class OneEyeMap;
 
+
+/* 示波器通道枚举值 */
+// enum class enum_OSCChannel
+// {
+//     Osc1_CHA = 1,
+//     Osc1_CHB,
+//     Osc2_CHA,
+//     Osc2_CHB,
+//     Osc3_CHA,
+//     Osc3_CHB,
+//     Osc4_CHA,
+//     Osc4_CHB,
+// };
+
 /* 保存实际可用的示波器通道信息
  * 通道号从1开始，0是未选择通道 */
 struct OneChannelInfo

EyeMap/GlobalInfo/GlobalInfo.cpp

@@ -1,255 +1,5 @@
 #include "GlobalInfo.h"
 
-/* OscData使用的眼图矩阵 */
-EyeDataMatrix g_eyeDataMatrix;
-/* OscWidget使用的眼图矩阵 */
-EyeMapMatrix g_eyeMapMatrix;
-
-
-
-
-
-void EyeDataMatrix::initEyeData()
-{
-    mutexEyeData.lock();
-    for(int i = 0; i < 1000; i++)
-    {
-        for(int j = 0; j < 256; j++)
-        {
-            dataMatrix[i][j].fCnt = 0.0;
-            dataMatrix[i][j].data = 0;
-            dataMatrix[i][j].Cnt = 0;
-        }
-    }
-    mutexEyeData.unlock();
-}
-
-
-/* 给一个采样点添加个数，为啥使用浮点数，添加0.99，不直接添加正数呢 */
-void EyeDataMatrix::addData(int x, int y) 
-{
-    if(dataMatrix[x][y].fCnt < 79999.0)
-    {
-        dataMatrix[x][y].fCnt += eyenWeightCoefficient;
-    }
-}
-
-/**
- * @brief 比重统计，点数大于79999的个数 比 点数大于0的个数的比重超过0.25，就开始减慢颜色变化的速度
- * 
- */
-void EyeDataMatrix::eyeStatisticalWeight()
-{
-    eyeIsLessenTheBurden = true;
-    if (eyenWeightCoefficient <= eyenWeightCoefficientMIN)
-    {
-        return;
-    }
-    int num = 0;            /* 点数大于0的个数 */
-    int num2 = 0;           /* 点数大于79999的个数 */
-    double num3 = 0.0;
-    int numMax = 79999;
-    for (int i = 0; i < 1000; i++)
-    {
-        for (int j = 0; j < 256; j++)
-        {
-            if (dataMatrix[i][j].fCnt > 0.0)
-            {
-                num++;
-                if (dataMatrix[i][j].fCnt >= (double)numMax)
-                {
-                    num2++;
-                }
-            }
-        }
-    }
-    if (num2 > 0)
-    {
-        num3 = (double)num2 / (double)num;
-    }
-    if (num3 >= 0.25)
-    {
-        eyeIsLessenTheBurden = false;
-    }
-}
-
-/**
- * @brief 眼图减慢颜色变化的速度
- * 
- */
-void EyeDataMatrix::eyeLessenTheBurden()
-{
-	if (eyeIsLessenTheBurden)
-	{
-		return;
-	}
-	int num = 0;
-	for (int i = 0; i < 1000; i++)
-	{
-		for (int j = 0; j < 256; j++)
-		{
-			if (dataMatrix[i][j].fCnt > 0.0)
-			{
-				num = (int)(dataMatrix[i][j].fCnt * 0.05);
-				dataMatrix[i][j].fCnt -= num;
-			}
-		}
-	}
-	eyenWeightCoefficient *= eyenWeightCoefficient;
-}
-
-
-std::shared_ptr<Vec2D> EyeDataMatrix::eyeZoomOut()
-{
-	std::shared_ptr<Vec2D> array = std::make_shared<Vec2D>(1000, std::vector<EyeDataSample>(256));
-	for (int i = 0; i < 1000; i++)
-	{
-		for (int j = 0; j < 256; j++)
-		{
-			EyeDataSample pEyeData2;
-			pEyeData2.x = dataMatrix[i][j].x;
-			pEyeData2.y = dataMatrix[i][j].y;
-			pEyeData2.fCnt = dataMatrix[i][j].fCnt;
-			pEyeData2.data = dataMatrix[i][j].data;
-			if (dataMatrix[i][j].fCnt > 0.0) {
-				pEyeData2.fCnt /= 100.0;
-				pEyeData2.Cnt = (int)pEyeData2.fCnt;
-			}
-			(*array)[i][j] = pEyeData2;
-		}
-	}
-	return array;
-}
-
-
-/* 初始化数据点 */
-void EyeMapMatrix::initEyeMapData(int width, int height)
-{
-    mutexEyeData.lock();
-    double saH = height / 256.0;
-    double saW = width / 1000.0;
-    for(int i = 0; i < 1000; i++)
-    {
-        for(int j = 0; j < 256; j++)
-        {
-            dataMatrix[i][j].x = (int)(i * saW);
-            dataMatrix[i][j].y = (int)(j * saH);
-            dataMatrix[i][j].rect = QRect(dataMatrix[i][j].x, dataMatrix[i][j].y, (int)saW, (int)saH);
-            dataMatrix[i][j].brush = QBrush(QColor(255, 255, 255));
-        }
-    }
-    mutexEyeData.unlock();
-}
-
-/* 拷贝数据到数组中 */
-void EyeMapMatrix::copyDataMatrix(Vec2D& data)
-{
-    for (int i = 0; i < 1000; i++)
-    {
-        for (int j = 0; j < 256; j++)
-        {
-            if (dataMatrix[i][j].Count != data[i][j].fCnt)
-            {
-                if (data[i][j].fCnt > 799.0)
-                {
-                    dataMatrix[i][j].Count = 799;
-                }
-                else
-                {
-                    dataMatrix[i][j].Count = data[i][j].fCnt;
-                }
-                dataMatrix[i][j].isDraw = true;
-            }
-        }
-    }
-}
-
-/* 将Count数值与颜色对应 */
-void EyeMapMatrix::addColorBySample()
-{
-    int r = 0;
-    int g = 0;
-    int b = 0;
-    double dec = 255 / 100.0;
-    for(int i = 0; i < 1000; i++)
-    {
-        for(int j = 0; j < 256; j++)
-        {
-            if(dataMatrix[i][j].isDraw == false)
-            {
-                continue;
-            }
-            if(dataMatrix[i][j].Count <= 0)
-            {
-                dataMatrix[i][j].Count = 0;
-                continue;
-            }
-            if(dataMatrix[i][j].Count > 799)
-            {
-                dataMatrix[i][j].Count = 799;
-            }
-            /* 1~100，RGB开始减G，往紫色方向走，为显示清楚，G直接从200开始减 */
-            if(dataMatrix[i][j].Count >= 1 && dataMatrix[i][j].Count <= 100)
-            {
-                r = 255;
-                g = 200 - dataMatrix[i][j].Count * 2;
-                b = 255;
-            }
-            /* 101~200，R0B开始减R，往蓝色方向走，这里开始100分成255份 */
-            else if(dataMatrix[i][j].Count >= 101 && dataMatrix[i][j].Count <= 200)
-            {
-                r = 255 - (dataMatrix[i][j].Count - 100) * dec;
-                g = 0;
-                b = 255;
-            }
-            /* 201~300，00B开始增加G，往青色方向走 */
-            else if (dataMatrix[i][j].Count >= 201 && dataMatrix[i][j].Count <= 300)
-            {
-                r = 0;
-                g = (dataMatrix[i][j].Count - 200) * dec;
-                b = 255;
-            }
-            /* 301~400，0GB开始减B，往绿色方向走 */
-            else if (dataMatrix[i][j].Count >= 301 && dataMatrix[i][j].Count <= 400)
-            {
-                r = 0;
-                g = 255;
-                b = 255 - (dataMatrix[i][j].Count - 300) * dec;
-            }
-            /* 401~500，0G0开始增加R，往黄色方向走 */
-            else if (dataMatrix[i][j].Count >= 401 && dataMatrix[i][j].Count <= 500)
-            {
-                r = (dataMatrix[i][j].Count - 400) * dec;
-                g = 255;
-                b = 0;
-            }
-            /* 501~600，RG0开始减G，往红色方向走 */
-            else if (dataMatrix[i][j].Count >= 501 && dataMatrix[i][j].Count <= 600)
-            {
-                r = 255;
-                g = 255 - (dataMatrix[i][j].Count - 500) * dec;
-                b = 0;
-            }
-            /* 601~700，R00开始减R，往黑色方向走 */
-            else if (dataMatrix[i][j].Count >= 601 && dataMatrix[i][j].Count <= 700)
-            {
-                r = 255 - (dataMatrix[i][j].Count - 600) * dec;
-                g = 0;
-                b = 0;
-            }
-            /* 大于700，直接显示黑色 */
-            else
-            {
-                r = 0;
-                g = 0;
-                b = 0;
-            }
-            // dataMatrix[i][j].color = QColor(r, g, b);
-            dataMatrix[i][j].brush = QBrush(QColor(r, g, b));
-        }
-    }
-}
-
 /*********************** 全局配置 ************************/
 GlobalConfig::~GlobalConfig()
 {

EyeMap/GlobalInfo/GlobalInfo.h

@@ -1,244 +1,13 @@
 #ifndef GLOBALINFO_H
 #define GLOBALINFO_H
 
-#include <mutex>
-#include <vector>
-#include <QRect>
-#include <QColor>
-#include <QBrush>
 
-#include "nlohmann/json.hpp"
-#define nJson nlohmann::json
-
-
-/* 示波器通道 */
-enum class OscChannel
-{
-    CH_A = 0,
-    CH_B,
-};
-
-/* 示波器通道耦合方式 */
-enum class OscChannelCoupling
-{
-    AC = 0,
-    DC,
-};
 
-/* 示波器采样率，目前就只要这些 */
-enum class OscSampleRate
-{
-    SR_49KHZ = 0,
-    SR_96KHZ,
-    SR_781KHZ,
-    SR_12_5MHZ,
-    SR_100MHZ,
-};
-
-/* 示波器通道的输入档位 */
-// enum class OscVoltageRange
-enum class OscVoltageRange
-{
-    CR_100MV = 0,
-    CR_250MV,
-    CR_500MV,
-    CR_1V,
-    CR_2V5,
-    CR_5V,
-    CR_8V,
-};
-
-/* 触发方式 */
-enum class OscTriggerMode
-{
-    TM_RISE = 0,    /* 上升沿触发 */
-    TM_DOWN,        /* 下降沿触发 */
-    TM_DOUBLE,      /* 双边沿触发 */
-};
 
-/* 触发灵敏度 */
-enum class OscTriggerSensitivity
-{
-    TS_LOW = 0,     /* 低灵敏度 */
-    TS_HIGH,        /* 高灵敏度 */
-};
-
-/* 一个格子的时间刻度值单位 */
-enum class OscTimeGridValue
-{
-    TGV_20NS = 20,          /* 0.02us */
-    TGV_50NS = 50,          /* 0.05us */
-    TGV_100NS = 100,        /* 0.1us */
-    TGV_200NS = 200,        /* 0.2us */
-    TGV_500NS = 500,        /* 0.5us */
-    TGV_1US = 1000,         /* 1us */
-    TGV_2US = 2000,         /* 2us */
-    TGV_5US = 5000,         /* 5us */
-    TGV_10US = 10000,       /* 10us */
-    TGV_20US = 20000,       /* 20us */
-    TGV_100US = 100000,     /* 100us */
-};
-
-
-struct EyeDataT
-{
-    bool isEyeData;
-    unsigned char value;
-    EyeDataT() : isEyeData(false), value(0) {}
-    EyeDataT(bool isOpen, unsigned char val) : isEyeData(isOpen), value(val) {}
-    EyeDataT& operator=(const EyeDataT& data)
-    {
-        isEyeData = data.isEyeData;
-        value = data.value;
-        return *this;
-    }
-};
-
-/* 眼图数据点 */
-struct EyeDataSample
-{
-    int x;              /* X坐标？ */
-    int y;              /* Y坐标？ */
-    double fCnt;        /* 颜色深浅？ */
-    int Cnt;            /*  */
-    unsigned char data;
-
-    EyeDataSample() : x(0), y(0), fCnt(0.0), Cnt(0), data(0) {}
-    EyeDataSample(int x, int y, double fCnt, int Cnt, unsigned char data) 
-        : x(x), y(y), fCnt(fCnt), Cnt(Cnt), data(data) {}
-    EyeDataSample& operator=(const EyeDataSample& data)
-    {
-        x = data.x;
-        y = data.y;
-        fCnt = data.fCnt;
-        Cnt = data.Cnt;
-        this->data = data.data;
-        return *this;
-    }
-};
-
-/* 类型重命名 */
-using Vec2D = std::vector<std::vector<EyeDataSample>>;
-/**
- * @brief 眼图数据
- * 
- */
-class EyeDataMatrix
-{   
-
-public:
-    EyeDataMatrix() : dataMatrix(1000, std::vector<EyeDataSample>(256)) {}
-    ~EyeDataMatrix() {}
-
-    Vec2D dataMatrix;
-    // EyeDataSample dataMatrix[1000][256];
-    std::mutex mutexEyeData;
-    
-    void initEyeData();
-    void addData(int x, int y);
-    void eyeStatisticalWeight();
-    void eyeLessenTheBurden();
-    std::shared_ptr<Vec2D> eyeZoomOut();
-
-private:
-    double eyenWeightCoefficient = 0.99;
-    bool eyeIsLessenTheBurden = true;
-    double eyenWeightCoefficientMIN = 1E-06;
-};
-extern EyeDataMatrix g_eyeDataMatrix;
-
-
-/**
- * @brief 绘制到窗口的眼图数据
- *        总共有1000 * 245个数据点充满屏幕，每个数据点是个矩形
- *        每个数据点的颜色深浅由fCnt决定，该点的数据越多，像素颜色越深
- * 
- */
-struct EyeMapDataSample
-{
-    bool isDraw;    /* 是否绘制 */
-    int x;
-    int y;
-    int Count;      /* 像素点的个数（颜色深度），这里限制为799，不知道为什么 */
-    unsigned char data;     /* 数据值 */
-    QRect rect;     /* 像素点的矩形区域 */
-    // QColor color;   /* 颜色 */
-    QBrush brush;   /* 颜色 */
-
-    // EyeMapDataSample() : isDraw(false), x(0), y(0), Count(0), data(0), color(255, 255, 255) {}
-    EyeMapDataSample() : isDraw(false), x(0), y(0), Count(0), data(0) {}
-    EyeMapDataSample(EyeDataSample& data) : isDraw(false), x(data.x), y(data.y), Count(data.Cnt), data(data.data) {}
-    EyeMapDataSample& operator=(const EyeMapDataSample& other) {
-        x = other.x;
-        y = other.y;
-        Count = other.Count;
-        isDraw = other.isDraw;
-        rect = other.rect;
-        data = other.data;
-        brush = other.brush;
-        return *this;
-    }
-};
-
-using Vec2DMap = std::vector<std::vector<EyeMapDataSample>>;
-/**
- * @brief 眼图数据矩阵
- * 
- */
-class EyeMapMatrix
-{
-public:
-    EyeMapMatrix() : dataMatrix(1000, std::vector<EyeMapDataSample>(256)) {}
-    ~EyeMapMatrix() {}
-
-    Vec2DMap dataMatrix;
-    std::mutex mutexEyeData;
-    /* 初始化数据点 */
-    void initEyeMapData(int width, int height);
-    /* 拷贝数据到数组中 */
-    void copyDataMatrix(Vec2D& data);
-    /* 将Count数值与颜色对应 */
-    void addColorBySample();
-};
-extern EyeMapMatrix g_eyeMapMatrix;
-
-
-
-#define OscParams OscilloscopeParameters::getInstance()
-/**
- * @brief 示波器全局设置，这是个单例类
- * 
- */
-class OscilloscopeParameters
-{
-private:
-    OscilloscopeParameters() {}
-    OscilloscopeParameters(const OscilloscopeParameters&) = delete;
-    OscilloscopeParameters& operator=(const OscilloscopeParameters&) = delete;
-public:
-    ~OscilloscopeParameters() {}
-    static OscilloscopeParameters& getInstance()
-    {
-        static OscilloscopeParameters instance;
-        return instance;
-    }
-
-    /* 示波器相关参数 */
-    // int OscCurrentTimeScale = 100;  /* 时间尺度，不知道啥意思，可能和采样率有关 */
-    // int OscOneGridTime = 1000;      /* 每格子的时间（单位ns） */
-
-    // int TimeGridNum = 10;           /* 10个时间格子 */
-    // int VolatileGridNum = 10;       /* 10个电压格子 */
-    int oneGridTime = 200;          /* 一个时间格子的时间长度（单位ns） */
-
-    double SampleIntervalTime = 0;     /* 采样点之间的时间间隔，单位ns（采样率的倒数，设置采样率的时候会设置） */
+#include "nlohmann/json.hpp"
+#define nJson nlohmann::json
 
-    /* 其他参数 */
-    const int dataNumPerPixar = 1;  /* 这个是SetInfo的第一个参数，固定是1，在眼图中会使用 */
 
-    /* 眼图参数 */
-    int eyeMapWidth = 1000;         /* 眼图x轴宽度（像素矩形的个数） */
-};
 
 
 

EyeMap/GlobalInfo/OscDataInfo.cpp

@@ -0,0 +1,303 @@
+#include "OscDataInfo.h"
+
+#include "EyeMapInfo.h"
+
+
+
+/* OscData使用的眼图矩阵 */
+EyeDataMatrix g_eyeDataMatrix;
+/* OscWidget使用的眼图矩阵 */
+EyeMapMatrix g_eyeMapMatrix;
+
+
+
+
+
+void EyeDataMatrix::initEyeData()
+{
+    mutexEyeData.lock();
+    dataMatrix.clear();
+
+    for(int i = 0; i < 1000; i++)
+    {
+        for(int j = 0; j < 256; j++)
+        {
+            dataMatrix[i][j].fCnt = 0.0;
+            dataMatrix[i][j].data = 0;
+            dataMatrix[i][j].Cnt = 0;
+        }
+    }
+    mutexEyeData.unlock();
+}
+
+
+/* 给一个采样点添加个数，为啥使用浮点数，添加0.99，不直接添加正数呢 */
+void EyeDataMatrix::addData(int x, int y) 
+{
+    if(dataMatrix[x][y].fCnt < 79999.0)
+    {
+        dataMatrix[x][y].fCnt += eyenWeightCoefficient;
+    }
+}
+
+/**
+ * @brief 比重统计，点数大于79999的个数 比 点数大于0的个数的比重超过0.25，就开始减慢颜色变化的速度
+ * 
+ */
+void EyeDataMatrix::eyeStatisticalWeight()
+{
+    eyeIsLessenTheBurden = true;
+    if (eyenWeightCoefficient <= eyenWeightCoefficientMIN)
+    {
+        return;
+    }
+    int num = 0;            /* 点数大于0的个数 */
+    int num2 = 0;           /* 点数大于79999的个数 */
+    double num3 = 0.0;
+    int numMax = 79999;
+    for (int i = 0; i < 1000; i++)
+    {
+        for (int j = 0; j < 256; j++)
+        {
+            if (dataMatrix[i][j].fCnt > 0.0)
+            {
+                num++;
+                if (dataMatrix[i][j].fCnt >= (double)numMax)
+                {
+                    num2++;
+                }
+            }
+        }
+    }
+    if (num2 > 0)
+    {
+        num3 = (double)num2 / (double)num;
+    }
+    if (num3 >= 0.25)
+    {
+        eyeIsLessenTheBurden = false;
+    }
+}
+
+/**
+ * @brief 眼图减慢颜色变化的速度
+ * 
+ */
+void EyeDataMatrix::eyeLessenTheBurden()
+{
+	if (eyeIsLessenTheBurden)
+	{
+		return;
+	}
+	int num = 0;
+	for (int i = 0; i < 1000; i++)
+	{
+		for (int j = 0; j < 256; j++)
+		{
+			if (dataMatrix[i][j].fCnt > 0.0)
+			{
+				num = (int)(dataMatrix[i][j].fCnt * 0.05);
+				dataMatrix[i][j].fCnt -= num;
+			}
+		}
+	}
+	eyenWeightCoefficient *= eyenWeightCoefficient;
+}
+
+
+std::shared_ptr<Vec2D> EyeDataMatrix::eyeZoomOut()
+{
+	std::shared_ptr<Vec2D> array = std::make_shared<Vec2D>(1000, std::vector<EyeDataSample>(256));
+	for (int i = 0; i < 1000; i++)
+	{
+		for (int j = 0; j < 256; j++)
+		{
+			EyeDataSample pEyeData2;
+			pEyeData2.x = dataMatrix[i][j].x;
+			pEyeData2.y = dataMatrix[i][j].y;
+			pEyeData2.fCnt = dataMatrix[i][j].fCnt;
+			pEyeData2.data = dataMatrix[i][j].data;
+			if (dataMatrix[i][j].fCnt > 0.0) {
+				pEyeData2.fCnt /= 100.0;
+				pEyeData2.Cnt = (int)pEyeData2.fCnt;
+			}
+			(*array)[i][j] = pEyeData2;
+		}
+	}
+	return array;
+}
+
+
+/* 初始化数据点 */
+void EyeMapMatrix::initEyeMapData(int width, int height)
+{
+    mutexEyeData.lock();
+    /*先清空 */
+    dataMatrix.clear();
+
+    double saH = height / 256.0;
+    double saW = width / 1000.0;
+    for(int i = 0; i < 1000; i++)
+    {
+        for(int j = 0; j < 256; j++)
+        {
+            dataMatrix[i][j].x = (int)(i * saW);
+            dataMatrix[i][j].y = (int)(j * saH);
+            dataMatrix[i][j].rect = QRect(dataMatrix[i][j].x, dataMatrix[i][j].y, (int)saW, (int)saH);
+            dataMatrix[i][j].brush = QBrush(QColor(255, 255, 255));
+        }
+    }
+    mutexEyeData.unlock();
+}
+
+/* 拷贝数据到数组中 */
+void EyeMapMatrix::copyDataMatrix(Vec2D& data)
+{
+    for (int i = 0; i < 1000; i++)
+    {
+        for (int j = 0; j < 256; j++)
+        {
+            if (dataMatrix[i][j].Count != data[i][j].fCnt)
+            {
+                if (data[i][j].fCnt > 799.0)
+                {
+                    dataMatrix[i][j].Count = 799;
+                }
+                else
+                {
+                    dataMatrix[i][j].Count = data[i][j].fCnt;
+                }
+                dataMatrix[i][j].isDraw = true;
+            }
+        }
+    }
+}
+
+/* 将Count数值与颜色对应 */
+void EyeMapMatrix::addColorBySample()
+{
+    int r = 0;
+    int g = 0;
+    int b = 0;
+    double dec = 255 / 100.0;
+    for(int i = 0; i < 1000; i++)
+    {
+        for(int j = 0; j < 256; j++)
+        {
+            if(dataMatrix[i][j].isDraw == false)
+            {
+                continue;
+            }
+            if(dataMatrix[i][j].Count <= 0)
+            {
+                dataMatrix[i][j].Count = 0;
+                continue;
+            }
+            if(dataMatrix[i][j].Count > 799)
+            {
+                dataMatrix[i][j].Count = 799;
+            }
+            /* 1~100，RGB开始减G，往紫色方向走，为显示清楚，G直接从200开始减 */
+            if(dataMatrix[i][j].Count >= 1 && dataMatrix[i][j].Count <= 100)
+            {
+                r = 255;
+                g = 200 - dataMatrix[i][j].Count * 2;
+                b = 255;
+            }
+            /* 101~200，R0B开始减R，往蓝色方向走，这里开始100分成255份 */
+            else if(dataMatrix[i][j].Count >= 101 && dataMatrix[i][j].Count <= 200)
+            {
+                r = 255 - (dataMatrix[i][j].Count - 100) * dec;
+                g = 0;
+                b = 255;
+            }
+            /* 201~300，00B开始增加G，往青色方向走 */
+            else if (dataMatrix[i][j].Count >= 201 && dataMatrix[i][j].Count <= 300)
+            {
+                r = 0;
+                g = (dataMatrix[i][j].Count - 200) * dec;
+                b = 255;
+            }
+            /* 301~400，0GB开始减B，往绿色方向走 */
+            else if (dataMatrix[i][j].Count >= 301 && dataMatrix[i][j].Count <= 400)
+            {
+                r = 0;
+                g = 255;
+                b = 255 - (dataMatrix[i][j].Count - 300) * dec;
+            }
+            /* 401~500，0G0开始增加R，往黄色方向走 */
+            else if (dataMatrix[i][j].Count >= 401 && dataMatrix[i][j].Count <= 500)
+            {
+                r = (dataMatrix[i][j].Count - 400) * dec;
+                g = 255;
+                b = 0;
+            }
+            /* 501~600，RG0开始减G，往红色方向走 */
+            else if (dataMatrix[i][j].Count >= 501 && dataMatrix[i][j].Count <= 600)
+            {
+                r = 255;
+                g = 255 - (dataMatrix[i][j].Count - 500) * dec;
+                b = 0;
+            }
+            /* 601~700，R00开始减R，往黑色方向走 */
+            else if (dataMatrix[i][j].Count >= 601 && dataMatrix[i][j].Count <= 700)
+            {
+                r = 255 - (dataMatrix[i][j].Count - 600) * dec;
+                g = 0;
+                b = 0;
+            }
+            /* 大于700，直接显示黑色 */
+            else
+            {
+                r = 0;
+                g = 0;
+                b = 0;
+            }
+            // dataMatrix[i][j].color = QColor(r, g, b);
+            dataMatrix[i][j].brush = QBrush(QColor(r, g, b));
+        }
+    }
+}
+
+
+
+/* 初始化示波器参数 */
+void OscilloscopeData::initOscData()
+{
+
+    /* 创建数据矩阵，根据实际的通道个数来创建 */
+    auto listChn = GEyeMapInfo.getChannelInfo();
+    for(auto chn : listChn)
+    {
+        EyeDataMatrix* pEyeDataMatrix = new EyeDataMatrix();
+        pEyeDataMatrix->initEyeData();
+        mapEyeDataMatrix[chn.channel] = pEyeDataMatrix;
+
+        EyeMapMatrix* pEyeMapMatrix = new EyeMapMatrix();
+        pEyeMapMatrix->initEyeMapData(1000, 256);
+        mapEyeMapMatrix[chn.channel] = pEyeMapMatrix;
+    }
+}
+
+/* 查找EyeDataMatrix */
+EyeDataMatrix* OscilloscopeData::findEyeDataMatrix(int channel)
+{
+    auto it = mapEyeDataMatrix.find(channel);
+    if(it != mapEyeDataMatrix.end())
+    {
+        return it.value();
+    }
+    return nullptr;
+}
+
+/* 查找EyeMapMatrix */
+EyeMapMatrix* OscilloscopeData::findEyeMapMatrix(int channel)
+{
+    auto it = mapEyeMapMatrix.find(channel);
+    if(it != mapEyeMapMatrix.end())
+    {
+        return it.value();
+    }
+    return nullptr;
+}
+

EyeMap/GlobalInfo/OscDataInfo.h

@@ -0,0 +1,282 @@
+#ifndef _OSCDATAINFO_H_
+#define _OSCDATAINFO_H_
+
+#include <mutex>
+#include <vector>
+#include <QRect>
+#include <QColor>
+#include <QBrush>
+#include <QMap>
+
+
+/* 示波器通道 */
+enum class OscChannel
+{
+    CH_A = 0,
+    CH_B,
+};
+
+/* 示波器通道耦合方式 */
+enum class OscChannelCoupling
+{
+    AC = 0,
+    DC,
+};
+
+/* 示波器采样率，目前就只要这些 */
+enum class OscSampleRate
+{
+    SR_49KHZ = 0,
+    SR_96KHZ,
+    SR_781KHZ,
+    SR_12_5MHZ,
+    SR_100MHZ,
+};
+
+/* 示波器通道的输入档位 */
+// enum class OscVoltageRange
+enum class OscVoltageRange
+{
+    CR_100MV = 0,
+    CR_250MV,
+    CR_500MV,
+    CR_1V,
+    CR_2V5,
+    CR_5V,
+    CR_8V,
+};
+
+/* 触发方式 */
+enum class OscTriggerMode
+{
+    TM_RISE = 0,    /* 上升沿触发 */
+    TM_DOWN,        /* 下降沿触发 */
+    TM_DOUBLE,      /* 双边沿触发 */
+};
+
+/* 触发灵敏度 */
+enum class OscTriggerSensitivity
+{
+    TS_LOW = 0,     /* 低灵敏度 */
+    TS_HIGH,        /* 高灵敏度 */
+};
+
+/* 一个格子的时间刻度值单位 */
+enum class OscTimeGridValue
+{
+    TGV_20NS = 20,          /* 0.02us */
+    TGV_50NS = 50,          /* 0.05us */
+    TGV_100NS = 100,        /* 0.1us */
+    TGV_200NS = 200,        /* 0.2us */
+    TGV_500NS = 500,        /* 0.5us */
+    TGV_1US = 1000,         /* 1us */
+    TGV_2US = 2000,         /* 2us */
+    TGV_5US = 5000,         /* 5us */
+    TGV_10US = 10000,       /* 10us */
+    TGV_20US = 20000,       /* 20us */
+    TGV_100US = 100000,     /* 100us */
+};
+
+
+struct EyeDataT
+{
+    bool isEyeData;
+    unsigned char value;
+    EyeDataT() : isEyeData(false), value(0) {}
+    EyeDataT(bool isOpen, unsigned char val) : isEyeData(isOpen), value(val) {}
+    EyeDataT& operator=(const EyeDataT& data)
+    {
+        isEyeData = data.isEyeData;
+        value = data.value;
+        return *this;
+    }
+};
+
+/* 眼图数据点 */
+struct EyeDataSample
+{
+    int x;              /* X坐标？ */
+    int y;              /* Y坐标？ */
+    double fCnt;        /* 颜色深浅？ */
+    int Cnt;            /*  */
+    unsigned char data;
+
+    EyeDataSample() : x(0), y(0), fCnt(0.0), Cnt(0), data(0) {}
+    EyeDataSample(int x, int y, double fCnt, int Cnt, unsigned char data) 
+        : x(x), y(y), fCnt(fCnt), Cnt(Cnt), data(data) {}
+    EyeDataSample& operator=(const EyeDataSample& data)
+    {
+        x = data.x;
+        y = data.y;
+        fCnt = data.fCnt;
+        Cnt = data.Cnt;
+        this->data = data.data;
+        return *this;
+    }
+};
+
+/* 类型重命名 */
+using Vec2D = std::vector<std::vector<EyeDataSample>>;
+/**
+ * @brief 眼图数据
+ * 
+ */
+class EyeDataMatrix
+{   
+
+public:
+    EyeDataMatrix() : dataMatrix(1000, std::vector<EyeDataSample>(256)) {}
+    ~EyeDataMatrix() {}
+
+    Vec2D dataMatrix;
+    // EyeDataSample dataMatrix[1000][256];
+    std::mutex mutexEyeData;
+    
+    void initEyeData();
+    void addData(int x, int y);
+    void eyeStatisticalWeight();
+    void eyeLessenTheBurden();
+    std::shared_ptr<Vec2D> eyeZoomOut();
+
+private:
+    double eyenWeightCoefficient = 0.99;
+    bool eyeIsLessenTheBurden = true;
+    double eyenWeightCoefficientMIN = 1E-06;
+};
+// extern EyeDataMatrix g_eyeDataMatrix;
+
+
+/**
+ * @brief 绘制到窗口的眼图数据
+ *        总共有1000 * 245个数据点充满屏幕，每个数据点是个矩形
+ *        每个数据点的颜色深浅由fCnt决定，该点的数据越多，像素颜色越深
+ * 
+ */
+struct EyeMapDataSample
+{
+    bool isDraw;    /* 是否绘制 */
+    int x;
+    int y;
+    int Count;      /* 像素点的个数（颜色深度），这里限制为799，不知道为什么 */
+    unsigned char data;     /* 数据值 */
+    QRect rect;     /* 像素点的矩形区域 */
+    // QColor color;   /* 颜色 */
+    QBrush brush;   /* 颜色 */
+
+    // EyeMapDataSample() : isDraw(false), x(0), y(0), Count(0), data(0), color(255, 255, 255) {}
+    EyeMapDataSample() : isDraw(false), x(0), y(0), Count(0), data(0) {}
+    EyeMapDataSample(EyeDataSample& data) : isDraw(false), x(data.x), y(data.y), Count(data.Cnt), data(data.data) {}
+    EyeMapDataSample& operator=(const EyeMapDataSample& other) {
+        x = other.x;
+        y = other.y;
+        Count = other.Count;
+        isDraw = other.isDraw;
+        rect = other.rect;
+        data = other.data;
+        brush = other.brush;
+        return *this;
+    }
+};
+
+using Vec2DMap = std::vector<std::vector<EyeMapDataSample>>;
+/**
+ * @brief 眼图数据矩阵
+ * 
+ */
+class EyeMapMatrix
+{
+public:
+    EyeMapMatrix() : dataMatrix(1000, std::vector<EyeMapDataSample>(256)) {}
+    ~EyeMapMatrix() {}
+
+    Vec2DMap dataMatrix;
+    std::mutex mutexEyeData;
+    /* 初始化数据点 */
+    void initEyeMapData(int width, int height);
+    /* 拷贝数据到数组中 */
+    void copyDataMatrix(Vec2D& data);
+    /* 将Count数值与颜色对应 */
+    void addColorBySample();
+};
+// extern EyeMapMatrix g_eyeMapMatrix;
+
+
+
+#define OscParams OscilloscopeParameters::getInstance()
+/**
+ * @brief 示波器全局设置，也包含这所有通道的数据指针
+ *      单例模式
+ * 
+ */
+class OscilloscopeParameters
+{
+private:
+    OscilloscopeParameters() {}
+    OscilloscopeParameters(const OscilloscopeParameters&) = delete;
+    OscilloscopeParameters& operator=(const OscilloscopeParameters&) = delete;
+public:
+    ~OscilloscopeParameters() {}
+    static OscilloscopeParameters& getInstance()
+    {
+        static OscilloscopeParameters instance;
+        return instance;
+    }
+
+    /* 示波器相关参数 */
+    int oneGridTime = 200;          /* 一个时间格子的时间长度（单位ns） */
+    double SampleIntervalTime = 0;     /* 采样点之间的时间间隔，单位ns（采样率的倒数，设置采样率的时候会设置） */
+
+    /* 其他参数 */
+    const int dataNumPerPixar = 1;  /* 这个是SetInfo的第一个参数，固定是1，在眼图中会使用 */
+    /* 眼图参数 */
+    int eyeMapWidth = 1000;         /* 眼图x轴宽度（像素矩形的个数） */
+
+    
+
+public:
+    
+
+};
+
+
+
+/**
+ * @brief 示波器全局数据
+ * 
+ */
+
+#define OscDataInfo OscilloscopeData::getInstance()
+class OscilloscopeData
+{
+    OscilloscopeData() {}
+    OscilloscopeData(const OscilloscopeData&) = delete;
+    OscilloscopeData& operator=(const OscilloscopeData&) = delete;
+public:
+    ~OscilloscopeData() {}
+
+    static OscilloscopeData& getInstance()
+    {
+        static OscilloscopeData instance;
+        return instance;
+    }
+
+    /* 初始化示波器参数 */
+    void initOscData();
+
+    /* 查找EyeDataMatrix */
+    EyeDataMatrix* findEyeDataMatrix(int channel);
+    /* 查找EyeMapMatrix */
+    EyeMapMatrix* findEyeMapMatrix(int channel);
+
+private:
+    /************ 数据相关 ************/
+    /* 眼图数据矩阵 */
+    QMap<int, EyeDataMatrix*> mapEyeDataMatrix;
+    /* 眼图颜色矩阵 */
+    QMap<int, EyeMapMatrix*> mapEyeMapMatrix;
+
+};
+
+
+
+#endif /* _OSCDATAINFO_H_ */

EyeMap/OneEyeMap/OneEyeMap.cpp

@@ -5,6 +5,9 @@
 #include <QPainter>
 #include <QPaintEvent>
 
+#include "GlobalInfo.h"
+
+
 OneEyeMap::OneEyeMap(QWidget *parent) :
     QWidget(parent),
     ui(new Ui::OneEyeMap)
@@ -53,7 +56,7 @@ OneEyeMap::OneEyeMap(QWidget *parent) :
     m_rectEyeMap.setHeight(m_rectScaleValue.height() - m_topMargin - m_bottomMargin);
 
     /* 初始化全局数据 */
-    g_eyeMapMatrix.initEyeMapData(this->width(), this->height());
+    
     /* 设置定时器 */
     m_timer.setTimerType(Qt::PreciseTimer);
     m_timer.setSingleShot(false);
@@ -72,6 +75,19 @@ OneEyeMap::~OneEyeMap()
     delete ui;
 }
 
+/* 根据通道号获取数据指针 */
+void OneEyeMap::getEyeDataPtrFromOscData(int channel)
+{
+    m_eyeMapMatrix = OscDataInfo.findEyeMapMatrix(channel);
+    if(m_eyeMapMatrix == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "获取颜色矩阵错误! 通道号: {}", channel);
+        return;
+    }
+    m_eyeMapMatrix->initEyeMapData(this->width(), this->height());
+}
+
+
 /* 设置标题 */
 void OneEyeMap::setTitle(const QString &title)
 {
@@ -142,7 +158,7 @@ void OneEyeMap::do_update()
  */
 void OneEyeMap::paintEvent(QPaintEvent *event)
 {
-    g_eyeMapMatrix.mutexEyeData.lock();
+    m_eyeMapMatrix->mutexEyeData.lock();
     QPainter painter(this);
     
     painter.setRenderHint(QPainter::Antialiasing, true);
@@ -159,23 +175,10 @@ void OneEyeMap::paintEvent(QPaintEvent *event)
     // SPDLOG_LOGGER_DEBUG(m_logger, "width = {}, height = {}", this->width(), this->height());
     // SPDLOG_LOGGER_DEBUG(m_logger, "m_rectScaleValue: x = {}, y = {}, width = {}, height = {}", m_rectScaleValue.x(), m_rectScaleValue.y(), m_rectScaleValue.width(), m_rectScaleValue.height());
     // SPDLOG_LOGGER_DEBUG(m_logger, "m_rectEyeMap: x = {}, y = {}, width = {}, height = {}", m_rectEyeMap.x(), m_rectEyeMap.y(), m_rectEyeMap.width(), m_rectEyeMap.height());
-    
-    /* 绘制眼图，就是绘制 1000 * 256 个矩形 */
-    // painter.setPen(QPen(Qt::NoPen));
-    // for(int i = 0; i < 1000; i++)
-    // {
-    //     for(int j = 0; j < 256; j++)
-    //     {
-    //         if(g_eyeMapMatrix.dataMatrix[i][j].isDraw == false)
-    //         {
-    //             continue;
-    //         }
-    //         // painter.setBrush(QBrush(g_eyeMapMatrix.dataMatrix[i][j].color));
-    //         painter.setBrush(g_eyeMapMatrix.dataMatrix[i][j].brush);
-    //         painter.drawRect(g_eyeMapMatrix.dataMatrix[i][j].rect);
-    //     }
-    // }
-    g_eyeMapMatrix.mutexEyeData.unlock();
+    /******************** 绘制眼图区域 ********************/
+    drawEyeMap(painter);
+
+    m_eyeMapMatrix->mutexEyeData.unlock();
 
     event->accept();
 }
@@ -355,7 +358,21 @@ void OneEyeMap::drawScale(QPainter &painter)
 /* 绘制眼图区域 */
 void OneEyeMap::drawEyeMap(QPainter &painter)
 {
-
+    /* 绘制眼图，就是绘制 1000 * 256 个矩形 */
+    painter.setPen(Qt::NoPen);
+    for(int i = 0; i < 1000; i++)
+    {
+        for(int j = 0; j < 256; j++)
+        {
+            if(m_eyeMapMatrix->dataMatrix[i][j].isDraw == false)
+            {
+                continue;
+            }
+            // painter.setBrush(QBrush(g_eyeMapMatrix.dataMatrix[i][j].color));
+            painter.setBrush(m_eyeMapMatrix->dataMatrix[i][j].brush);
+            painter.drawRect(m_eyeMapMatrix->dataMatrix[i][j].rect);
+        }
+    }
 }
 
 /* 获取一个格子的电压值 */

EyeMap/OneEyeMap/OneEyeMap.h

@@ -7,8 +7,6 @@
 
 #include "spdlog/spdlog.h"
 
-#include "OscData.h"
-#include "GlobalInfo.h"
 #include "EyeMapInfo.h"
 
 namespace Ui {
@@ -23,6 +21,9 @@ public:
     explicit OneEyeMap(QWidget *parent = nullptr);
     ~OneEyeMap();
 
+    /* 根据通道号获取数据指针 */
+    void getEyeDataPtrFromOscData(int channel);
+
     /* 设置序号 */
     void setNum(int num) { m_info.num = num; }
     /* 获取序号 */
@@ -107,6 +108,8 @@ private:
     /* 眼图属性 */
     // OscVoltageRange m_cRange = OscVoltageRange::CR_2V5;    /* 通道输入档位 */
     // OscTimeGridValue m_tGridValue = OscTimeGridValue::TGV_200NS;    /* 时间刻度值 */
+
+    EyeMapMatrix* m_eyeMapMatrix = nullptr; /* 眼图矩阵，从外面获取 */
 };
 
 #endif // ONEEYEMAP_H

EyeMap/OscData/OneOscData.cpp

@@ -0,0 +1,1164 @@
+#include "OneOscData.h"
+#include <QApplication>
+#include <QRandomGenerator>
+
+#include "ThreadPool/ThreadPool.h"
+
+
+OneOscilloscopeData::OneOscilloscopeData()
+{
+    
+}
+
+
+OneOscilloscopeData::~OneOscilloscopeData()
+{
+    if(m_isOpen)
+    {
+        closeOSC();
+    }
+    if(m_buffer != nullptr)
+    {
+        delete[] m_buffer;
+        m_buffer = nullptr;
+    }
+    if(m_bufferChnA != nullptr)
+    {
+        delete[] m_bufferChnA;
+        m_bufferChnA = nullptr;
+    }
+    if(m_bufferChnB != nullptr)
+    {
+        delete[] m_bufferChnB;
+        m_bufferChnB = nullptr;
+    }
+}
+
+/* 初始化示波器 */
+void OneOscilloscopeData::initOsc()
+{
+    m_logger = spdlog::get("OscData");
+    if(m_logger == nullptr)
+    {
+        SPDLOG_ERROR("获取 OscData logger 失败");
+        return;
+    }
+    m_usbInterface = std::make_shared<USBInterface>();
+    if(!m_usbInterface->loadLib(QApplication::applicationDirPath()))
+    {
+        return;
+    }
+    /* 分配缓冲区内存 */
+    m_buffer = new unsigned char[BUFFER_SIZE];
+    m_bufferChnA = new unsigned char[BUFFER_SIZE / 2];
+    m_bufferChnB = new unsigned char[BUFFER_SIZE / 2];
+}
+
+/* 打开示波器 */
+bool OneOscilloscopeData::openOSC()
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return false;
+    }
+    /* 指定示波器设备型号，OSCA02是6 */
+    m_usbInterface->specifyDevId(6);
+    auto ret = m_usbInterface->devOpen();
+    if(ret != 0)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "打开示波器失败!");
+        return false;
+    }
+    /* 获取缓冲区首指针 */
+    m_devBuffer = m_usbInterface->bufferWR(-1);
+    if(m_devBuffer == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "获取缓冲区指针失败!");
+        return false;
+    }
+    /* 设置硬件触发命令，关闭外部触发，好像是有的设备需要，有的不需要 */
+    m_ctrlByte1 &= 0xdf;
+    m_ctrlByte1 |= 0x00;
+    m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+    /* 设置触发位置在缓冲区中间 */
+    m_usbInterface->usbCtrlTrans(0x18, 0xff);
+    m_usbInterface->usbCtrlTrans(0x17, 0x7f);
+    /* 设置缓冲区大小 */
+    m_usbInterface->setInfo(BUFFER_SIZE);
+    /* 获取零电压值 */
+    getZeroVoltage();
+    /* 获取电压校准系数 */
+    getVoltageCalibration();
+
+
+    m_isOpen = true;
+    return true;
+}
+
+/* 关闭示波器 */
+void OneOscilloscopeData::closeOSC()
+{
+    if(m_runCapture)
+    {
+        stopCapture();
+    }
+    
+    if(m_usbInterface != nullptr)
+    {
+        m_usbInterface->devClose();
+    }
+    m_isOpen = false;
+    SPDLOG_INFO("示波器已关闭");
+}
+
+/* 开始采集数据 */
+bool OneOscilloscopeData::startCapture()
+{
+    if(m_buffer == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "缓冲区指针为空!");
+        return false;
+    }
+    /* 启动子线程 */
+    m_runCapture = true;
+    CPPTP.add_task(&OneOscilloscopeData::threadCaptureData, this);
+    CPPTP.add_task(&OneOscilloscopeData::threadSeparateData, this);
+    CPPTP.add_task(&OneOscilloscopeData::threadProcessData_A, this);
+    CPPTP.add_task(&OneOscilloscopeData::threadProcessData_B, this);
+    return true;
+}
+
+/* 停止采集数据 */
+void OneOscilloscopeData::stopCapture()
+{
+    if(!m_runCapture)
+    {
+        return;
+    }
+    m_runCapture = false;
+    while (m_isRunCapture)
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+    }
+    SPDLOG_LOGGER_INFO(m_logger, "停止采集数据");
+}
+
+/* 设置示波器的采样率 */
+void OneOscilloscopeData::setSampleRate(OscSampleRate rate)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    m_ctrlByte0 &= 0xf0;
+    if(rate == OscSampleRate::SR_49KHZ)
+    {
+        m_ctrlByte0 |= 0x0e;
+        OscParams.SampleIntervalTime = 20408.16;
+    }
+    else if(rate == OscSampleRate::SR_96KHZ)
+    {
+        m_ctrlByte0 |= 0x04;
+        OscParams.SampleIntervalTime = 10416.67;
+    }
+    else if(rate == OscSampleRate::SR_781KHZ)
+    {
+        m_ctrlByte0 |= 0x0c;
+        OscParams.SampleIntervalTime = 1280.0;
+    }
+    else if(rate == OscSampleRate::SR_12_5MHZ)
+    {
+        m_ctrlByte0 |= 0x08;
+        OscParams.SampleIntervalTime = 80.0;
+    }
+    else if(rate == OscSampleRate::SR_100MHZ)
+    {
+        m_ctrlByte0 |= 0x00;
+        OscParams.SampleIntervalTime = 10;
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "采样率设置错误!");
+        return;
+    }
+    m_usbInterface->usbCtrlTrans(0x94, m_ctrlByte0);
+}
+
+/**
+ * @brief 将示波器两个通道合并为一个通道
+ *        将AB两个通道的资源全部给A，B通道失效，A通道的采样率和带宽翻倍
+ * @param merge 是否合并
+ */
+void OneOscilloscopeData::setChannelMerge(bool merge)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    if(merge)
+    {
+        m_ctrlByte1 |= 0x80;
+    }else {
+        m_ctrlByte1 &= 0x7f;
+    }
+    m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+}
+
+/**
+ * @brief 设置通道A输入量程，这个函数需要在打开示波器之后调用
+ * 
+ * @param range 
+ */
+void OneOscilloscopeData::setChannelARange(OscVoltageRange range)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    m_ctrlByte1 &= 0xf7;
+    if(range == OscVoltageRange::CR_100MV)
+    {
+        m_usbInterface->usbCtrlTrans(0x22, 0x06);
+    }
+    else if(range == OscVoltageRange::CR_250MV)
+    {
+        m_usbInterface->usbCtrlTrans(0x22, 0x04);
+    }
+    else if(range == OscVoltageRange::CR_500MV)
+    {
+        m_usbInterface->usbCtrlTrans(0x22, 0x02);
+    }
+    else if(range == OscVoltageRange::CR_1V)
+    {
+        m_ctrlByte1 |= 0x08;
+        m_usbInterface->usbCtrlTrans(0x22, 0x06);
+    }
+    else if(range == OscVoltageRange::CR_2V5)
+    {
+        m_ctrlByte1 |= 0x08;
+        m_usbInterface->usbCtrlTrans(0x22, 0x04);
+    }
+    else if(range == OscVoltageRange::CR_5V)
+    {
+        m_ctrlByte1 |= 0x08;
+        m_usbInterface->usbCtrlTrans(0x22, 0x02);
+    }
+    else if(range == OscVoltageRange::CR_8V)
+    {
+        m_ctrlByte1 |= 0x08;
+        m_usbInterface->usbCtrlTrans(0x22, 0x00);
+    }
+    m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+    
+    setZeroVoltageAndCalibration(OscChannel::CH_A, range);
+}
+
+/**
+ * @brief 设置通道B输入量程
+ * 
+ * @param range 
+ */
+void OneOscilloscopeData::setChannelBRange(OscVoltageRange range)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    m_ctrlByte1 &= 0xf9;
+    if(range == OscVoltageRange::CR_100MV)
+    {
+        m_ctrlByte1 |= 0x06;
+        m_usbInterface->usbCtrlTrans(0x23, 0x40);
+    }
+    else if(range == OscVoltageRange::CR_250MV)
+    {
+        m_ctrlByte1 |= 0x04;
+        m_usbInterface->usbCtrlTrans(0x23, 0x40);
+    }
+    else if(range == OscVoltageRange::CR_500MV)
+    {
+        m_ctrlByte1 |= 0x02;
+        m_usbInterface->usbCtrlTrans(0x23, 0x40);
+    }
+    else if(range == OscVoltageRange::CR_1V)
+    {
+        m_ctrlByte1 |= 0x06;
+        m_usbInterface->usbCtrlTrans(0x23, 0x00);
+    }
+    else if(range == OscVoltageRange::CR_2V5)
+    {
+        m_ctrlByte1 |= 0x04;
+        m_usbInterface->usbCtrlTrans(0x23, 0x00);
+    }
+    else if(range == OscVoltageRange::CR_5V)
+    {
+        m_ctrlByte1 |= 0x02;
+        m_usbInterface->usbCtrlTrans(0x23, 0x00);
+    }
+    else if(range == OscVoltageRange::CR_8V)
+    {
+        m_usbInterface->usbCtrlTrans(0x23, 0x00);
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "输入量程设置错误!");
+        return;
+    }
+    m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+
+    setZeroVoltageAndCalibration(OscChannel::CH_B, range);
+}
+
+/**
+ * @brief 设置通道耦合方式
+ * 
+ * @param channel 通道
+ * @param coupling 耦合方式，DC或者AC
+ */
+void OneOscilloscopeData::setChannelCoupling(OscChannel channel, OscChannelCoupling coupling)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    if(channel == OscChannel::CH_A)
+    {
+        m_ctrlByte0 &= 0xef;
+        if(coupling == OscChannelCoupling::DC) {
+            m_ctrlByte0 |= 0x10;
+        }
+        else if(coupling == OscChannelCoupling::AC) {}
+        else {
+            SPDLOG_LOGGER_ERROR(m_logger, "耦合方式设置错误!");
+            return;
+        }
+        m_usbInterface->usbCtrlTrans(0x94, m_ctrlByte0);
+    }
+    else if(channel == OscChannel::CH_B)
+    {
+        m_ctrlByte1 &= 0xef;
+        if(coupling == OscChannelCoupling::AC) {
+            m_ctrlByte1 |= 0x10;
+        }
+        else if(coupling == OscChannelCoupling::DC) {}
+        else {
+            SPDLOG_LOGGER_ERROR(m_logger, "耦合方式设置错误!");
+            return;
+        }
+        m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "通道设置错误!");
+        return;
+    }
+}
+
+/* 开启或关闭通道A触发 */
+void OneOscilloscopeData::setChannelATrigger(bool enable)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    if(enable)
+    {
+        m_usbInterface->usbCtrlTrans(0xE7, 0x01);
+    }
+    else
+    {
+        m_usbInterface->usbCtrlTrans(0xE7, 0x00);
+    }
+}
+
+/* 开启外触发 */
+void OneOscilloscopeData::setExternalTrigger(bool enable)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    if(enable)
+    {
+        m_usbInterface->usbCtrlTrans(0xE7, 0x01);
+        m_ctrlByte1 &= 0xdf;
+        m_ctrlByte1 |= 0x20;
+        m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+    }
+    else
+    {
+        m_usbInterface->usbCtrlTrans(0xE7, 0x00);
+        m_ctrlByte1 &= 0xdf;
+        m_ctrlByte1 |= 0x00;
+        m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+    }
+}
+
+/* 设置触发方式 */
+void OneOscilloscopeData::setTriggerMode(OscTriggerMode mode)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    if(mode == OscTriggerMode::TM_RISE)
+    {
+        m_usbInterface->usbCtrlTrans(0xC5, 0x00);
+    }
+    else if (mode == OscTriggerMode::TM_DOWN)
+    {
+        m_usbInterface->usbCtrlTrans(0xC5, 0x01);
+    }
+    else if (mode == OscTriggerMode::TM_DOUBLE)
+    {
+        m_usbInterface->usbCtrlTrans(0xC5, 0x03);
+    }
+}
+
+/**
+ * @brief 设置触发电平
+ * 
+ * @param level 0~255的值
+ */
+void OneOscilloscopeData::setTriggerLevel(unsigned char level)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    m_usbInterface->usbCtrlTrans(0x16, level);
+}
+
+/* 设置触发灵敏度 */
+void OneOscilloscopeData::setTriggerSensitivity(OscTriggerSensitivity sensitivity)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    if(sensitivity == OscTriggerSensitivity::TS_LOW)
+    {
+        m_usbInterface->usbCtrlTrans(0x2b, 0);
+    }
+    else if(sensitivity == OscTriggerSensitivity::TS_HIGH)
+    {
+        m_usbInterface->usbCtrlTrans(0x2b, 1);
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "触发灵敏度设置错误!");
+        return;
+    }
+}
+
+/* 设置触发在缓冲区的哪个位置 */
+void OneOscilloscopeData::setTriggerPosition(unsigned char lowByte, unsigned char highByte)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    m_usbInterface->usbCtrlTrans(0x18, lowByte);
+    m_usbInterface->usbCtrlTrans(0x17, highByte);
+}
+
+/* 获取示波器不同档位下的零电压值 */
+void OneOscilloscopeData::getZeroVoltage()
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    /* 获取通道A零电压值 */
+    unsigned char zeroVoltage = 0;
+    /* 2V档位，正负8V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x82);
+    m_mapChAZeroVoltage.insert(OscVoltageRange::CR_8V, zeroVoltage);
+    /* 1V档位，正负5V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x01);
+    m_mapChAZeroVoltage.insert(OscVoltageRange::CR_5V, zeroVoltage);
+    /* 500mV档位，正负2.5V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x0e);
+    m_mapChAZeroVoltage.insert(OscVoltageRange::CR_2V5, zeroVoltage);
+    /* 200mV档位，正负1V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x14);
+    m_mapChAZeroVoltage.insert(OscVoltageRange::CR_1V, zeroVoltage);
+    /* 100mV档位，正负500mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x12);
+    m_mapChAZeroVoltage.insert(OscVoltageRange::CR_500MV, zeroVoltage);
+    /* 50mV档位，正负250mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x10);
+    m_mapChAZeroVoltage.insert(OscVoltageRange::CR_250MV, zeroVoltage);
+    /* 20mV档位，正负100mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0xa0);
+    m_mapChAZeroVoltage.insert(OscVoltageRange::CR_100MV, zeroVoltage);
+
+    /* 获取通道B零电压值 */
+    /* 2V档位，正负8V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x72);
+    m_mapChBZeroVoltage.insert(OscVoltageRange::CR_8V, zeroVoltage);
+    /* 1V档位，正负5V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x02);
+    m_mapChBZeroVoltage.insert(OscVoltageRange::CR_5V, zeroVoltage);
+    /* 500mV档位，正负2.5V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x0f);
+    m_mapChBZeroVoltage.insert(OscVoltageRange::CR_2V5, zeroVoltage);
+    /* 200mV档位，正负1V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x15);
+    m_mapChBZeroVoltage.insert(OscVoltageRange::CR_1V, zeroVoltage);
+    /* 100mV档位，正负500mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x13);
+    m_mapChBZeroVoltage.insert(OscVoltageRange::CR_500MV, zeroVoltage);
+    /* 50mV档位，正负250mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x11);
+    m_mapChBZeroVoltage.insert(OscVoltageRange::CR_250MV, zeroVoltage);
+    /* 20mV档位，正负100mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0xa1);
+    m_mapChBZeroVoltage.insert(OscVoltageRange::CR_100MV, zeroVoltage);
+}
+
+/* 打印出零电压值 */
+void OneOscilloscopeData::printZeroVoltage(OscChannel channel)
+{
+    if(channel == OscChannel::CH_A)
+    {
+        for(auto it = m_mapChAZeroVoltage.begin(); it != m_mapChAZeroVoltage.end(); ++it)
+        {
+            SPDLOG_LOGGER_INFO(m_logger, "通道A {} 量程下的零电压值为: {}", static_cast<int>(it.key()), it.value());
+        }
+    }
+    else if(channel == OscChannel::CH_B)
+    {
+        for(auto it = m_mapChBZeroVoltage.begin(); it != m_mapChBZeroVoltage.end(); ++it)
+        {
+            SPDLOG_LOGGER_INFO(m_logger, "通道B {} 量程下的零电压值为: {}", static_cast<int>(it.key()), it.value());
+        }
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "通道设置错误!");
+        return;
+    }
+}
+
+/* 获取不同档位下电压校准系数 */
+void OneOscilloscopeData::getVoltageCalibration()
+{
+    if (m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    /* 获取通道A电压校准系数 */
+    unsigned char voltageCalibration = 0;
+    /* 2V档位，正负8V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0xc2);
+    m_mapChAVoltageAmplitudeRatio.insert(OscVoltageRange::CR_8V, voltageCalibration);
+    /* 1V档位，正负5V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x03);
+    m_mapChAVoltageAmplitudeRatio.insert(OscVoltageRange::CR_5V, voltageCalibration);
+    /* 500mV档位，正负2.5V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x08);
+    m_mapChAVoltageAmplitudeRatio.insert(OscVoltageRange::CR_2V5, voltageCalibration);
+    /* 200mV档位，正负1V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x06);
+    m_mapChAVoltageAmplitudeRatio.insert(OscVoltageRange::CR_1V, voltageCalibration);
+    /* 100mV档位，正负500mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x09);
+    m_mapChAVoltageAmplitudeRatio.insert(OscVoltageRange::CR_500MV, voltageCalibration);
+    /* 50mV档位，正负250mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x0a);
+    m_mapChAVoltageAmplitudeRatio.insert(OscVoltageRange::CR_250MV, voltageCalibration);
+    /* 20mV档位，正负100mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x2a);
+    m_mapChAVoltageAmplitudeRatio.insert(OscVoltageRange::CR_100MV, voltageCalibration);
+
+    /* 获取通道B电压校准系数 */
+    /* 2V档位，正负8V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0xd2);
+    m_mapChBVoltageAmplitudeRatio.insert(OscVoltageRange::CR_8V, voltageCalibration);
+    /* 1V档位，正负5V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x04);
+    m_mapChBVoltageAmplitudeRatio.insert(OscVoltageRange::CR_5V, voltageCalibration);
+    /* 500mV档位，正负2.5V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x0b);
+    m_mapChBVoltageAmplitudeRatio.insert(OscVoltageRange::CR_2V5, voltageCalibration);
+    /* 200mV档位，正负1V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x07);
+    m_mapChBVoltageAmplitudeRatio.insert(OscVoltageRange::CR_1V, voltageCalibration);
+    /* 100mV档位，正负500mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x0c);
+    m_mapChBVoltageAmplitudeRatio.insert(OscVoltageRange::CR_500MV, voltageCalibration);
+    /* 50mV档位，正负250mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x0d);
+    m_mapChBVoltageAmplitudeRatio.insert(OscVoltageRange::CR_250MV, voltageCalibration);
+    /* 20mV档位，正负100mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x2d);
+    m_mapChBVoltageAmplitudeRatio.insert(OscVoltageRange::CR_100MV, voltageCalibration);
+
+}
+
+/* 打印出电压校准系数 */
+void OneOscilloscopeData::printVoltageCalibration(OscChannel channel)
+{
+    if(channel == OscChannel::CH_A)
+    {
+        for(auto it = m_mapChAVoltageAmplitudeRatio.begin(); it != m_mapChAVoltageAmplitudeRatio.end(); ++it)
+        {
+            SPDLOG_LOGGER_INFO(m_logger, "通道A {} 量程下的电压校准系数为: {}", static_cast<int>(it.key()), it.value());
+        }
+    }
+    else if(channel == OscChannel::CH_B)
+    {
+        for(auto it = m_mapChBVoltageAmplitudeRatio.begin(); it != m_mapChBVoltageAmplitudeRatio.end(); ++it)
+        {
+            SPDLOG_LOGGER_INFO(m_logger, "通道B {} 量程下的电压校准系数为: {}", static_cast<int>(it.key()), it.value());
+        }
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "通道设置错误!");
+        return;
+    }
+}
+
+/**
+ * @brief 采集数据，这个是子线程 
+ * 
+ */
+void OneOscilloscopeData::threadCaptureData()
+{
+    SPDLOG_LOGGER_INFO(m_logger, "开始采集数据线程");
+    m_isRunCapture = true;
+    // unsigned char* buffer = nullptr;
+    while(m_runCapture)
+    {
+        // SPDLOG_LOGGER_DEBUG(m_logger, "开始采集数据");
+        /* 开始采集数据 */
+        m_usbInterface->usbCtrlTransSimple(0x33);
+        /* 清空数据缓冲区 */
+        for(uint32_t i = 0; i < BUFFER_SIZE; i++)
+        {
+            m_buffer[i] = 0;
+        }
+        /* 查询数据是否采集完成（应该是填充满128KB的SRAM）
+         * 注意，这里是十进制33，不是0x33 */
+        while(m_usbInterface->usbCtrlTransSimple(0x50) != 33)
+        {
+            std::this_thread::sleep_for(std::chrono::microseconds(10));
+        }
+        // SPDLOG_LOGGER_DEBUG(m_logger, "硬件缓冲区已满");
+        /* 将数据从示波器的SRAM中拷贝到电脑内存中，1次传输完成，设置超时时间1ms */
+        m_usbInterface->readBulkData(BUFFER_SIZE, 1, 100, m_devBuffer);
+        /* 等待传输完成 */
+        auto ret = m_usbInterface->eventCheck(100);
+        if(ret == 0x555)
+        {
+            SPDLOG_LOGGER_ERROR(m_logger, "数据传输超时!");
+            // continue;
+        }
+        // SPDLOG_LOGGER_DEBUG(m_logger, "数据通过USB传输完成");
+        /* 取出数据 */
+        // buffer = m_ringQueue.back();
+        m_mutexBuffer.lock();
+        std::memcpy(m_buffer, m_devBuffer, BUFFER_SIZE);
+        m_mutexBuffer.unlock();
+        // SPDLOG_LOGGER_DEBUG(m_logger, "count: {}", count++);
+        m_isCapturedData = true;
+        m_condCapture.notify_one();
+        /* 清空缓冲区 */
+        m_usbInterface->resetPipe();
+    }
+    m_isRunCapture = false;
+    SPDLOG_LOGGER_INFO(m_logger, "采集数据线程结束");
+}
+
+/* 处理数据线程 */
+void OneOscilloscopeData::threadSeparateData()
+{
+    
+    SPDLOG_LOGGER_INFO(m_logger, "开始处理数据线程");
+    while(m_runCapture)
+    {
+        {
+            std::unique_lock<std::mutex> lock(m_mutexBuffer);
+            m_condCapture.wait(lock, [this](){ 
+                return m_isCapturedData.load();
+            });
+            /* 分离通道AB的数据 */
+            m_mutexBuffer_A.lock();
+            m_mutexBuffer_B.lock();
+            for(uint32_t i = 0; i < BUFFER_SIZE / 2; i++)
+            {
+                m_bufferChnA[i] = m_buffer[i * 2];
+                m_bufferChnB[i] = m_buffer[i * 2 + 1];
+            }
+            /* 处理数据 */
+            // SPDLOG_LOGGER_DEBUG(m_logger, "开始处理数据，通道A数据: {}, 通道B数据: {}", m_bufferChnA[32000], m_bufferChnB[32000]);
+            m_mutexBuffer_A.unlock();
+            m_mutexBuffer_B.unlock();
+        }
+    }
+    SPDLOG_LOGGER_INFO(m_logger, "处理数据线程结束");
+}
+
+/* 处理A通道数据 */
+void OneOscilloscopeData::threadProcessData_A()
+{
+    while (m_runCapture)
+    {
+        std::unique_lock<std::mutex> lock(m_mutexBuffer_A);
+        m_condBuffer_A.wait(lock);
+        /* 矫正零电压值 */
+        for(uint32_t i = 0; i < BUFFER_SIZE / 2; i++)
+        {
+            m_bufferChnA[i] = m_bufferChnA[i] + m_diffVoltageA;
+        }
+        /* 对零电平进行矫正 */
+
+        /* 处理眼图数据 */
+        parseEyeMapData(OscChannel::CH_A, m_bufferChnA, BUFFER_SIZE / 2);
+        /* 添加颜色 */
+        m_eyeMapMatrix_A->mutexEyeData.lock();
+        m_eyeMapMatrix_A->addColorBySample();
+        m_eyeMapMatrix_A->mutexEyeData.unlock();
+    }
+}
+
+/* 处理B通道数据 */
+void OneOscilloscopeData::threadProcessData_B()
+{
+    while (m_runCapture)
+    {
+        std::unique_lock<std::mutex> lock(m_mutexBuffer_B);
+        m_condBuffer_B.wait(lock);
+        /* 矫正零电压值 */
+        for(uint32_t i = 0; i < BUFFER_SIZE / 2; i++)
+        {
+            m_bufferChnB[i] = m_bufferChnB[i] + m_diffVoltageB;
+        }
+        /* 对零电平进行矫正 */
+
+        /* 处理眼图数据 */
+        parseEyeMapData(OscChannel::CH_B, m_bufferChnB, BUFFER_SIZE / 2);
+        /* 添加颜色 */
+        m_eyeMapMatrix_B->mutexEyeData.lock();
+        m_eyeMapMatrix_B->addColorBySample();
+        m_eyeMapMatrix_B->mutexEyeData.unlock();
+    }
+}
+
+
+/** 
+ * @brief 解析数据，眼图需要的数据，从C#代码中移植过来 
+ *        1、采样率为100MHz的时候，采样点间隔时间是10ns
+ *          x轴时间是1000分度，当x轴整体时间是10us的时候，采样点和分辨率一一对应
+ *          x轴时间大于10us，采样点比分辨率高，无需做什么操作
+ *          x轴时间小于10us，采样点数量会小于1000，那么绘制的矩形小点间隔会比较长，这时候就需要进行插帧
+ *        2、屏幕中显示多少波形和波形的频率及时间屏幕可以现实的时间长度有关，波形的频率未知，所以这里只能通过调整时间长度来调整波形
+ *          在屏幕中显示的数目
+ *        3、当时间长度变小，小到整个屏幕的采样点数目不足1000的时候，就需要进行插值，插值到1000附近
+ * 
+ * @param buffer 数据缓冲区 
+ * @param size 缓冲区大小，单位字节 
+ */ 
+void OneOscilloscopeData::parseEyeMapData(OscChannel chn, unsigned char* buffer, unsigned int size)
+{
+    EyeDataMatrix* eyeDataMatrix = nullptr;
+    EyeMapMatrix* eyeMapMatrix = nullptr;
+    if(chn == OscChannel::CH_A)
+    {
+        eyeDataMatrix = m_eyeDataMatrix_A;
+        eyeMapMatrix = m_eyeMapMatrix_A;
+    }
+    else if (chn == OscChannel::CH_B)
+    {
+        eyeDataMatrix = m_eyeDataMatrix_B;
+        eyeMapMatrix = m_eyeMapMatrix_B;
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "通道设置错误!");
+        return;
+    }
+
+    int bufferSize = size;
+    uint8_t* array = buffer;
+
+    uint8_t vaMax = 128;
+    uint8_t vaMin = 128;
+    uint8_t tmp = 128;
+
+    /* 数据预处理，找出最大值和最小值 */
+    for (int i = 0; i < bufferSize; i++)
+    {
+        /* 取出这组数据的最大值和最小值 */
+        tmp = array[i];
+        if (tmp < vaMin)
+        {
+            vaMin = tmp;
+        }
+        if (tmp > vaMax)
+        {
+            vaMax = tmp;
+        }
+    }
+
+    /* 取绝对值，小于15丢弃，丢弃幅度小于15的数据，这部分可能不是触发的数据 */
+    int numAmp = std::abs(vaMax - vaMin);
+    if (numAmp <= 15)
+    {
+        return;
+    }
+    /* 计算最大值和最小值的中间数 */
+    uint8_t vaMid = (vaMax + vaMin) / 2;
+
+    /* ======================================================================== */
+    /* 将采样点添加bool值，如果时间很短，就进行插值，每个采样点之间插入30个值 */
+    /* 时间尺度，OscCurrentTimeScale = 100，num7 = 1.0，100MHz下每个采样点间距10ns */
+    // double num7 = OscParams.dataNumPerPixar * OscParams.OscCurrentTimeScale / 100.0;
+    // /* num7 * OscOneGridTime是一个时间格子中采样点的个数 */
+    // long oneGridTime = num7 * OscParams.OscOneGridTime;
+    // if (oneGridTime % 2 != 0L)
+    // {
+    //     oneGridTime++;
+    // }
+
+    /* 采样率为100MHz的时候，采样点间隔时间是10ns
+     * x轴时间是1000分度，当x轴整体时间是10us的时候，采样点和分辨率一一对应
+     * x轴时间大于10us，采样点比分辨率高，无需做什么操作
+     * x轴时间小于10us，采样点数量会小于1000，那么绘制的矩形小点间隔会比较长，这时候就需要进行插帧 */
+    /* 一个时间格子的采样率个数 */
+    int oneGridSa = OscParams.oneGridTime / OscParams.SampleIntervalTime;       /* 当前一个格子中采样点的数目 */
+    int saTotal = oneGridSa * 10;       /* 一个时间格子中采样点的总数 */
+    bool isNeedFrameInsertion = ( saTotal < OscParams.eyeMapWidth ) ? true : false;
+
+    int num9 = (int)((double)oneGridSa * 0.25);       /* 1/4个时间格子长度 */
+    /* 记录buffer的值，并添加bool */
+    std::vector<EyeDataT> vecData;
+    int numMulti = 0;    /* 倍率，可能是1可能是30 */
+    if (isNeedFrameInsertion == false)
+    {
+        /* 将数据放入到list中，带有bool标志位，全部启用 */
+        for (int i = 0; i < bufferSize; i++)
+        {
+            vecData.push_back(EyeDataT(true, array[i]));
+        }
+        numMulti = 1;
+    }
+    else
+    {
+        /* 缩放系数小于1.0，下面会进行插值 */
+        int numTmp = bufferSize - 1;
+        float num11 = 0.0;
+
+        uint8_t b2 = 0;
+        uint8_t b3 = 0;
+        uint8_t b = 0;
+
+        /* 进行插值，每个采样点之间插值根据实际的采样点来计算，插值后的采样点个数比1000略大 */
+        int numMulti2 = 0;
+        double numMulti1 = 1000.0 / saTotal;
+        if(numMulti1 > 1.0 && numMulti1 < 2.0)
+        {
+            numMulti2 = 1;
+        }
+        else if(numMulti1 > 2.0 && numMulti1 < 3.0)
+        {
+            numMulti2 = 2;
+        }
+        else if(numMulti1 > 3.0)
+        {
+            numMulti2 = std::round(numMulti1);
+        }
+        for(int i = 0; i < numTmp; i++)
+        {
+            b2 = array[i];
+            b3 = array[i + 1];
+            num11 = (float)(b3 - b2) / numMulti2;
+            vecData.push_back(EyeDataT(true, b2));
+            for(int j = 0; j < numMulti2; j++)
+            {
+                b = std::round((num11 * (float)j) + (int)b2);
+                vecData.push_back(EyeDataT(true, b));
+            }
+            vecData.push_back(EyeDataT(true, b3));
+        }
+
+        numMulti = numMulti2;
+    }
+    if (vecData.size() <= 0)
+    {
+        return;
+    }
+    num9 *= numMulti;          /* 1/4个时间格子长度，乘以倍数 */
+    /* 这里决定着时间的缩放关系，saTotal是整个显示区域的采样点个数 */
+    long oneJumpSa = saTotal * numMulti;
+    // long oneJumpSa = 1000;
+    /* ======================================================================== */
+    /* 寻找波形，找到上升沿和下降沿 */
+    /* 存储下标 */
+    std::vector<int> listSub;
+    size_t numDataSize = vecData.size() - num9;
+    bool flag3 = true;
+    /* 找到数组中的上升沿和下降沿，并记录其坐标
+     * 这里寻找上升沿和下降沿是检测的中间值，是每个跳变沿的中部
+     * 中间值理论上是零值 */
+    uint8_t vaPre = 0;
+    // uint8_t va = 0;
+    uint8_t vaNext = 0;
+    for (int i = 10; i < numDataSize; i++)
+    {
+        /* 取出相邻的三个值 */
+        vaPre = vecData[i - 1].value;
+        // va = vecData[i].value;
+        vaNext = vecData[i + 1].value;
+        if (flag3)
+        {
+            /* 上升沿，就是中间值 */
+            if (vaPre <= vaMid && vaNext > vaMid)
+            {
+                listSub.push_back(i);		/* 记录下标 */
+                flag3 = !flag3;			    /* 不再检测上升沿，检测下降沿 */
+            }
+        }
+        /* 下降沿 */
+        else if (vaPre >= vaMid && vaNext < vaMid)
+        {
+            listSub.push_back(i);
+            flag3 = !flag3;
+        }
+        /* 采集到600个上升沿和下降沿 */
+        if (listSub.size() >= 600)
+        {
+            break;
+        }
+    }
+    if (listSub.size() <= 0)
+    {
+        return;
+    }
+    /* ======================================================================== */
+    /* 这里应该是根据跳变沿的中间值，取出完整的跳变沿
+     * 创建一个二维数组，每一行就是一个跳变沿 */
+    std::vector<std::vector<EyeDataT>> vec2DEyeData;
+    int jumpStart = 0;      /* 跳变沿起点 */
+    size_t jumpEnd = 0;        /* 跳变沿终点 */
+    int num17 = 0;
+    size_t numSubSize = listSub.size();                 /* 跳变沿下标的个数 */
+    int oneThirdSa = (int)(oneJumpSa / 3);           /* 一个时间格子中三分之一的采样点个数 */
+    int numSub1 = 0;
+    int numSub2 = 0;
+    for (int i = 0; i < numSubSize; i++)
+    {
+        int j = 0;
+        /* 这一个数组就是一个跳变沿，num12是一个跳变沿所有的采样点的个数 */
+        std::vector<EyeDataT> vecDataTmp(oneJumpSa, EyeDataT(false, 0));
+
+        numSub1 = listSub[i];               /* 取出下标值 */
+        numSub2 = numSub1 - oneThirdSa;     /* 下标往后倒退1/3个时间格子的采样点数，当作起点 */
+        /* 判断是否小于0，这里是起点 */
+        jumpStart = numSub2;
+        if (jumpStart <= 0)
+        {
+            jumpStart = 0;
+        }
+        /* 终点往后2/3个时间格子的采样点数，当作终点 */
+        jumpEnd = numSub1 + oneThirdSa * 2;
+        if (jumpEnd >= vecData.size())
+        {
+            jumpEnd = vecData.size() - 1;
+        }
+        /* 这里为了去掉jumpStart前面的值，让vecDataTmp从0开始计数 */
+        num17 = 0;
+        if (numSub2 < 0)
+        {
+            num17 = std::abs(numSub2);
+        }
+        if (numSub2 > 0)
+        {
+            num17 = -numSub2;
+        }
+        /* num14是起点，num15是终点，num17应该是个负值，num17+j从0开始计数 */
+        for (j = jumpStart; j < jumpEnd; j++)
+        {
+            vecDataTmp[num17 + j].isEyeData = vecData[j].isEyeData;
+            vecDataTmp[num17 + j].value = vecData[j].value;
+        }
+        // for(j = 0; j < oneGridTime2; j++)
+        // {
+        //     vecDataTmp[j].isEyeData = vecData[jumpStart + j].isEyeData;
+        //     vecDataTmp[j].value = vecData[jumpStart + j].value;
+        // }
+        vec2DEyeData.push_back(vecDataTmp);
+    }
+    // listSub.clear();
+    // vecData.clear();
+    if (vec2DEyeData.size() <= 0)
+    {
+        return;
+    }
+    /* ======================================================================== */
+    int num18 = 0;
+    float num20 = 0.0;
+    /* 将数据拷贝到OscData的Matrix中 */
+    size_t numTmp = 0;
+    int ValTmp = 0;
+    /* 将跳变沿数据放入到全局变量中，并根据坐标进行排列
+     * x轴是这个跳变沿根据时间平分1000份
+     * y轴是这个值 */
+    eyeDataMatrix->mutexEyeData.lock();
+    for (int i = 0; i < vec2DEyeData.size(); i++)
+    {
+        /* 取出一个跳变沿，将其分布在整个 1000 * 256像素的矩阵中 */
+        std::vector<EyeDataT>& vecTmp = vec2DEyeData[i];
+        numTmp = vecTmp.size();
+        num20 = numTmp / 1000.f;    /* x轴方向1000分 */
+        for (int i = 0; i < numTmp; i++)
+        {
+            if (vecTmp[i].isEyeData)
+            {
+                ValTmp = vecTmp[i].value;
+                num18 = (int)((float)i / num20);
+                /* 将数据添加到眼图矩阵中 */
+                eyeDataMatrix->addData(num18, ValTmp);
+            }
+        }
+    }
+    
+
+    eyeDataMatrix->eyeStatisticalWeight();
+    eyeDataMatrix->eyeLessenTheBurden();
+    vec2DEyeData.clear();
+    auto eyeData = eyeDataMatrix->eyeZoomOut();
+    eyeDataMatrix->mutexEyeData.unlock();
+
+    eyeMapMatrix->mutexEyeData.lock();
+    eyeMapMatrix->copyDataMatrix(*eyeData);
+    eyeMapMatrix->mutexEyeData.unlock();
+}
+
+
+/* 设置零电压值和电压校准系数 */
+void OneOscilloscopeData::setZeroVoltageAndCalibration(OscChannel chn, OscVoltageRange range)
+{
+
+    if(chn == OscChannel::CH_A)
+    {
+        /* 电压幅值比 */
+        uint8_t altitudeByteA = 0;
+        m_zeroVoltageA = m_mapChAZeroVoltage.value(range);
+        altitudeByteA = m_mapChAVoltageAmplitudeRatio.value(range);
+        m_diffVoltageA = m_zeroVoltageA - 128;
+        
+
+
+        if(range == OscVoltageRange::CR_100MV)
+        {
+            m_voltageCalibrationA = (altitudeByteA * 2) / 255.0;
+            m_rangeRatioA = 0.1 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_250MV)
+        {
+            m_voltageCalibrationA = (altitudeByteA * 2) / 255.0;
+            m_rangeRatioA = 0.25 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_500MV)
+        {
+            m_voltageCalibrationA = (altitudeByteA * 2) / 255.0;
+            m_rangeRatioA = 0.5 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_1V)
+        {
+            m_voltageCalibrationA = (altitudeByteA * 2) / 255.0;
+            m_rangeRatioA = 1.0 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_2V5)
+        {
+            m_voltageCalibrationA = (altitudeByteA * 2) / 255.0;
+            m_rangeRatioA = 2.5 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_5V)
+        {
+            m_voltageCalibrationA = (altitudeByteA * 2) / 255.0;
+            m_rangeRatioA = 5.0 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_8V)
+        {
+            m_voltageCalibrationA = (altitudeByteA * 2) / 255.0;
+            m_rangeRatioA = 8.0 / 255.0;
+        }
+    }
+    else if(chn == OscChannel::CH_B)
+    {
+        /* 电压幅值比 */
+        uint8_t altitudeByteB = 0;      
+        m_zeroVoltageB = m_mapChBZeroVoltage.value(range);
+        altitudeByteB = m_mapChBVoltageAmplitudeRatio.value(range);
+        m_diffVoltageB = m_zeroVoltageB - 128;
+
+        if(range == OscVoltageRange::CR_100MV)
+        {
+            m_voltageCalibrationB = (altitudeByteB * 2) / 255.0;
+            m_rangeRatioB = 0.1 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_250MV)
+        {
+            m_voltageCalibrationB = (altitudeByteB * 2) / 255.0;
+            m_rangeRatioB = 0.25 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_500MV)
+        {
+            m_voltageCalibrationB = (altitudeByteB * 2) / 255.0;
+            m_rangeRatioB = 0.5 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_1V)
+        {
+            m_voltageCalibrationB = (altitudeByteB * 2) / 255.0;
+            m_rangeRatioB = 1.0 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_2V5)
+        {
+            m_voltageCalibrationB = (altitudeByteB * 2) / 255.0;
+            m_rangeRatioB = 2.5 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_5V)
+        {
+            m_voltageCalibrationB = (altitudeByteB * 2) / 255.0;
+            m_rangeRatioB = 5.0 / 255.0;
+        }
+        else if(range == OscVoltageRange::CR_8V)
+        {
+            m_voltageCalibrationB = (altitudeByteB * 2) / 255.0;
+            m_rangeRatioB = 8.0 / 255.0;
+        }
+    }
+
+    
+}
+
+
+/* 校准电压 */
+double OneOscilloscopeData::calibrationVoltageA(uint8_t& data)
+{
+    return m_voltageCalibrationA * m_rangeRatioA * (data - m_zeroVoltageA);
+}
+
+double OneOscilloscopeData::calibrationVoltageB(uint8_t& data)
+{
+    return m_voltageCalibrationB * m_rangeRatioB * (data - m_zeroVoltageB);
+}
+

EyeMap/OscData/OneOscData.h

@@ -0,0 +1,146 @@
+#ifndef _OneOscilloscopeData_H_
+#define _OneOscilloscopeData_H_
+
+#include <QObject>
+#include <QMap>
+
+#include "USBInterFace.h"
+#include "spdlog/spdlog.h"
+#include "GlobalInfo.h"
+#include "OscDataInfo.h"
+#include "RingQueue/RingQueue.hpp"
+
+#define OneOscData OneOscilloscopeData::getInstance()
+
+class OneOscilloscopeData : public QObject
+{
+    Q_OBJECT
+
+const uint32_t BUFFER_SIZE = 1024 * 128 ;    /* 缓冲区大小，OSCA02的缓冲区应该是128KB的SRAM */
+
+private:
+    
+    OneOscilloscopeData(const OneOscilloscopeData&) = delete;
+    OneOscilloscopeData& operator=(const OneOscilloscopeData&) = delete;
+public:
+    OneOscilloscopeData();
+    ~OneOscilloscopeData();
+
+    static OneOscilloscopeData& getInstance()
+    {
+        static OneOscilloscopeData instance;
+        return instance;
+    }
+    /* 初始化示波器 */
+    void initOsc();
+    /* 打开示波器 */
+    bool openOSC();
+    /* 关闭示波器 */
+    void closeOSC();
+    /* 示波器是否打开 */
+    bool isOpen() { return m_isOpen; }
+    /* 开始采集数据 */
+    bool startCapture();
+    /* 停止采集数据 */
+    void stopCapture();
+
+    /***** 设置示波器的功能命令 *****/
+    /* 设置示波器的采样率 */
+    void setSampleRate(OscSampleRate rate);
+    /* 将示波器两个通道合并为一个通道 */
+    void setChannelMerge(bool merge);
+    /* 设置通道A输入量程 */
+    void setChannelARange(OscVoltageRange range);
+    /* 设置通道B输入量程 */
+    void setChannelBRange(OscVoltageRange range);
+    /* 设置通道耦合方式 */
+    void setChannelCoupling(OscChannel channel, OscChannelCoupling coupling);
+    /* 开启或关闭通道A触发 */
+    void setChannelATrigger(bool enable);
+    /* 开启外触发 */
+    void setExternalTrigger(bool enable);
+    /* 设置触发方式 */
+    void setTriggerMode(OscTriggerMode mode);
+    /* 设置触发电平 */
+    void setTriggerLevel(unsigned char level);
+    /* 设置触发灵敏度 */
+    void setTriggerSensitivity(OscTriggerSensitivity sensitivity);
+    /* 设置触发在缓冲区的哪个位置 */
+    void setTriggerPosition(unsigned char lowByte, unsigned char highByte);
+
+    /* 获取示波器不同档位下的零电压值 */
+    void getZeroVoltage();
+    /* 打印出零电压值 */
+    void printZeroVoltage(OscChannel channel);
+
+    /* 获取不同档位下电压校准系数 */
+    void getVoltageCalibration();
+    /* 打印出电压校准系数 */
+    void printVoltageCalibration(OscChannel channel);
+
+// private:
+public:
+    /* 采集数据，这个是子线程 */
+    void threadCaptureData();
+    /* 处理数据线程 */
+    void threadSeparateData();
+    /* 处理A通道数据 */
+    void threadProcessData_A();
+    /* 处理B通道数据 */
+    void threadProcessData_B();
+
+    /* 解析数据，眼图需要的数据 */
+    void parseEyeMapData(OscChannel chn, unsigned char* buffer, unsigned int size);
+    /* 设置零电压值和电压校准系数 */
+    void setZeroVoltageAndCalibration(OscChannel chn, OscVoltageRange range);
+    /* 校准电压 */
+    inline double calibrationVoltageA(uint8_t& data);
+    inline double calibrationVoltageB(uint8_t& data);
+
+private:
+    std::shared_ptr<spdlog::logger> m_logger = nullptr;
+    std::shared_ptr<USBInterface> m_usbInterface = nullptr;
+    std::atomic_bool m_isOpen = false;                      /* 示波器是否打开 */
+    std::atomic_bool m_runCapture = false;                  /* 采集数据的线程标志 */
+    std::atomic_bool m_isRunCapture = false;                /* 采集数据的线程运行标志，这个标志位作为线程运行的标志 */
+    std::atomic_bool m_isCapturedData = false;              /* 是否采集到数据 */
+    std::condition_variable m_condCapture;                  /* 采集数据的条件变量 */
+    std::condition_variable m_condBuffer_A;                 /* 通道A的条件变量 */
+    std::condition_variable m_condBuffer_B;                 /* 通道B的条件变量 */
+    std::mutex m_mutexBuffer;                               /* 互斥锁，用于保护采集到的数据 */
+    std::mutex m_mutexBuffer_A;                             /* 互斥锁，用于保护采集到的数据 */
+    std::mutex m_mutexBuffer_B;                             /* 互斥锁，用于保护采集到的数据 */
+    unsigned char* m_devBuffer = nullptr;                   /* 设备缓冲区指针，拷贝数据用的 */
+    unsigned char* m_buffer = nullptr;                      /* 缓冲区指针，用于存储拷贝出来的数据 */
+    unsigned char* m_bufferChnA = nullptr;                  /* 通道A的缓冲区指针 */
+    unsigned char* m_bufferChnB = nullptr;                  /* 通道B的缓冲区指针 */
+    RingQueue<unsigned char*> m_ringQueue;                  /* 环形队列，用于存储示波器采集到的数据 */
+
+    unsigned char m_ctrlByte0 = 0;                          /* 控制字节0 */
+    unsigned char m_ctrlByte1 = 0;                          /* 控制字节1 */
+
+    QMap<OscVoltageRange, unsigned char> m_mapChAZeroVoltage;   /* 通道A的零电压值 */
+    QMap<OscVoltageRange, unsigned char> m_mapChBZeroVoltage;   /* 通道B的零电压值 */
+    QMap<OscVoltageRange, unsigned char> m_mapChAVoltageAmplitudeRatio;     /* 通道A的电压校准系数 */
+    QMap<OscVoltageRange, unsigned char> m_mapChBVoltageAmplitudeRatio;     /* 通道B的电压校准系数 */
+
+    unsigned char m_zeroVoltageA = 0;                       /* 通道A零电压值 */
+    unsigned char m_zeroVoltageB = 0;                       /* 通道B零电压值 */
+    char m_diffVoltageA = 0;                                /* 通道A零电压差值 */
+    char m_diffVoltageB = 0;                                /* 通道B零电压差值 */
+    double m_voltageCalibrationA = 0;                       /* 通道A电压校准系数 */
+    double m_voltageCalibrationB = 0;                       /* 通道B电压校准系数 */
+    double m_rangeRatioA = 0.0;                             /* 通道A量程比例 */
+    double m_rangeRatioB = 0.0;                             /* 通道B量程比例 */
+
+    /************* 数据指针 *************/
+    EyeDataMatrix* m_eyeDataMatrix_A = nullptr;               /* 眼图数据矩阵，A通道 */
+    EyeDataMatrix* m_eyeDataMatrix_B = nullptr;               /* 眼图数据矩阵，B通道 */
+    EyeMapMatrix* m_eyeMapMatrix_A = nullptr;                 /* 眼图矩阵，A通道 */
+    EyeMapMatrix* m_eyeMapMatrix_B = nullptr;                 /* 眼图矩阵，B通道 */
+};
+
+
+
+
+#endif /* _OneOscilloscopeData_H_ */

EyeMap/OscData/OscData.h → EyeMap/OscData/OscData.h_

@@ -7,6 +7,7 @@
 #include "USBInterFace.h"
 #include "spdlog/spdlog.h"
 #include "GlobalInfo.h"
+#include "OscDataInfo.h"
 #include "RingQueue/RingQueue.hpp"
 
 #define OscData OscilloscopeData::getInstance()

EyeMap/main.cpp

@@ -7,6 +7,7 @@
 #include "logs/loginit.h"
 #include "EyeMapWidget.h"
 #include "EyeMapInfo.h"
+#include "OscDataInfo.h"
 
 void addFont();
 
@@ -27,6 +28,8 @@ int main(int argc, char* argv[])
     addFont();
     /* 初始化数据 */
     GEyeMapInfo.initEyeMapInfo();
+    /* 初始化示波器的数据类 */
+    OscDataInfo.initOscData();
 
     EyeMapWidget w;
     w.show();