V0.6.3

1、眼图的数据部分基本完成了
2、设置功能对示波器的控制的完成了
3、添加了示波器的状态，未打开会显示无设备图片

EyeMap/EyeMapWidget/eyemapwidget.cpp

@@ -74,6 +74,13 @@ EyeMapWidget::~EyeMapWidget()
     delete ui;
 }
 
+/* 开始采集 */
+void EyeMapWidget::startCapture()
+{
+
+    GOscDataInfo.startAllCapture();
+}
+
 
 void EyeMapWidget::do_exit()
 {
@@ -123,16 +130,20 @@ void EyeMapWidget::do_pBtnSettingNum()
     settingNum->setChannelList(GEyeMapInfo.getChannelInfo());
     settingNum->exec();
     /* 判断是否点击的是ok，是则重新布局 */
-    if(settingNum->isOk)
+    if(!settingNum->isOk)
     {
-        m_row = settingNum->row;
-        m_column = settingNum->column;
-        eyeMapLayout();
+        return;
     }
-    // for(const auto &it : GEyeMapInfo.getEyeMapList())
-    // {
-    //     SPDLOG_LOGGER_DEBUG(m_logger, "配置完成后的眼图序号: {}, 通道号:{} ", it->getNum(), it->getChannelInfo().channelName.toStdString());
-    // }
+    /* 先暂停所有的采集 */
+    GOscDataInfo.stopAllCapture();
+    m_row = settingNum->row;
+    m_column = settingNum->column;
+    eyeMapLayout();
+    /* 重置眼图数据矩阵 */
+    resetMatrix();
+    
+    /* 开启采集 */
+    GOscDataInfo.startAllCapture();
 }
 
 /* 设置眼图参数的槽函数 */
@@ -142,10 +153,24 @@ void EyeMapWidget::do_pBtnSettingParam()
     paramConfig->createItem(GEyeMapInfo.getEyeMapInfo());
     paramConfig->exec();
     /* 判断是否点击了确定按钮 */
-    if(paramConfig->isOk)
+    if(!paramConfig->isOk)
+    {
+        return;
+    }
+    GOscDataInfo.stopAllCapture();
+    /* 重置眼图数据矩阵 */
+    resetMatrix();
+    /* 根据已经被更新好的全局眼图参数，对示波器类单独设置 */
+    for(const auto &it : GEyeMapInfo.getEyeMapList())
     {
-        
+        /* 根据通道号更新电压值 */
+        GOscDataInfo.setVoltageRange(it->getChannelInfo().channel, it->getVoltageRange());
+        /* 更新时间刻度 */
+        GOscDataInfo.setTimeGridValue(it->getChannelInfo().channel, it->getTimeGridValue());
     }
+
+    /* 开启采集 */
+    GOscDataInfo.startAllCapture();
 }
 
 /* 初始化眼图 */
@@ -170,6 +195,12 @@ void EyeMapWidget::initEyeMap()
     m_column = GEyeMapInfo.column;
     eyeMapLayout();
 
+    /* 根据示波器打开的情况判断是刷新网格还是显示“暂无设备” */
+    for(const auto &it : GOscDataInfo.getOsc())
+    {
+        GEyeMapInfo.setEyeMapOscOpen(it->getOscNum(), it->isOpen());
+    }
+    update();
 }
 
 
@@ -263,3 +294,20 @@ void EyeMapWidget::eyeMapLayout()
     }
 }
 
+
+
+/* 清空数据矩阵内容 */
+void EyeMapWidget::resetMatrix()
+{
+    /* 重新初始化数据矩阵 */
+    GOscDataInfo.resetDataMatrix();
+    /* 每个眼图模块的大小都是一样的，所以这里获取序号为1的眼图大小，1号是肯定会显示的 */
+    auto pEyeMap = GEyeMapInfo.findEyeMap(1);
+    if(pEyeMap == nullptr)
+    {
+        return;
+    }
+    auto size = pEyeMap->getEyeMapSize();
+    GOscDataInfo.resetColorMatrix(size.width(), size.height());
+}
+

EyeMap/EyeMapWidget/eyemapwidget.h

@@ -21,6 +21,8 @@ public:
     explicit EyeMapWidget(QWidget *parent = nullptr);
     ~EyeMapWidget();
 
+    /* 开始采集 */
+    void startCapture();
     // /* 设置显示的个数 */
     // void setShowNum(int num) { m_showNum = num; }
     // /* 获取显示的个数 */
@@ -40,6 +42,8 @@ private:
     void initEyeMap();
     /* 排列眼图布局 */
     void eyeMapLayout();
+    /* 清空数据矩阵内容 */
+    void resetMatrix();
 
 private:
     Ui::EyeMapWidget *ui;

EyeMap/GlobalInfo/EyeMapInfo.cpp

@@ -332,5 +332,33 @@ QString AllEyeMapInfo::getChannelName(OscChnNum channel)
 }
 
 
+/* 判断一个示波器是否有显示的眼图，有一个就返回true */
+bool AllEyeMapInfo::hasShowEyeMap(int oscNum)
+{
+    for(const auto& it : listEyeMapPtr)
+    {
+        if(it->getChannelInfo().channel == static_cast<OscChnNum>(oscNum) && it->getShow())
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+/* 根据示波器编号设置眼图状态 */
+void AllEyeMapInfo::setEyeMapOscOpen(int oscNum, bool isOpen)
+{
+    OscChnNum oscChn1 = static_cast<OscChnNum>(oscNum * 2 - 1);
+    OscChnNum oscChn2 = static_cast<OscChnNum>(oscNum * 2);
+    for(const auto& it : listEyeMapPtr)
+    {
+        if(it->getChannelInfo().channel == oscChn1 || it->getChannelInfo().channel == oscChn2)
+        {
+            it->setOpen(isOpen);
+        }
+    }
+}
+
+
 
 

EyeMap/GlobalInfo/EyeMapInfo.h

@@ -110,6 +110,12 @@ public:
     /* 获取通道号对应的通道名称 */
     static QString getChannelName(OscChnNum channel);
 
+    /* 判断一个示波器是否有显示的眼图 */
+    bool hasShowEyeMap(int oscNum);
+
+    /* 根据示波器编号设置眼图状态 */
+    void setEyeMapOscOpen(int oscNum, bool isOpen);
+
 public:
     QList<OneEyeMap*> listEyeMapPtr;                    /* 保存8个眼图的指针 */
     QList<OneChannelInfo> listChannelInfo;              /* 可用的通道号 */

EyeMap/GlobalInfo/OscDataInfo.cpp

@@ -128,7 +128,12 @@ std::shared_ptr<Vec2D> EyeDataMatrix::eyeZoomOut()
 }
 
 
-/* 初始化数据点 */
+/**
+ * @brief 初始化数据点
+ * 
+ * @param width 显示范围的宽
+ * @param height 显示范围的高
+ */
 void EyeMapMatrix::initEyeMapData(int width, int height)
 {
     mutexEyeData.lock();
@@ -273,7 +278,7 @@ OscilloscopeData::~OscilloscopeData()
     {
         delete it.value();
     }
-    for(auto it = mapOscData.begin(); it != mapOscData.end(); ++it)
+    for(auto it = mapOsc.begin(); it != mapOsc.end(); ++it)
     {
         delete it.value();
     }
@@ -304,6 +309,7 @@ void OscilloscopeData::initOscData()
         pOscData->initOSC(i);
         if(!pOscData->openOSC())
         {
+            
             continue;
         }
         /* 获取零电压值 */
@@ -311,12 +317,12 @@ void OscilloscopeData::initOscData()
         /* 获取电压校准系数 */
         pOscData->getVoltageCalibration();
 
-        mapOscData.insert(i, pOscData);
+        mapOsc.insert(i, pOscData);
     }
     /* 设置示波器参数 */
     for(const auto &it : GEyeMapInfo.listInitEyeMapInfo)
     {
-        auto pOsc = GOscDataInfo.findOscData(it.channelInfo.channel);
+        auto pOsc = GOscDataInfo.findOsc(it.channelInfo.channel);
         if(pOsc == nullptr)
         {
             continue;
@@ -356,7 +362,7 @@ EyeMapMatrix* OscilloscopeData::findEyeMapMatrix(OscChnNum channel)
 }
 
 /* 根据通道号查找示波器 */
-OneOscilloscopeData* OscilloscopeData::findOscData(OscChnNum oscNum)
+OneOscilloscopeData* OscilloscopeData::findOsc(OscChnNum oscNum)
 {
     int num = 0;
     switch (oscNum)
@@ -388,8 +394,8 @@ OneOscilloscopeData* OscilloscopeData::findOscData(OscChnNum oscNum)
         default:
             break;
     }
-    auto it = mapOscData.find(num);
-    if(it != mapOscData.end())
+    auto it = mapOsc.find(num);
+    if(it != mapOsc.end())
     {
         return it.value();
     }
@@ -399,7 +405,7 @@ OneOscilloscopeData* OscilloscopeData::findOscData(OscChnNum oscNum)
 /* 根据通道号设置电压范围 */
 void OscilloscopeData::setVoltageRange(OscChnNum oscNum, OscVoltageRange range)
 {
-    auto pOsc = findOscData(oscNum);
+    auto pOsc = findOsc(oscNum);
     if(pOsc == nullptr)
     {
         return;
@@ -414,3 +420,55 @@ void OscilloscopeData::setVoltageRange(OscChnNum oscNum, OscVoltageRange range)
     }
 }
 
+/* 根据通道号设置时间刻度值 */
+void OscilloscopeData::setTimeGridValue(OscChnNum oscNum, OscTimeGridValue value)
+{
+    auto pOsc = findOsc(oscNum);
+    if(pOsc == nullptr)
+    {
+        return;
+    }
+    pOsc->setTimeGridValue(value);
+}
+
+
+/* 清空数据矩阵 */
+void OscilloscopeData::resetDataMatrix()
+{
+    for(auto it = mapEyeDataMatrix.begin(); it != mapEyeDataMatrix.end(); ++it)
+    {
+        it.value()->initEyeData();
+    }
+}
+
+/* 清空颜色矩阵，重新初始化 */
+void OscilloscopeData::resetColorMatrix(int width, int height)
+{
+    for(auto it = mapEyeMapMatrix.begin(); it != mapEyeMapMatrix.end(); ++it)
+    {
+        it.value()->initEyeMapData(width, height);
+    }
+}
+
+/* 暂停所有的采集 */
+void OscilloscopeData::stopAllCapture()
+{
+    for(const auto& it : getOsc())
+    {
+        it->stopCapture();
+    }
+}
+
+/* 开启所有的采集 */
+void OscilloscopeData::startAllCapture()
+{
+    for(const auto& it : getOsc())
+    {
+        /* 判断是否显示的眼图，示波器对应的两个眼图都不显示则不开启采集 */
+        if(GEyeMapInfo.hasShowEyeMap(it->getOscNum()))
+        {
+            it->startCapture();
+        }
+    }
+}
+

EyeMap/GlobalInfo/OscDataInfo.h

@@ -159,13 +159,13 @@ public:
     }
 
     /* 示波器相关参数 */
-    int oneGridTime = 200;          /* 一个时间格子的时间长度（单位ns） */
-    double SampleIntervalTime = 0;     /* 采样点之间的时间间隔，单位ns（采样率的倒数，设置采样率的时候会设置） */
+    // int oneGridTime = 200;          /* 一个时间格子的时间长度（单位ns） */
+    // double SampleIntervalTime = 0;     /* 采样点之间的时间间隔，单位ns（采样率的倒数，设置采样率的时候会设置） */
 
     /* 其他参数 */
     const int dataNumPerPixar = 1;  /* 这个是SetInfo的第一个参数，固定是1，在眼图中会使用 */
     /* 眼图参数 */
-    int eyeMapWidth = g_HorPixel;         /* 眼图x轴宽度（像素矩形的个数） */
+    // int eyeMapWidth = g_HorPixel;         /* 眼图x轴宽度（像素矩形的个数） */
 
     
 
@@ -204,11 +204,23 @@ public:
     /* 查找EyeMapMatrix */
     EyeMapMatrix* findEyeMapMatrix(OscChnNum channel);
     /* 获取示波器列表 */
-    QMap<int, OneOscilloscopeData*>& getOscData() { return mapOscData; }
+    QMap<int, OneOscilloscopeData*>& getOsc() { return mapOsc; }
     /* 根据通道号查找示波器 */
-    OneOscilloscopeData* findOscData(OscChnNum oscNum);
+    OneOscilloscopeData* findOsc(OscChnNum oscNum);
     /* 根据通道号设置电压范围 */
     void setVoltageRange(OscChnNum oscNum, OscVoltageRange range);
+    /* 根据通道号设置时间刻度值 */
+    void setTimeGridValue(OscChnNum oscNum, OscTimeGridValue value);
+
+    /* 清空数据矩阵 */
+    void resetDataMatrix();
+    /* 清空颜色矩阵 */
+    void resetColorMatrix(int width, int height);
+
+    /* 暂停所有的采集 */
+    void stopAllCapture();
+    /* 开启所有的采集 */
+    void startAllCapture();
 
 private:
     /************ 数据相关 ************/
@@ -217,7 +229,7 @@ private:
     /* 眼图颜色矩阵 */
     QMap<OscChnNum, EyeMapMatrix*> mapEyeMapMatrix;
     /* 示波器类指针，int是示波器编号 */
-    QMap<int, OneOscilloscopeData*> mapOscData;
+    QMap<int, OneOscilloscopeData*> mapOsc;
 };
 
 

EyeMap/OneEyeMap/OneEyeMap.cpp

@@ -61,7 +61,9 @@ OneEyeMap::OneEyeMap(QWidget *parent) :
     m_rectEyeMap.setWidth(m_rectScaleValue.width() - m_leftMargin - m_rightMargin);
     m_rectEyeMap.setHeight(m_rectScaleValue.height() - m_topMargin - m_bottomMargin);
 
-    /* 初始化全局数据 */
+    /* 设置“暂无设备”、“设备离线”图片 */
+    m_pixmapNoDevice = new QPixmap(":/image/Resource/image/dev_none.png");
+    m_pixmapDeviceOffline  = new QPixmap(":/image/Resource/image/dev_outline.png");
     
     /* 设置定时器 */
     m_timer.setTimerType(Qt::PreciseTimer);
@@ -168,13 +170,22 @@ void OneEyeMap::paintEvent(QPaintEvent *event)
     {
         return;
     }
-    m_eyeMapMatrix->mutexEyeData.lock();
     QPainter painter(this);
-    
     painter.setRenderHint(QPainter::Antialiasing, true);
-    
-    /******************** 绘制标题背景 ********************/
-    /* 标题栏的背景在setTitleBarColor函数中设置 */
+
+    /******************** 绘制背景 ********************/
+    drawBackground(painter);
+
+    /* 判断设备是否打开，没打开就显示“暂无设备”图片 */
+    if(!m_isOpen)
+    {
+        ui->widget_title->hide();
+        drawNoDevice(painter);
+        return;
+    }
+    ui->widget_title->show();
+
+    m_eyeMapMatrix->mutexEyeData.lock();
 
     /******************** 绘制刻度值 ********************/
     drawScaleValue(painter);
@@ -217,8 +228,8 @@ void OneEyeMap::resizeEvent(QResizeEvent *event)
     event->accept();
 }
 
-/* 绘制刻度区域 */
-void OneEyeMap::drawScaleValue(QPainter &painter)
+/* 绘制背景 */
+void OneEyeMap::drawBackground(QPainter &painter)
 {
     /* 绘制背景颜色 */
     painter.setPen(Qt::NoPen);
@@ -227,7 +238,11 @@ void OneEyeMap::drawScaleValue(QPainter &painter)
     brush.setStyle(Qt::SolidPattern);
     painter.setBrush(brush);
     painter.drawRect(m_rectScaleValue);
+}
 
+/* 绘制刻度区域 */
+void OneEyeMap::drawScaleValue(QPainter &painter)
+{
     /* 绘制刻度值 */
     QPen pen;
     pen.setColor("#C8CCD2");
@@ -401,6 +416,14 @@ void OneEyeMap::drawEyeMap(QPainter &painter)
     }
 }
 
+/* 绘制“暂无设备” */
+void OneEyeMap::drawNoDevice(QPainter &painter)
+{
+    int x = (this->width() - m_pixmapNoDevice->width()) / 2;
+    int y = (this->height() - m_pixmapNoDevice->height()) / 2;
+    painter.drawPixmap(x, y, *m_pixmapNoDevice);
+}
+
 /* 获取一个格子的电压值 */
 QString OneEyeMap::getVScaleValue(int index)
 {

EyeMap/OneEyeMap/OneEyeMap.h

@@ -26,6 +26,8 @@ public:
     /* 根据通道号获取数据指针 */
     void setEyeDataPtrFromOscData(OscChnNum channel);
 
+    /* 设置对应的示波器是否已经打开 */
+    void setOpen(bool isOpen) { m_isOpen = isOpen; }
     /* 设置序号 */
     void setNum(int num) { m_info.num = num; }
     /* 获取序号 */
@@ -59,6 +61,8 @@ public:
     /* 只更新设置个数页面的信息 */
     void updateSettingNum(const OneEyeMapInfo &info);
 
+    /* 获取眼图显示区域的大小 */
+    QSize getEyeMapSize() { return m_rectEyeMap.size(); }
 
 signals:
     void signal_update();
@@ -72,12 +76,16 @@ protected:
     void resizeEvent(QResizeEvent *event) override;
 
 private:
+    /* 绘制背景 */
+    void drawBackground(QPainter &painter);
     /* 绘制刻度值区域 */
     void drawScaleValue(QPainter &painter);
     /* 绘制刻度 */
     void drawScale(QPainter &painter);
     /* 绘制眼图区域 */
     void drawEyeMap(QPainter &painter);
+    /* 绘制暂无设备 */
+    void drawNoDevice(QPainter &painter);
 
     /* 获取一个格子的电压值 */
     inline QString getVScaleValue(int index);
@@ -90,10 +98,8 @@ private:
     std::shared_ptr<spdlog::logger> m_logger = nullptr;
 
     /* 组件属性信息 */
-    // bool m_isShow = false;              /* 是否显示 */
-    // int m_num;                          /* 序号 */
-    // QString m_title;                    /* 标题 */
-    // QColor m_color;                     /* 颜色 */
+    bool m_isOpen = false;              /* 是否示波器 */
+
     OneEyeMapInfo m_info;               /* 组件信息 */
 
     QTimer m_timer;
@@ -113,6 +119,9 @@ private:
     // OscTimeGridValue m_tGridValue = OscTimeGridValue::TGV_200NS;    /* 时间刻度值 */
 
     EyeMapMatrix* m_eyeMapMatrix = nullptr; /* 眼图矩阵，从外面获取 */
+
+    QPixmap* m_pixmapNoDevice = nullptr; /* 暂无设备图片 */
+    QPixmap* m_pixmapDeviceOffline = nullptr; /* 设备离线图片 */
 };
 
 #endif // ONEEYEMAP_H

EyeMap/OscData/OneOscData.cpp

@@ -1,6 +1,7 @@
 #include "OneOscData.h"
 #include <QApplication>
 #include <QRandomGenerator>
+#include <chrono>
 
 #include "ThreadPool/ThreadPool.h"
 
@@ -82,6 +83,9 @@ void OneOscilloscopeData::initOSC(int oscNum)
     m_buffer = new unsigned char[BUFFER_SIZE];
     m_bufferChnA = new unsigned char[BUFFER_SIZE / 2];
     m_bufferChnB = new unsigned char[BUFFER_SIZE / 2];
+
+    /* 设置默认的初始化参数 */
+    m_oneTimeGrid = 200;
 }
 
 /* 打开示波器 */
@@ -157,6 +161,12 @@ bool OneOscilloscopeData::startCapture()
         SPDLOG_LOGGER_ERROR(m_logger, "缓冲区指针为空!");
         return false;
     }
+    /* 判断示波器是否已经打开成功 */
+    if(!m_isOpen)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "示波器{}未打开!", m_oscNum);
+        return false;
+    }
     /* 启动子线程 */
     m_runCapture = true;
     CPPTP.add_task(&OneOscilloscopeData::threadCaptureData, this);
@@ -176,9 +186,9 @@ void OneOscilloscopeData::stopCapture()
     m_runCapture = false;
     while (m_isRunCapture)
     {
-        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
-    SPDLOG_LOGGER_INFO(m_logger, "停止采集数据");
+    SPDLOG_LOGGER_INFO(m_logger, "示波器{}已停止采集数据", m_oscNum);
 }
 
 /* 设置示波器的采样率 */
@@ -193,27 +203,27 @@ void OneOscilloscopeData::setSampleRate(OscSampleRate rate)
     if(rate == OscSampleRate::SR_49KHZ)
     {
         m_ctrlByte0 |= 0x0e;
-        OscParams.SampleIntervalTime = 20408.16;
+        m_SampleIntervalTime.store(20408.16);
     }
     else if(rate == OscSampleRate::SR_96KHZ)
     {
         m_ctrlByte0 |= 0x04;
-        OscParams.SampleIntervalTime = 10416.67;
+        m_SampleIntervalTime.store(10416.67);
     }
     else if(rate == OscSampleRate::SR_781KHZ)
     {
         m_ctrlByte0 |= 0x0c;
-        OscParams.SampleIntervalTime = 1280.0;
+        m_SampleIntervalTime.store(1280.0);
     }
     else if(rate == OscSampleRate::SR_12_5MHZ)
     {
         m_ctrlByte0 |= 0x08;
-        OscParams.SampleIntervalTime = 80.0;
+        m_SampleIntervalTime.store(80.0);
     }
     else if(rate == OscSampleRate::SR_100MHZ)
     {
         m_ctrlByte0 |= 0x00;
-        OscParams.SampleIntervalTime = 10;
+        m_SampleIntervalTime.store(10);
     }
     else
     {
@@ -511,6 +521,14 @@ void OneOscilloscopeData::setTriggerPosition(unsigned char lowByte, unsigned cha
     m_usbInterface->usbCtrlTrans(0x17, highByte);
 }
 
+/* 设置时间刻度 */
+void OneOscilloscopeData::setTimeGridValue(OscTimeGridValue value)
+{
+    m_oneTimeGrid = static_cast<int>(value);
+    /* 修改时间刻度理论上需要清空已有的缓存 */
+
+}
+
 /* 获取示波器不同档位下的零电压值 */
 void OneOscilloscopeData::getZeroVoltage()
 {
@@ -680,6 +698,8 @@ void OneOscilloscopeData::threadCaptureData()
 {
     SPDLOG_LOGGER_INFO(m_logger, "开始采集数据线程");
     m_isRunCapture = true;
+    /* 这个记录等待数据的时间间隔，超过一定时间就认为设备离线了 */
+    std::chrono::steady_clock::time_point timePoint = std::chrono::steady_clock::now();
     // unsigned char* buffer = nullptr;
     while(m_runCapture)
     {
@@ -693,9 +713,18 @@ void OneOscilloscopeData::threadCaptureData()
         }
         /* 查询数据是否采集完成（应该是填充满128KB的SRAM）
          * 注意，这里是十进制33，不是0x33 */
+         timePoint = std::chrono::steady_clock::now();
         while(m_usbInterface->usbCtrlTransSimple(0x50) != 33)
         {
             std::this_thread::sleep_for(std::chrono::microseconds(10));
+            /* 如果超过1s还没有数据，就认为设备离线了 */
+            if(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - timePoint).count() > 1)
+            {
+                SPDLOG_LOGGER_ERROR(m_logger, "示波器{}离线!", m_oscNum);
+                m_isConnected.store(false);
+                m_isRunCapture = false;
+                return;
+            }
         }
         // SPDLOG_LOGGER_DEBUG(m_logger, "硬件缓冲区已满");
         /* 将数据从示波器的SRAM中拷贝到电脑内存中，1次传输完成，设置超时时间1ms */
@@ -804,7 +833,7 @@ void OneOscilloscopeData::threadProcessData_B()
  *          x轴时间是1000分度，当x轴整体时间是10us的时候，采样点和分辨率一一对应
  *          x轴时间大于10us，采样点比分辨率高，无需做什么操作
  *          x轴时间小于10us，采样点数量会小于1000，那么绘制的矩形小点间隔会比较长，这时候就需要进行插帧
- *        2、屏幕中显示多少波形和波形的频率及时间屏幕可以现实的时间长度有关，波形的频率未知，所以这里只能通过调整时间长度来调整波形
+ *        2、屏幕中显示多少波形和波形的频率及时间屏幕可以显示的时间长度有关，波形的频率未知，所以这里只能通过调整时间长度来调整波形
  *          在屏幕中显示的数目
  *        3、当时间长度变小，小到整个屏幕的采样点数目不足1000的时候，就需要进行插值，插值到1000附近
  * 
@@ -864,23 +893,16 @@ void OneOscilloscopeData::parseEyeMapData(OscChannel chn, unsigned char* buffer,
 
     /* ======================================================================== */
     /* 将采样点添加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 oneGridSa = m_oneTimeGrid / m_SampleIntervalTime;       /* 当前一个格子中采样点的数目 */
     int saTotal = oneGridSa * 10;       /* 一个时间格子中采样点的总数 */
-    bool isNeedFrameInsertion = ( saTotal < OscParams.eyeMapWidth ) ? true : false;
+    /* 采样点个数小于颜色矩阵x方向的个数，就进行插帧 */
+    bool isNeedFrameInsertion = ( saTotal < g_HorPixel ) ? true : false;
 
     int num9 = (int)((double)oneGridSa * 0.25);       /* 1/4个时间格子长度 */
     /* 记录buffer的值，并添加bool */

EyeMap/OscData/OneOscData.h

@@ -39,6 +39,7 @@ public:
     void closeOSC();
     /* 示波器是否打开 */
     bool isOpen() { return m_isOpen; }
+    /*  */
     /* 开始采集数据 */
     bool startCapture();
     /* 停止采集数据 */
@@ -67,6 +68,8 @@ public:
     void setTriggerSensitivity(OscTriggerSensitivity sensitivity);
     /* 设置触发在缓冲区的哪个位置 */
     void setTriggerPosition(unsigned char lowByte, unsigned char highByte);
+    /* 设置时间刻度 */
+    void setTimeGridValue(OscTimeGridValue value);
 
     /* 获取示波器不同档位下的零电压值 */
     void getZeroVoltage();
@@ -78,8 +81,11 @@ public:
     /* 打印出电压校准系数 */
     void printVoltageCalibration(OscChannel channel);
 
-// private:
-public:
+    /***** 示波器其他属性 *****/
+    int getOscNum() { return m_oscNum; }
+
+private:
+// public:
     /* 采集数据，这个是子线程 */
     void threadCaptureData();
     /* 处理数据线程 */
@@ -104,6 +110,7 @@ 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_isConnected = false;                 /* 示波器是否连接 */
     std::atomic_bool m_runCapture = false;                  /* 采集数据的线程标志 */
     std::atomic_bool m_isRunCapture = false;                /* 采集数据的线程运行标志，这个标志位作为线程运行的标志 */
     std::atomic_bool m_isCapturedData = false;              /* 是否采集到数据 */
@@ -120,6 +127,7 @@ private:
     // RingQueue<unsigned char*> m_ringQueue;                  /* 环形队列，用于存储示波器采集到的数据 */
 
     int m_oscNum = 0;                                       /* 示波器编号 */
+    
 
     /************* 示波器控制相关 *************/
     unsigned char m_ctrlByte0 = 0;                          /* 控制字节0 */
@@ -139,6 +147,10 @@ private:
     double m_rangeRatioA = 0.0;                             /* 通道A量程比例 */
     double m_rangeRatioB = 0.0;                             /* 通道B量程比例 */
 
+    std::atomic_int m_oneTimeGrid = 0;                      /* 一个时间刻度的时间长度，单位ns，和枚举值OscTimeGridValue相对应 */
+    std::atomic<double> m_SampleIntervalTime = 0;           /* 采样点之间的时间间隔，单位ns（采样率的倒数，设置采样率的时候会设置） */
+    // std::atomic_int m_eyeMapWidth = 0;                      /* 眼图x轴宽度（像素矩形的个数） */
+
     /************* 数据指针 *************/
     EyeDataMatrix* m_eyeDataMatrix_A = nullptr;               /* 眼图数据矩阵，A通道 */
     EyeDataMatrix* m_eyeDataMatrix_B = nullptr;               /* 眼图数据矩阵，B通道 */

EyeMap/main.cpp

@@ -33,6 +33,7 @@ int main(int argc, char* argv[])
 
     EyeMapWidget w;
     w.show();
+    w.startCapture();
 
     return app.exec();
 }