深入掌握MFC实现串口数据实时显示-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_32925455/article/details/146244745

简介：本文详细介绍了如何利用MFC（Microsoft Foundation Classes）进行串口通信，实现数据的接收和实时波形显示。首先阐述了MFC串口操作的基础知识和相关设置，然后深入解析数据接收后的处理流程和图形界面更新机制。通过实际代码示例，讲述了如何通过多线程提高程序效率。掌握这些技术点对于开发涉及串口通信的应用程序至关重要。 MFC串口接收数据并实时显示

1. MFC串口通信基础

1.1 MFC串口通信概述

在现代工业和数据采集系统中，串口通信因其简单可靠、设备兼容性广泛而被广泛应用。MFC（Microsoft Foundation Classes）提供了一套用于串口通信的类，使得开发者能够更便捷地创建此类应用程序。在深入了解如何使用这些类之前，我们需要对串口通信的原理有一个基础的认识。

串口通信主要涉及到数据的发送和接收，这些数据通过串行端口在设备间以位为单位顺序传输。通信双方必须设置一致的波特率、数据位、停止位和校验位等参数，才能正确解码传输的数据。

1.2 MFC中的串口通信机制

在MFC中，串口通信是通过CSocket类和其派生类实现的，但更常见的做法是使用第三方库，例如Windows API中提供的串口函数，或者社区开发的类库如CSerialPort。通过这些类库，我们可以较为简单地实现串口的打开、配置、读写操作以及关闭。

在本章中，我们将详细介绍如何使用MFC进行串口通信，包括配置串口参数、数据的读写以及异常处理等基础知识，为后续章节中更深层次的应用和实践打下坚实的基础。

2. CSerialPort类操作实践

CSerialPort类是MFC库中提供的用于串口通信的类。它封装了Windows的串口API，使得开发者能够方便地通过对象来操作串口。本章节将深入实践如何使用CSerialPort类进行串口的初始化、配置、读写操作以及异常处理。

2.1 CSerialPort类的初始化与配置

2.1.1 创建CSerialPort对象

在开始使用CSerialPort类进行串口通信之前，我们需要先创建一个CSerialPort对象。在MFC应用程序中，这通常是在视图类或者某个处理串口通信的类中完成的。

// 假设在某个处理串口通信的类中
CSerialPort serial;

// 设置串口参数
serial.SetPortName(_T("COM3")); // 串口名称
serial.SetBaudRate(CSerialPort::baud115200); // 波特率115200
serial.SetByteSize(8); // 数据位8位
serial.SetParity(CSerialPort::parityNone); // 无奇偶校验
serial.SetStopBits(CSerialPort::stopOne); // 1个停止位
serial.SetFlowControl(CSerialPort::flowNone); // 无流控制

2.1.2 配置串口参数

初始化CSerialPort对象后，我们需要根据实际需要配置串口的参数。参数包括但不限于端口名称、波特率、数据位、停止位、奇偶校验位以及硬件流控制。

// 继续上面的代码
if (!serial.Open()) // 尝试打开串口
{
    AfxMessageBox(_T("无法打开串口"));
    return;
}

// 配置串口参数示例
// 这些设置需要根据实际硬件和通信协议要求进行调整

2.2 CSerialPort类的读写操作

2.2.1 异步读取数据

异步读取是一种常用的读取串口数据方式，它可以让程序在等待数据时继续执行其他任务。CSerialPort类提供了StartRead和StopRead方法来实现异步读取。

// 异步读取数据
void OnStartRead()
{
    serial.StartRead(
        [](CSerialPort* pPort, void* pContext, const BYTE* pBuff, size_t count)
        {
            // 当数据到达时的回调函数
            // pPort: 当前串口对象
            // pContext: 异步读取时传入的上下文
            // pBuff: 接收到的数据指针
            // count: 接收到的数据字节数
        }, nullptr);
}

2.2.2 同步写入数据

写入串口数据时，可以使用同步的方式，即等待写入操作完成后再继续执行后续代码。通过调用CSerialPort类的Write方法可以实现数据的同步写入。

// 同步写入数据
void OnWriteData()
{
    BYTE data[] = {'H', 'e', 'l', 'l', 'o', '\n'}; // 要发送的数据
    DWORD bytesWritten = 0; // 记录写入字节数
    if (!serial.Write(data, sizeof(data), &bytesWritten)) 
    {
        // 写入失败处理
        AfxMessageBox(_T("写入串口失败"));
    }
}

2.3 CSerialPort类的异常处理

2.3.1 常见异常的捕获与处理

在串口通信过程中可能会出现各种异常情况，例如设备未连接、读写错误等。通过捕获这些异常并进行适当处理，可以增强程序的健壮性。

// 异常处理示例
try
{
    // 可能引发异常的代码
}
catch (CSerialException* e)
{
    AfxMessageBox(e->GetErrorMessage());
    e->Delete();
}

2.3.2 设备状态监测

监测串口设备的状态对于保证通信的稳定和及时发现故障非常关键。CSerialPort类提供了多个状态监测功能，可以通过Get modem status等方法来获取设备状态。

// 设备状态监测
void OnCheckDeviceStatus()
{
    DWORD modemStatus = 0;
    if (!serial.GetModemStatus(&modemStatus))
    {
        // 获取状态失败处理
        AfxMessageBox(_T("获取设备状态失败"));
    }
    // 根据modemStatus的位值判断设备的具体状态
}

至此，我们完成了对CSerialPort类操作实践的基础介绍。在下一章节中，我们将深入探讨数据解析与转换技术，这是实现数据有效通信的关键环节。

3. 数据解析与转换技术

3.1 数据帧的结构与解析

3.1.1 定义数据帧格式

在进行串口通信时，数据帧格式是双方事先约定好的一种规则，用以确保数据的正确接收与解析。定义数据帧通常包括起始位、数据位、校验位和停止位等，有时还包括地址位和控制位。例如，一个简单的数据帧可能由起始位、8位数据、1位校验位和1位停止位组成。

为了解析数据帧，我们需要了解如何将串口接收到的字节流切割成有意义的数据单元。这通常涉及到查找特定的字节序列作为帧的边界。举个例子，我们定义数据帧以特定的起始字节和结束字节为边界，这样我们就可以在接收数据流时，从第一个起始字节开始切割，直到遇到结束字节为止。

3.1.2 数据的分包与重组

在实际的通信过程中，由于网络延迟或硬件限制，数据往往被分成多个包发送。因此，接收端需要实现数据的分包与重组功能，确保数据能被正确恢复。

实现分包通常依赖于数据帧的格式，例如，我们可能使用数据包的长度字段来确定一个数据包的开始和结束。在C++中，使用标准库中的函数如 std::search ，可以在字节流中搜索特定的字节序列，从而识别出各个数据包的边界。以下是一个简化的代码示例，展示了如何识别并提取数据包：

#include <vector>
#include <algorithm>

const std::vector<uint8_t> startSequence = {0xAA, 0xBB}; // 定义起始字节序列
const std::vector<uint8_t> endSequence = {0xCC};         // 定义结束字节序列

// 从缓冲区中查找起始和结束序列，提取数据包
std::vector<uint8_t> extractPacket(std::vector<uint8_t>& buffer) {
    auto startIt = std::search(buffer.begin(), buffer.end(), startSequence.begin(), startSequence.end());
    if (startIt != buffer.end()) {
        auto endIt = std::search(startIt, buffer.end(), endSequence.begin(), endSequence.end());
        if (endIt != buffer.end()) {
            // 提取数据包
            std::vector<uint8_t> packet(startIt, endIt + 1); // 包含结束字节
            // 移除已处理的数据包
            buffer.erase(startIt, endIt + 1);
            return packet;
        }
    }
    return std::vector<uint8_t>(); // 如果没有找到完整的数据包，则返回空包
}

// 缓冲区数据的维护和处理逻辑
void processBuffer(std::vector<uint8_t>& buffer) {
    while (true) {
        std::vector<uint8_t> packet = extractPacket(buffer);
        if (packet.empty()) {
            break;
        }
        // 对提取出的数据包进行进一步处理
        processSinglePacket(packet);
    }
}

在上述代码中， extractPacket 函数负责从接收到的数据缓冲区中查找并提取数据包。数据包提取后，剩余的字节流保持在缓冲区中，等待下一次处理。 processBuffer 函数持续调用 extractPacket ，直到没有更多数据包可以从缓冲区中提取出来。

理解了数据帧的定义和分包与重组的策略后，接下来需要关注的是数据帧内的数据转换与处理技术。

3.2 数据转换与处理

3.2.1 数据格式转换

数据格式转换是将接收到的原始数据从一种格式转换为另一种格式的过程。例如，将字节数据转换为整数、浮点数或字符串等。在MFC串口通信中，常见的数据格式转换包括：

字节序（Endianness）转换：大端序和小端序之间的转换，以确保数据在不同系统间的一致性。
数据类型的转换：将原始的字节序列转换为不同的数值类型，如int、float、double等。

考虑到不同硬件和软件平台可能使用不同的字节序，因此在处理跨平台通信时，需要特别注意字节序的转换。例如，如果我们从一个大端序的设备接收数据，而目标平台是小端序，那么就需要在解析数据之前进行字节序的转换。下面展示了如何在C++中实现字节序的转换：

#include <cstdint>

// 假设rawData是从串口读取的原始数据（例如，4字节的整数）
uint32_t rawData = 0x12345678;

// 转换为小端序的函数
uint32_t toLittleEndian(uint32_t value) {
    return ((value & 0x000000FF) << 24) |
           ((value & 0x0000FF00) << 8) |
           ((value & 0x00FF0000) >> 8) |
           ((value & 0xFF000000) >> 24);
}

// 转换为大端序的函数
uint32_t toBigEndian(uint32_t value) {
    return ((value & 0x000000FF) << 24) |
           ((value & 0x0000FF00) << 8) |
           ((value & 0x00FF0000) >> 8) |
           ((value & 0xFF000000) >> 24);
}

// 使用示例
uint32_t bigEndianData = toBigEndian(rawData); // 转换为大端序
uint32_t littleEndianData = toLittleEndian(rawData); // 转换为小端序

3.2.2 数据校验与错误处理

数据在传输过程中可能会出现错误，因此需要实现数据校验机制，以确保数据的完整性和准确性。常见的数据校验方法有：

奇偶校验：通过增加额外的校验位来确保数据的奇偶性。
校验和（Checksum）：通常通过对数据进行某种算术运算来获得校验和。
循环冗余校验（CRC）：利用循环冗余校验生成多项式，是一种较为复杂但高效的校验方法。

在实现数据校验时，发送方需要计算并附加校验信息，而接收方则需要对数据重新进行校验，以发现可能的错误。如果校验失败，程序应能够根据错误的严重程度做出适当的处理，例如请求重发数据、丢弃错误的数据包或记录错误日志等。

// 一个简单的CRC校验计算示例
uint16_t simpleCRC16(const uint8_t* data, size_t size) {
    uint16_t crc = 0xFFFF; // 初始值
    while (size--) {
        crc ^= *data++;
        for (int i = 0; i < 8; i++) {
            if (crc & 1) {
                crc >>= 1;
                crc ^= 0xA001; // 一个简单的CRC多项式
            } else {
                crc >>= 1;
            }
        }
    }
    return crc;
}

// 使用示例
const uint8_t* data = /* ... 数据字节序列 ... */;
size_t dataSize = /* ... 数据大小 ... */;
uint16_t crcValue = simpleCRC16(data, dataSize);

// 将计算得到的CRC值附加到数据包中发送
// 接收方在收到数据后重新计算CRC值，并与接收到的CRC值进行比较

在上述代码中， simpleCRC16 函数通过一个简单的多项式来计算数据的CRC校验值。数据发送方需要在发送数据之前调用这个函数，并将计算得到的校验值附加到数据包中。数据接收方在收到数据后，同样需要调用此函数，并将计算得到的CRC值与接收到的值进行比较，以检测数据是否在传输过程中发生了错误。

表格：数据校验方法对比

| 校验方法 | 优点 | 缺点 | 应用场景 | | --- | --- | --- | --- | | 奇偶校验 | 实现简单 | 检测能力弱 | 对通信错误要求不高的系统 | | 校验和 | 相对简单，增加的校验信息较少 | 检测能力有限 | 需要较高准确性的应用 | | CRC | 检测能力强，可靠性高 | 实现较复杂 | 要求极高的数据传输系统 |

通过上述章节，我们了解了如何定义和解析数据帧，以及数据转换和校验的实现方法。这些技术对于确保数据的准确性和完整性至关重要。在下一章节，我们将深入探讨如何利用MFC的CView类来更新图形界面，将接收到的数据以直观的方式展示给用户。

4. CView类图形界面更新

4.1 CView类与MFC文档/视图架构

4.1.1 文档/视图关系概述

在MFC（Microsoft Foundation Classes）应用程序框架中，文档/视图架构扮演着至关重要的角色。CView类是MFC中的一个基本类，用于向用户提供与文档数据交互的界面。它作为一个窗口类，通常负责显示、编辑以及打印文档数据。文档/视图架构允许我们分离数据模型和显示逻辑，从而在处理复杂数据时提供更高的灵活性和扩展性。

文档类负责数据的存储和管理，而视图类则负责将文档数据转换成用户可以看到和与之交互的形式。这种设计模式允许应用程序支持多种视图类型，例如，一个文档可以同时在文本视图和图形视图中显示，而所有视图都将共享相同的数据模型，确保数据的一致性。

4.1.2 CView类的作用与特点

CView类作为视图类的基类，提供了一系列功能用于绘制图形和处理用户输入。它集成了Windows GDI（图形设备接口）的功能，提供了绘图和文本显示的功能，使得开发者可以相对容易地实现复杂的图形界面。

CView类的几个关键特点是：

自动窗口绘制 ：CView类会处理窗口的重绘消息，开发者仅需重载 OnDraw 函数来实现自定义的绘制逻辑。
消息处理 ：CView类处理了大部分的消息，例如键盘、鼠标和滚动条消息，使得视图类可以方便地处理用户交互。
视图更新 ：CView类提供了 UpdateWindow 、 RedrawWindow 等函数，用于强制视图立即重绘或更新部分内容。

4.2 实时数据显示的实现

4.2.1 数据接收与显示同步

为了实现实时数据显示，CView类需要与数据源进行同步，这通常是通过多线程技术来完成的。在CView类中，我们可以启动一个或多个后台线程来负责数据的采集和处理，同时主线程的视图更新应当与这些后台线程的数据更新同步。

在实际应用中，这可以通过信号量、事件、消息泵或Windows的UI线程机制来实现。例如，可以使用 PostMessage 或 SetEvent 来通知UI线程进行视图更新。以下是一个简化的代码示例，展示了如何在接收到新数据时通知UI线程进行视图更新：

void CMyView::OnNewDataReceived()
{
    // 获取文档指针
    CMyDocument* pDoc = GetDocument();
    // 在UI线程上进行更新，这里假设使用PostMessage
    PostMessage(WM_USER_DATA_UPDATE, 0, 0);
}

// 在视图类的消息处理函数中
BEGIN_MESSAGE_MAP(CMyView, CView)
    ON_MESSAGE(WM_USER_DATA_UPDATE, OnUpdateUI)
END_MESSAGE_MAP()

void CMyView::OnUpdateUI()
{
    // 更新视图
    Invalidate(); // 使当前视图的客户区无效
    UpdateWindow(); // 立即更新客户区
}

4.2.2 字符与图形界面的渲染

字符和图形的渲染是实现用户界面的关键部分。字符渲染通常用于显示文本信息，而图形渲染则用于绘制形状、图像等复杂元素。MFC为CView类提供了丰富的GDI对象和函数来完成这些任务。例如，可以通过 CPen 和 CBrush 对象来定义绘图的笔刷和画笔，使用 CDC 类提供的函数来绘制线条、矩形、椭圆、位图等。

更新图形界面时，需要考虑到渲染性能，避免画面闪烁和卡顿。这通常需要合理安排绘图代码的位置，如在 OnDraw 函数中使用双缓冲技术。双缓冲技术通过先在内存中的一个临时位图上绘图，然后一次性将结果拷贝到屏幕上，从而提高渲染效率。

4.3 用户交互与响应机制

4.3.1 用户操作处理

用户操作处理是图形界面设计中的另一个重要方面。CView类提供了一组消息映射宏，允许开发者定义消息处理函数来响应用户的各种操作。这些操作包括键盘输入、鼠标点击、拖拽、菜单选择等。

对于复杂的用户操作，我们可能需要维护一个内部状态机来管理不同的用户交互阶段，从而提供连贯的用户体验。例如，用户可能在点击按钮后需要选择多个对象，这时我们可以临时改变视图的状态，等待用户完成操作后恢复到正常模式。

4.3.2 界面刷新与更新策略

界面刷新和更新策略直接影响到用户体验和系统性能。更新策略必须灵活以适应不同的应用场景，例如，在数据更新频繁的实时监控界面和用户交互较多的编辑界面之间，刷新频率和时机的差异会很大。

在实时监控界面中，为了保证数据的实时性，通常需要实现一个高速的数据刷新机制。可以使用定时器或事件触发的方式来控制数据更新频率，但同时要考虑最小化对系统资源的消耗。实现这一机制时，合理地平衡更新频率和系统资源占用是关键。

在MFC中，可以使用 SetTimer 函数设置定时器，并在 OnTimer 消息处理函数中执行更新操作：

void CMyView::OnTimer(UINT_PTR nIDEvent)
{
    CView::OnTimer(nIDEvent);
    if (nIDEvent == ID_TIMER_REFRESH)
    {
        UpdateDataView(); // 更新视图数据
    }
}

void CMyView::OnUpdateDataView()
{
    // 更新视图数据逻辑
}

// 在视图构造函数中启动定时器
m_nUpdateTimerID = SetTimer(ID_TIMER_REFRESH, 500, NULL); // 每500ms刷新一次数据

以上代码中，我们设置了一个每500毫秒触发一次的定时器，用于定期更新数据。

界面更新策略需要经过仔细的设计和测试，以确保满足应用需求。通过合理地调整定时器间隔、利用双缓冲技术和优化绘图代码，可以使用户界面的响应和表现达到最佳状态。

5. 多线程编程技巧

5.1 多线程的基本概念

5.1.1 线程与进程的区别

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。线程与进程的区别主要体现在以下几点：

地址空间和其他资源（如打开文件）：进程间相互独立，而线程共享其所属进程的资源。
系统开销：创建或销毁线程的开销要比进程小得多，因为线程间通信更方便，线程切换的上下文开销也比进程小。
并发性：不同进程间可以实现并发，同一个进程的线程也可以并发执行。

在多线程编程中，合理利用线程可以提高程序的并发性和效率，减少系统开销。

5.1.2 多线程的优势与挑战

多线程编程的优势在于：

提高资源利用率 ：多线程能够更有效地利用多核处理器。
提升应用程序响应性 ：通过多线程，用户界面可以保持响应，而耗时的操作在后台执行。
简化复杂操作 ：例如在进行网络通信时，可以将监听连接的线程与处理数据的线程分离。

然而，多线程编程也存在挑战：

线程安全问题 ：线程间共享数据时，可能会产生竞争条件和数据不一致的问题。
同步和死锁 ：为了协调线程对共享资源的访问，需要同步机制，而这些机制使用不当容易造成死锁。

为了克服这些挑战，需要掌握合适的多线程编程技巧和模式。

5.2 创建与管理线程

5.2.1 线程的创建方法

在Windows平台，线程的创建可以通过调用Win32 API实现，例如使用 CreateThread 函数。在C++中，通常使用 std::thread 类来创建线程：

#include <thread>
#include <iostream>

void printNumbers() {
    for(int i = 1; i <= 5; ++i) {
        std::cout << "Number: " << i << std::endl;
    }
}

int main() {
    std::thread t(printNumbers);
    t.join(); // 等待线程完成
    return 0;
}

5.2.2 线程同步与互斥

线程同步是指多个线程之间协调运行次序和共享资源访问。而互斥则是指多个线程在同一时刻只能有一个线程可以访问共享资源。

互斥锁（Mutex） ：例如使用 std::mutex 来控制对共享资源的访问。

std::mutex mtx;
void printNumbers() {
    for(int i = 1; i <= 5; ++i) {
        mtx.lock(); // 获取互斥锁
        std::cout << "Number: " << i << std::endl;
        mtx.unlock(); // 释放互斥锁
    }
}

条件变量（Condition Variable） ：用于线程间的协作，例如在等待某个条件满足时。

std::condition_variable cv;
std::mutex mtx;
bool ready = false;

void threadFunction() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one(); // 通知一个等待的线程
}

int main() {
    std::thread t(threadFunction);
    std::unique_lock<std::mutex> lk(mtx);
    cv.wait(lk, []{return ready;}); // 等待条件变量通知
    std::cout << "Condition met!" << std::endl;
    t.join();
    return 0;
}

5.3 线程在串口通信中的应用

5.3.1 多线程串口读写策略

在串口通信中，使用多线程可以优化程序的性能，提高读写效率。典型的应用策略包括：

读线程 ：负责监听串口是否有数据到达，并将其读入缓冲区。
写线程 ：将要发送的数据写入串口。

5.3.2 线程安全与性能优化

为了保证线程安全，可以采取以下措施：

使用互斥锁保护共享资源。
使用线程局部存储（TLS）来避免全局资源访问冲突。

性能优化方面，可以考虑：

任务批处理 ：减少上下文切换的次数，提高吞吐量。
线程池 ：避免频繁创建和销毁线程带来的开销。

多线程编程技巧是提升串口通信软件性能的关键技术之一。通过合理运用多线程，可以实现更高的数据吞吐量和更优的用户交互体验。在实际应用中，开发者需要根据具体的应用场景来权衡多线程带来的优势和挑战。

6. 波形显示的实现方法

波形显示是许多科学与工程软件中的一个重要功能，特别是在涉及到数据分析与仪器控制的应用程序中。它允许用户通过图形界面观察信号、波形或其他类型的数据变化。本章将探讨波形显示的需求、技术实现路径，以及如何优化波形显示效果。

6.1 波形显示的需求分析

在开始实现波形显示之前，首先需要对其需求进行深入的分析，这有助于确定技术实现的方向和重点。

6.1.1 波形显示的目的与重要性

波形显示的主要目的是提供一种直观的方式来观察和分析数据序列。这种显示方式对于捕捉数据的模式和趋势非常有效，尤其是在信号处理、医疗设备监控、工业自动化等领域。通过波形显示，用户可以快速识别异常值、周期性模式，甚至可以对数据进行实时监控。

6.1.2 波形数据的特性

波形数据通常以时间序列的形式存在，它们可能随时间连续变化或以离散的采样点存在。波形数据可能具有不同的频率、振幅以及噪声水平。为了准确地在屏幕上显示这些数据，波形显示系统需要能够处理数据的这些特性。

6.2 实现波形显示的技术路径

波形显示的技术实现涉及到数据的图形化表达以及实时数据流的处理。这些步骤通常需要结合图形用户界面(GUI)和数据处理技术。

6.2.1 波形数据的图形化表达

要将数据转换为图形化表达，需要选择合适的图形库和设计合适的图形渲染算法。MFC环境下，可以使用GDI或者GDI+来绘制波形。波形通常显示为线条、点或者其他形状，这些需要通过编程方式在窗口中绘制。

// 代码块示例：绘制波形数据的简化版本
void CMyView::OnDraw(CDC* pDC)
{
    CDocument* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    if (!pDoc)
        return;

    // 假设 m_WaveFormData 是存储波形数据的数组
    const auto& waveFormData = pDoc->GetWaveFormData();

    // 绘制波形
    for (size_t i = 1; i < waveFormData.size(); ++i)
    {
        pDC->MoveTo(waveFormData[i-1].x, waveFormData[i-1].y);
        pDC->LineTo(waveFormData[i].x, waveFormData[i].y);
    }
}

上述代码简单地使用MFC的CDC类绘制波形，实际应用中可能需要对坐标进行转换，以匹配数据点与屏幕像素。

6.2.2 实时更新波形显示

实时更新波形显示意味着波形图像需要根据新接收到的数据不断刷新。为了做到这一点，我们需要实现一个高效的更新机制，这通常涉及到定时器和缓冲技术。

void CMyView::OnTimer(UINT_PTR nIDEvent)
{
    // 更新波形数据缓冲区
    UpdateWaveFormDataBuffer();

    // 重绘视图
    Invalidate();

    CView::OnTimer(nIDEvent);
}

void CMyView::OnPaint()
{
    CPaintDC dc(this);
    // 在这里绘制波形
}

在这里， UpdateWaveFormDataBuffer() 函数负责将最新数据填充到波形数据缓冲区，而 Invalidate() 函数则请求视图进行重绘，然后通过 OnPaint() 函数中的绘图代码，将新的波形数据显示出来。