V0.2

1、读取出了示波器的数据
2、读取到的数据应该有问题，都是128

EyeMap/OscData.cpp

@@ -3,12 +3,32 @@
 #include "ThreadPool/ThreadPool.h"
 
 
-OscData::OscData()
+OscilloscopeData::OscilloscopeData()
+{
+    
+}
+
+
+OscilloscopeData::~OscilloscopeData()
+{
+    if(m_isOpen)
+    {
+        closeOSC();
+    }
+    if(m_buffer != nullptr)
+    {
+        delete[] m_buffer;
+        m_buffer = nullptr;
+    }
+}
+
+/* 初始化示波器 */
+void OscilloscopeData::initOsc()
 {
     m_logger = spdlog::get("OscData");
     if(m_logger == nullptr)
     {
-        SPDLOG_ERROR("获取 OSC logger 失败");
+        SPDLOG_ERROR("获取 OscData logger 失败");
         return;
     }
     m_usbInterface = std::make_shared<USBInterface>();
@@ -18,21 +38,18 @@ OscData::OscData()
     }
     /* 分配缓冲区内存 */
     m_buffer = new unsigned char[BUFFER_SIZE];
+    m_bufferChnA = new unsigned char[BUFFER_SIZE / 2];
+    m_bufferChnB = new unsigned char[BUFFER_SIZE / 2];
 }
 
-
-OscData::~OscData()
+/* 打开示波器 */
+bool OscilloscopeData::openOSC()
 {
-    if(m_buffer != nullptr)
+    if(m_usbInterface == nullptr)
     {
-        delete[] m_buffer;
-        m_buffer = nullptr;
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return false;
     }
-}
-
-/* 打开示波器 */
-bool OscData::openOSC()
-{
     /* 指定示波器设备型号，OSCA02是6 */
     m_usbInterface->specifyDevId(6);
     auto ret = m_usbInterface->devOpen();
@@ -44,18 +61,18 @@ bool OscData::openOSC()
     /* 设置缓冲区大小 */
     m_usbInterface->setInfo(BUFFER_SIZE);
     /* 获取缓冲区首指针 */
-    m_buffer = m_usbInterface->bufferWR(-1);
-    if(m_buffer == nullptr)
+    m_devBuffer = m_usbInterface->bufferWR(-1);
+    if(m_devBuffer == nullptr)
     {
         SPDLOG_LOGGER_ERROR(m_logger, "获取缓冲区指针失败!");
         return false;
     }
-
+    m_isOpen = true;
     return true;
 }
 
 /* 关闭示波器 */
-void OscData::closeOSC()
+void OscilloscopeData::closeOSC()
 {
     if(m_runCapture)
     {
@@ -69,10 +86,12 @@ void OscData::closeOSC()
     {
         m_usbInterface->devClose();
     }
+    m_isOpen = false;
+    SPDLOG_INFO("示波器已关闭");
 }
 
 /* 开始采集数据 */
-bool OscData::startCapture()
+bool OscilloscopeData::startCapture()
 {
     if(m_buffer == nullptr)
     {
@@ -81,18 +100,19 @@ bool OscData::startCapture()
     }
     /* 启动子线程 */
     m_runCapture = true;
-    CPPTP.add_task(&OscData::threadCaptureData, this);
+    CPPTP.add_task(&OscilloscopeData::threadCaptureData, this);
+    CPPTP.add_task(&OscilloscopeData::threadProcessData, this);
     return true;
 }
 
 /* 停止采集数据 */
-void OscData::stopCapture()
+void OscilloscopeData::stopCapture()
 {
     m_runCapture = false;
 }
 
 /* 设置示波器的采样率 */
-void OscData::setSampleRate(OscSampleRate rate)
+void OscilloscopeData::setSampleRate(OscSampleRate rate)
 {
     if(m_usbInterface == nullptr)
     {
@@ -133,7 +153,7 @@ void OscData::setSampleRate(OscSampleRate rate)
  *        将AB两个通道的资源全部给A，B通道失效，A通道的采样率和带宽翻倍
  * @param merge 是否合并
  */
-void OscData::setChannelMerge(bool merge)
+void OscilloscopeData::setChannelMerge(bool merge)
 {
     if(m_usbInterface == nullptr)
     {
@@ -149,25 +169,448 @@ void OscData::setChannelMerge(bool merge)
     m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
 }
 
+/* 设置通道A输入量程 */
+void OscilloscopeData::setChannelARange(OscChannelRange range)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    m_ctrlByte1 &= 0xf7;
+    if(range == OscChannelRange::CR_100MV)
+    {
+        m_usbInterface->usbCtrlTrans(0x22, 0x06);
+    }
+    else if(range == OscChannelRange::CR_250MV)
+    {
+        m_usbInterface->usbCtrlTrans(0x22, 0x04);
+    }
+    else if(range == OscChannelRange::CR_500MV)
+    {
+        m_usbInterface->usbCtrlTrans(0x22, 0x02);
+    }
+    else if(range == OscChannelRange::CR_1V)
+    {
+        m_ctrlByte1 |= 0x08;
+        m_usbInterface->usbCtrlTrans(0x22, 0x06);
+    }
+    else if(range == OscChannelRange::CR_2V5)
+    {
+        m_ctrlByte1 |= 0x08;
+        m_usbInterface->usbCtrlTrans(0x22, 0x04);
+    }
+    else if(range == OscChannelRange::CR_5V)
+    {
+        m_ctrlByte1 |= 0x08;
+        m_usbInterface->usbCtrlTrans(0x22, 0x02);
+    }
+    else if(range == OscChannelRange::CR_8V)
+    {
+        m_ctrlByte1 |= 0x08;
+        m_usbInterface->usbCtrlTrans(0x22, 0x00);
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "输入量程设置错误!");
+        return;
+    }
+    m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+}
+
+/* 设置通道B输入量程 */
+void OscilloscopeData::setChannelBRange(OscChannelRange range)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    m_ctrlByte1 &= 0xf9;
+    if(range == OscChannelRange::CR_100MV)
+    {
+        m_ctrlByte1 |= 0x06;
+        m_usbInterface->usbCtrlTrans(0x23, 0x40);
+    }
+    else if(range == OscChannelRange::CR_250MV)
+    {
+        m_ctrlByte1 |= 0x04;
+        m_usbInterface->usbCtrlTrans(0x23, 0x40);
+    }
+    else if(range == OscChannelRange::CR_500MV)
+    {
+        m_ctrlByte1 |= 0x02;
+        m_usbInterface->usbCtrlTrans(0x23, 0x40);
+    }
+    else if(range == OscChannelRange::CR_1V)
+    {
+        m_ctrlByte1 |= 0x06;
+        m_usbInterface->usbCtrlTrans(0x23, 0x00);
+    }
+    else if(range == OscChannelRange::CR_2V5)
+    {
+        m_ctrlByte1 |= 0x04;
+        m_usbInterface->usbCtrlTrans(0x23, 0x00);
+    }
+    else if(range == OscChannelRange::CR_5V)
+    {
+        m_ctrlByte1 |= 0x02;
+        m_usbInterface->usbCtrlTrans(0x23, 0x00);
+    }
+    else if(range == OscChannelRange::CR_8V)
+    {
+        m_usbInterface->usbCtrlTrans(0x23, 0x00);
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "输入量程设置错误!");
+        return;
+    }
+    m_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+}
+
+/**
+ * @brief 设置通道耦合方式
+ * 
+ * @param channel 通道
+ * @param coupling 耦合方式，DC或者AC
+ */
+void OscilloscopeData::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 OscilloscopeData::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 OscilloscopeData::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_usbInterface->usbCtrlTrans(0x24, m_ctrlByte1);
+    }
+}
+
+/* 设置触发方式 */
+void OscilloscopeData::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 OscilloscopeData::setTriggerLevel(unsigned char level)
+{
+    if(m_usbInterface == nullptr)
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "USBInterface指针为空!");
+        return;
+    }
+    m_usbInterface->usbCtrlTrans(0x16, level);
+}
+
+/* 设置触发灵敏度 */
+void OscilloscopeData::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 OscilloscopeData::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 OscilloscopeData::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(OscChannelRange::CR_8V, zeroVoltage);
+    /* 1V档位，正负5V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x01);
+    m_mapChAZeroVoltage.insert(OscChannelRange::CR_5V, zeroVoltage);
+    /* 500mV档位，正负2.5V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x0e);
+    m_mapChAZeroVoltage.insert(OscChannelRange::CR_2V5, zeroVoltage);
+    /* 200mV档位，正负1V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x14);
+    m_mapChAZeroVoltage.insert(OscChannelRange::CR_1V, zeroVoltage);
+    /* 100mV档位，正负500mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x12);
+    m_mapChAZeroVoltage.insert(OscChannelRange::CR_500MV, zeroVoltage);
+    /* 50mV档位，正负250mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x10);
+    m_mapChAZeroVoltage.insert(OscChannelRange::CR_250MV, zeroVoltage);
+    /* 20mV档位，正负100mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0xa0);
+    m_mapChAZeroVoltage.insert(OscChannelRange::CR_100MV, zeroVoltage);
+
+    /* 获取通道B零电压值 */
+    /* 2V档位，正负8V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x72);
+    m_mapChBZeroVoltage.insert(OscChannelRange::CR_8V, zeroVoltage);
+    /* 1V档位，正负5V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x02);
+    m_mapChBZeroVoltage.insert(OscChannelRange::CR_5V, zeroVoltage);
+    /* 500mV档位，正负2.5V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x0f);
+    m_mapChBZeroVoltage.insert(OscChannelRange::CR_2V5, zeroVoltage);
+    /* 200mV档位，正负1V量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x15);
+    m_mapChBZeroVoltage.insert(OscChannelRange::CR_1V, zeroVoltage);
+    /* 100mV档位，正负500mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x13);
+    m_mapChBZeroVoltage.insert(OscChannelRange::CR_500MV, zeroVoltage);
+    /* 50mV档位，正负250mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0x11);
+    m_mapChBZeroVoltage.insert(OscChannelRange::CR_250MV, zeroVoltage);
+    /* 20mV档位，正负100mV量程 */
+    zeroVoltage = m_usbInterface->usbCtrlTrans(0x90, 0xa1);
+    m_mapChBZeroVoltage.insert(OscChannelRange::CR_100MV, zeroVoltage);
+}
+
+/* 打印出零电压值 */
+void OscilloscopeData::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 OscilloscopeData::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_mapChAVoltageCalibration.insert(OscChannelRange::CR_8V, voltageCalibration);
+    /* 1V档位，正负5V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x03);
+    m_mapChAVoltageCalibration.insert(OscChannelRange::CR_5V, voltageCalibration);
+    /* 500mV档位，正负2.5V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x08);
+    m_mapChAVoltageCalibration.insert(OscChannelRange::CR_2V5, voltageCalibration);
+    /* 200mV档位，正负1V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x06);
+    m_mapChAVoltageCalibration.insert(OscChannelRange::CR_1V, voltageCalibration);
+    /* 100mV档位，正负500mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x09);
+    m_mapChAVoltageCalibration.insert(OscChannelRange::CR_500MV, voltageCalibration);
+    /* 50mV档位，正负250mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x0a);
+    m_mapChAVoltageCalibration.insert(OscChannelRange::CR_250MV, voltageCalibration);
+    /* 20mV档位，正负100mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x2a);
+    m_mapChAVoltageCalibration.insert(OscChannelRange::CR_100MV, voltageCalibration);
+
+    /* 获取通道B电压校准系数 */
+    /* 2V档位，正负8V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0xd2);
+    m_mapChBVoltageCalibration.insert(OscChannelRange::CR_8V, voltageCalibration);
+    /* 1V档位，正负5V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x04);
+    m_mapChBVoltageCalibration.insert(OscChannelRange::CR_5V, voltageCalibration);
+    /* 500mV档位，正负2.5V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x0b);
+    m_mapChBVoltageCalibration.insert(OscChannelRange::CR_2V5, voltageCalibration);
+    /* 200mV档位，正负1V量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x07);
+    m_mapChBVoltageCalibration.insert(OscChannelRange::CR_1V, voltageCalibration);
+    /* 100mV档位，正负500mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x0c);
+    m_mapChBVoltageCalibration.insert(OscChannelRange::CR_500MV, voltageCalibration);
+    /* 50mV档位，正负250mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x0d);
+    m_mapChBVoltageCalibration.insert(OscChannelRange::CR_250MV, voltageCalibration);
+    /* 20mV档位，正负100mV量程 */
+    voltageCalibration = m_usbInterface->usbCtrlTrans(0x90, 0x2d);
+    m_mapChBVoltageCalibration.insert(OscChannelRange::CR_100MV, voltageCalibration);
+
+}
+
+/* 打印出电压校准系数 */
+void OscilloscopeData::printVoltageCalibration(OscChannel channel)
+{
+    if(channel == OscChannel::CH_A)
+    {
+        for(auto it = m_mapChAVoltageCalibration.begin(); it != m_mapChAVoltageCalibration.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_mapChBVoltageCalibration.begin(); it != m_mapChBVoltageCalibration.end(); ++it)
+        {
+            SPDLOG_LOGGER_INFO(m_logger, "通道B {} 量程下的电压校准系数为: {}", static_cast<int>(it.key()), it.value());
+        }
+    }
+    else
+    {
+        SPDLOG_LOGGER_ERROR(m_logger, "通道设置错误!");
+        return;
+    }
+}
 
 /**
  * @brief 采集数据，这个是子线程 
  * 
  */
-void OscData::threadCaptureData()
+void OscilloscopeData::threadCaptureData()
 {
     SPDLOG_LOGGER_INFO(m_logger, "开始采集数据线程");
     m_isRunCapture = true;
     uint64_t count = 0;
+    // unsigned char* buffer = nullptr;
     while(m_runCapture)
     {
+        // SPDLOG_LOGGER_DEBUG(m_logger, "开始采集数据");
         /* 开始采集数据 */
         m_usbInterface->usbCtrlTransSimple(0x33);
-        /* 查询数据是否采集完成（应该是填充满128KB的SRAM） */
-        while(m_usbInterface->usbCtrlTransSimple(0x50) != 0x33)
+        /* 查询数据是否采集完成（应该是填充满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, 1, m_devBuffer);
         /* 等待传输完成 */
@@ -177,13 +620,42 @@ void OscData::threadCaptureData()
             SPDLOG_LOGGER_ERROR(m_logger, "数据传输超时!");
             continue;
         }
+        // SPDLOG_LOGGER_DEBUG(m_logger, "数据通过USB传输完成");
         /* 取出数据 */
+        // buffer = m_ringQueue.back();
+        m_mutexCaptureData.lock();
         std::memcpy(m_buffer, m_devBuffer, BUFFER_SIZE);
+        m_isCaptureData = true;
+        m_mutexCaptureData.unlock();
         /* 清空缓冲区 */
         m_usbInterface->resetPipe();
-        SPDLOG_LOGGER_DEBUG(m_logger, "第 {} 次采集数据完成", count++);
+        // SPDLOG_LOGGER_DEBUG(m_logger, "count: {}", count++);
     }
     m_isRunCapture = false;
 }
 
+/* 处理数据线程 */
+void OscilloscopeData::threadProcessData()
+{
+    SPDLOG_LOGGER_INFO(m_logger, "开始处理数据线程");
+    while(m_runCapture)
+    {
+        if(m_isCaptureData.load())
+        {
+            m_mutexCaptureData.lock();
+            /* 分离通道AB的数据 */
+            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];
+            }
+            m_isCaptureData = false;
+            m_mutexCaptureData.unlock();
+            /* 处理数据 */
+            SPDLOG_LOGGER_DEBUG(m_logger, "开始处理数据，通道A数据: {}, 通道B数据: {}", m_bufferChnA[50], m_bufferChnB[50]);
+        }
+        std::this_thread::sleep_for(std::chrono::microseconds(10));
+    }
+}
+
 

EyeMap/OscData.h

@@ -1,25 +1,42 @@
-#ifndef _OSCDATA_H_
-#define _OSCDATA_H_
+#ifndef _OscilloscopeData_H_
+#define _OscilloscopeData_H_
 
 #include <QObject>
+#include <QMap>
+
 #include "USBInterFace.h"
 #include "spdlog/spdlog.h"
 #include "GlobalInfo.h"
+#include "RingQueue/RingQueue.hpp"
+
+#define OscData OscilloscopeData::getInstance()
 
-class OscData : public QObject
+class OscilloscopeData : public QObject
 {
     Q_OBJECT
 
-const uint32_t BUFFER_SIZE = 1024 * 128;    /* 缓冲区大小，OSCA02的缓冲区应该是128KB的SRAM */
+const uint32_t BUFFER_SIZE = 1024 * 128 ;    /* 缓冲区大小，OSCA02的缓冲区应该是128KB的SRAM */
 
+private:
+    OscilloscopeData();
+    OscilloscopeData(const OscilloscopeData&) = delete;
+    OscilloscopeData& operator=(const OscilloscopeData&) = delete;
 public:
-    OscData();
-    ~OscData();
+    ~OscilloscopeData();
 
+    static OscilloscopeData& getInstance()
+    {
+        static OscilloscopeData instance;
+        return instance;
+    }
+    /* 初始化示波器 */
+    void initOsc();
     /* 打开示波器 */
     bool openOSC();
     /* 关闭示波器 */
     void closeOSC();
+    /* 示波器是否打开 */
+    bool isOpen() { return m_isOpen; }
     /* 开始采集数据 */
     bool startCapture();
     /* 停止采集数据 */
@@ -31,23 +48,64 @@ public:
     /* 将示波器两个通道合并为一个通道 */
     void setChannelMerge(bool merge);
     /* 设置通道A输入量程 */
-    void setChannelARange(unsigned char range);
+    void setChannelARange(OscChannelRange range);
+    /* 设置通道B输入量程 */
+    void setChannelBRange(OscChannelRange 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:
     /* 采集数据，这个是子线程 */
     void threadCaptureData();
+    /* 处理数据线程 */
+    void threadProcessData();
 
 private:
     std::shared_ptr<spdlog::logger> m_logger = nullptr;
     std::shared_ptr<USBInterface> m_usbInterface = nullptr;
-    bool m_runCapture = false;                  /* 采集数据的线程标志 */
-    bool m_isRunCapture = false;                /* 采集数据的线程运行标志，这个标志位作为线程运行的标志 */
-    unsigned char* m_devBuffer = nullptr;       /* 设备缓冲区指针，拷贝数据用的 */
-    unsigned char* m_buffer = nullptr;          /* 缓冲区指针，用于存储拷贝出来的数据 */
-    unsigned char m_ctrlByte0 = 0;              /* 控制字节0 */
-    unsigned char m_ctrlByte1 = 0;              /* 控制字节1 */
+    std::atomic_bool m_isOpen = false;                      /* 示波器是否打开 */
+    std::atomic_bool m_runCapture = false;                  /* 采集数据的线程标志 */
+    std::atomic_bool m_isRunCapture = false;                /* 采集数据的线程运行标志，这个标志位作为线程运行的标志 */
+    std::atomic_bool m_isCaptureData = false;               /* 是否采集到数据 */
+    std::mutex m_mutexCaptureData;                          /* 互斥锁，用于保护采集到的数据 */
+    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<OscChannelRange, unsigned char> m_mapChAZeroVoltage;   /* 通道A的零电压值 */
+    QMap<OscChannelRange, unsigned char> m_mapChBZeroVoltage;   /* 通道B的零电压值 */
+    QMap<OscChannelRange, unsigned char> m_mapChAVoltageCalibration;   /* 通道A的电压校准系数 */
+    QMap<OscChannelRange, unsigned char> m_mapChBVoltageCalibration;   /* 通道B的电压校准系数 */
 };
 
 
 
-#endif /* _OSCDATA_H_ */
+
+#endif /* _OscilloscopeData_H_ */

EyeMap/eyemap.cpp

@@ -1,6 +1,8 @@
 #include "eyemap.h"
 #include "ui_eyemap.h"
+
 #include <QApplication>
+#include <QPainter>
 
 EyeMap::EyeMap(QWidget *parent) :
     QWidget(parent),
@@ -13,21 +15,69 @@ EyeMap::EyeMap(QWidget *parent) :
         SPDLOG_ERROR("获取 OSC logger 失败");
         return;
     }
+    /* 自定义大小 */
+    setFixedSize(1600, 900);
 
     SPDLOG_LOGGER_INFO(m_logger, "EyeMap 初始化成功");
-    if(m_oscData.openOSC())
+    OscData.initOsc();
+    if(OscData.openOSC())
     {
         SPDLOG_LOGGER_INFO(m_logger, "打开示波器成功");
     } else {
         SPDLOG_LOGGER_ERROR(m_logger, "打开示波器失败");
         return;
     }
+    /* 获取零电压值 */
+    OscData.getZeroVoltage();
+    OscData.printZeroVoltage(OscChannel::CH_A);
+    OscData.printZeroVoltage(OscChannel::CH_B);
+    /* 获取电压校准系数 */
+    OscData.getVoltageCalibration();
+    OscData.printVoltageCalibration(OscChannel::CH_A);
+    OscData.printVoltageCalibration(OscChannel::CH_B);
+
+    /* 设置示波器参数 */
+    OscData.setExternalTrigger(false);
+    OscData.setTriggerPosition(0, 0);     /* 在中间位置触发 */
+    OscData.setSampleRate(OscSampleRate::SR_100MHZ);
+    OscData.setChannelARange(OscChannelRange::CR_8V);
+    OscData.setChannelATrigger(true);
+    OscData.setChannelCoupling(OscChannel::CH_A, OscChannelCoupling::DC);
+    OscData.setChannelCoupling(OscChannel::CH_B, OscChannelCoupling::DC);
+    OscData.setTriggerMode(OscTriggerMode::TM_RISE);
+    OscData.setTriggerLevel(128);
+    OscData.setTriggerSensitivity(OscTriggerSensitivity::TS_LOW);
     
-    m_oscData.startCapture();
+
+    OscData.startCapture();
 }
 
 EyeMap::~EyeMap()
 {
+    if(OscData.isOpen())
+    {
+        OscData.closeOSC();
+    }
     delete ui;
 }
 
+/**
+ * @brief 绘制图形
+ * 
+ * @param event 
+ */
+void EyeMap::paintEvent(QPaintEvent *event)
+{
+    QPainter painter(this);
+    /* 绘制背景 */
+    painter.setRenderHint(QPainter::Antialiasing, true);
+    painter.setPen(QPen(Qt::blue, 1, Qt::SolidLine));
+    painter.setBrush(QBrush(Qt::black, Qt::SolidPattern));
+    painter.drawRect(0, 0, 1600, 900);
+    /* 绘制刻度 */
+
+    /* 绘制网格 */
+    
+    /* 绘制眼图 */
+}
+

EyeMap/eyemap.h

@@ -20,11 +20,13 @@ public:
     explicit EyeMap(QWidget *parent = nullptr);
     ~EyeMap();
 
+protected:
+    void paintEvent(QPaintEvent *event) override;
 
 private:
     Ui::EyeMap *ui;
     std::shared_ptr<spdlog::logger> m_logger = nullptr;
-    OscData m_oscData;
+
 };
 
 #endif // EYEMAP_H

GlobalInfo/GlobalInfo.h

@@ -1,6 +1,20 @@
 #ifndef GLOBALINFO_H
 #define GLOBALINFO_H
 
+/* 示波器通道 */
+enum class OscChannel
+{
+    CH_A = 0,
+    CH_B,
+};
+
+/* 示波器通道耦合方式 */
+enum class OscChannelCoupling
+{
+    AC = 0,
+    DC,
+};
+
 /* 示波器采样率，目前就只要这些 */
 enum class OscSampleRate
 {
@@ -11,7 +25,7 @@ enum class OscSampleRate
     SR_100MHZ,
 };
 
-/* 示波器通道的输入量程 */
+/* 示波器通道的输入档位 */
 enum class OscChannelRange
 {
     CR_100MV = 0,
@@ -23,5 +37,22 @@ enum class OscChannelRange
     CR_8V,
 };
 
+/* 触发方式 */
+enum class OscTriggerMode
+{
+    TM_RISE = 0,    /* 上升沿触发 */
+    TM_DOWN,        /* 下降沿触发 */
+    TM_DOUBLE,      /* 双边沿触发 */
+};
+
+/* 触发灵敏度 */
+enum class OscTriggerSensitivity
+{
+    TS_LOW = 0,     /* 低灵敏度 */
+    TS_HIGH,        /* 高灵敏度 */
+};
+
+
+
 
 #endif /* GLOBALINFO_H */