Vẽ đồ thị dữ liệu cảm biến theo thời gian thực với Matplotlib

Vẽ đồ thị dữ liệu cảm biến theo thời gian thực với Matplotlib

Trong bài này chúng ta sẽ cùng vẽ đồ thị dữ liệu cảm biến theo thời gian thực với Matplotlib: ESP32 gửi dữ liệu qua UART, Python đọc bằng PySerial và cập nhật đồ thị liên tục ngay khi có dữ liệu mới. Đây là cách nhanh nhất để “nhìn thấy” tín hiệu cảm biến, cực kỳ hữu ích khi debug bộ lọc, kiểm tra nhiễu ADC hay chỉnh thông số PID.

Bài 21 trong Serie Lập trình Python từ A tới Z

Vẽ đồ thị dữ liệu cảm biến thời gian thực với Matplotlib

Tại sao cần vẽ đồ thị thời gian thực?

Nhìn một cột số chạy liên tục trên Serial Monitor, rất khó biết tín hiệu đang dao động, đang trôi dần hay có gai nhiễu. Vẽ thành đồ thị thì chỉ cần liếc qua là thấy ngay.

Giống như bác sĩ đo điện tim: không ai đọc từng con số điện áp cả, người ta nhìn đường sóng chạy trên màn hình. Tim đập bất thường là thấy ngay hình dạng sóng khác đi.

Arduino IDE có sẵn Serial Plotter, nhưng khá đơn giản. Tự vẽ bằng Python thì các bạn chỉnh được mọi thứ: vẽ nhiều kênh, thêm đường ngưỡng cảnh báo, vừa vẽ vừa lưu file, vừa vẽ vừa lọc nhiễu.

Chuẩn bị

Bài này dùng lại nguyên phần cứng và firmware của bài Đọc dữ liệu UART từ vi điều khiển với PySerial: ESP32 nối biến trở vào GPIO34, cứ 200ms gửi lên một dòng dạng thời_gian_ms,nhiệt_độ,ADC.

Cài 2 thư viện cần dùng:

pip install pyserial matplotlib

Cách dùng Matplotlib cơ bản như plot(), xlabel(), title() mình đã giới thiệu ở bài Tổng quan thư viện Matplotlib, bài này tập trung vào phần làm cho đồ thị chạy liên tục.

Vẽ đồ thị thời gian thực với Matplotlib và FuncAnimation

Vì sao không dùng vòng while đơn giản?

Cách đầu tiên ai cũng nghĩ tới là viết vòng while True: đọc một dòng, thêm vào List, xóa đồ thị, vẽ lại. Cách này chạy được nhưng có 2 vấn đề:

  • Cửa sổ đồ thị bị đơ, không kéo, không phóng to được, vì vòng lặp chiếm hết thời gian, Matplotlib không có lúc nào để xử lý sự kiện chuột.
  • List dài ra mãi, chạy vài tiếng là tốn bộ nhớ và vẽ ngày càng chậm.

Matplotlib có sẵn công cụ đúng cho việc này là FuncAnimation: cứ sau một khoảng thời gian cố định, nó tự gọi một hàm của chúng ta để cập nhật dữ liệu, phần còn lại để Matplotlib lo vẽ và xử lý cửa sổ.

Giới hạn số điểm với deque

Để đồ thị không dài ra vô tận, chúng ta chỉ giữ 100 điểm gần nhất bằng deque (hàng đợi hai đầu) trong module collections:

from collections import deque

MAX_POINTS = 100
times = deque(maxlen=MAX_POINTS)
adcs = deque(maxlen=MAX_POINTS)

deque có tham số maxlen: khi đã đủ 100 phần tử mà thêm phần tử mới, phần tử cũ nhất tự động bị đẩy ra. Đồ thị nhờ vậy giống như cửa sổ trượt, luôn hiển thị khoảng 20 giây gần nhất (100 điểm × 200ms).

Đọc serial không bị chặn

Trong bài trước mình dùng readline() với timeout=1, hàm này đứng chờ tới khi có đủ một dòng. Nếu gọi trong hàm cập nhật đồ thị thì cửa sổ sẽ bị giật mỗi lần chờ.

Vì vậy ở đây mình mở cổng với timeout=0 và tự gom dữ liệu vào một bộ đệm:

ser = serial.Serial(PORT, BAUD, timeout=0)   # timeout=0: đọc không chờ
buffer = b""

buffer += ser.read(ser.in_waiting or 1)      # lấy hết dữ liệu đang có trong bộ đệm
while b"\n" in buffer:
    raw, buffer = buffer.split(b"\n", 1)     # tách ra từng dòng hoàn chỉnh
  • ser.in_waiting là số byte đang nằm sẵn trong bộ đệm nhận của cổng serial.
  • ser.read(...) lấy hết số byte đó ra ngay, không có thì trả về rỗng chứ không đứng chờ.
  • Dữ liệu được cộng dồn vào buffer, cứ gặp \n là tách ra một dòng hoàn chỉnh. Phần còn dư (dòng mới nhận được một nửa) giữ lại trong buffer để lần sau ghép tiếp.

Lưu ý: Nếu mỗi lần cập nhật đồ thị chỉ đọc đúng một dòng, trong khi board gửi nhanh hơn tốc độ vẽ, dữ liệu sẽ dồn ứ trong bộ đệm và đồ thị chạy trễ dần so với thực tế, xoay biến trở vài giây sau đồ thị mới thay đổi. Luôn đọc hết dữ liệu đang có trong bộ đệm như đoạn code trên nhé.

Hàm cập nhật đồ thị

def update(frame):
    global buffer
    buffer += ser.read(ser.in_waiting or 1)
    while b"\n" in buffer:
        raw, buffer = buffer.split(b"\n", 1)
        try:
            t, temp, adc = raw.decode().strip().split(",")
            time_s = int(t) / 1000
            adc_value = int(adc)
            if time_s < 0 or not 0 <= adc_value <= 4095:
                continue
        except (ValueError, UnicodeDecodeError):
            continue
        times.append(time_s)
        adcs.append(adc_value)
    if len(buffer) > 4096:
        buffer = b""
    if times:
        line.set_data(times, adcs)
        ax.set_xlim(times[0], max(times[-1], times[0] + 1))
    return line,

Chỉ thêm cả thời gian và ADC sau khi đã kiểm tra xong bản tin, để hai deque luôn có cùng số điểm khi gặp dữ liệu lỗi. Bộ đệm cũng được giới hạn nếu mất ký tự xuống dòng. Thay vì xóa đi vẽ lại cả đồ thị, chúng ta chỉ cập nhật dữ liệu của đường đã có bằng line.set_data(), rồi dời trục X theo khoảng thời gian mới bằng ax.set_xlim(). Cách này nhẹ hơn rất nhiều.

Cuối cùng tạo animation, cứ 50ms gọi update() một lần:

ani = FuncAnimation(fig, update, interval=50, cache_frame_data=False)
plt.show()

Lưu ý: Bắt buộc phải gán kết quả vào một biến như ani = FuncAnimation(...). Nếu chỉ gọi FuncAnimation(...) mà không gán, Python sẽ dọn đối tượng animation ngay lập tức, đồ thị hiện lên nhưng đứng yên không cập nhật, kèm cảnh báo “Animation was deleted without rendering anything”.

Code đầy đủ

Đây là full code, các bạn lưu thành file realtime_plot.py rồi chạy bằng lệnh python realtime_plot.py COM3 (thay COM3 bằng cổng của board):

# Bài 21: Vẽ đồ thị dữ liệu cảm biến theo thời gian thực với Matplotlib
import sys
from collections import deque

import matplotlib.pyplot as plt
import serial
from matplotlib.animation import FuncAnimation

PORT = sys.argv[1] if len(sys.argv) > 1 else "COM3"
BAUD = 115200
MAX_POINTS = 100                      # chỉ giữ 100 điểm gần nhất trên đồ thị

ser = serial.Serial(PORT, BAUD, timeout=0)   # timeout=0: đọc không chờ
buffer = b""
times = deque(maxlen=MAX_POINTS)
adcs = deque(maxlen=MAX_POINTS)

fig, ax = plt.subplots()
line, = ax.plot([], [], "b-")
ax.set_ylim(0, 4095)
ax.set_xlabel("Thời gian (s)")
ax.set_ylabel("Giá trị ADC")
ax.set_title(f"Dữ liệu ADC từ {PORT}")
ax.grid(True)


def update(frame):
    global buffer
    buffer += ser.read(ser.in_waiting or 1)   # lấy hết dữ liệu đang có trong bộ đệm
    while b"\n" in buffer:
        raw, buffer = buffer.split(b"\n", 1)
        try:
            t, temp, adc = raw.decode().strip().split(",")
            time_s = int(t) / 1000
            adc_value = int(adc)
            if time_s < 0 or not 0 <= adc_value <= 4095:
                continue
        except (ValueError, UnicodeDecodeError):
            continue
        times.append(time_s)
        adcs.append(adc_value)
    if len(buffer) > 4096:             # bỏ bản tin quá dài, thiếu ký tự xuống dòng
        buffer = b""
    if times:
        line.set_data(times, adcs)
        ax.set_xlim(times[0], max(times[-1], times[0] + 1))
    return line,


ani = FuncAnimation(fig, update, interval=50, cache_frame_data=False)
try:
    plt.show()
finally:
    ser.close()

Trục Y được cố định từ 0 tới 4095, đúng bằng dải giá trị của ADC 12 bit, để đồ thị không bị nhảy tỉ lệ mỗi khi dữ liệu thay đổi. Đóng cửa sổ đồ thị thì plt.show() kết thúc và cổng serial được đóng lại.

Toàn bộ mã nguồn đã có trong các khối code ở trên; lưu thành realtime_plot.py để chạy.

Kết quả

Nạp firmware của bài 20 cho ESP32, tắt Serial Monitor rồi chạy script. Cửa sổ đồ thị hiện lên và đường ADC chạy liên tục từ phải sang trái. Xoay biến trở qua lại, đường đồ thị lên xuống theo gần như tức thì.

Đồ thị từ script realtime_plot.py chạy với dữ liệu UART mô phỏng, không phải phép đo ESP32
Kết quả chạy script vẽ đồ thị với dữ liệu UART mô phỏng qua serial ảo; không phải phép đo biến trở hoặc chân ADC thả nổi.

Thử rút dây chân giữa biến trở ra khỏi GPIO34, giá trị có thể nhiễu, dao động hoặc dồn về một vùng tùy mạch và môi trường. Đó là chân ADC đang thả nổi (floating) và bắt nhiễu, một hiện tượng nhìn số trên Serial Monitor rất khó nhận ra nhưng nhìn đồ thị thì rõ ngay.

Đồ thị từ script realtime_plot.py chạy với dữ liệu UART mô phỏng, không phải phép đo ESP32
Kết quả chạy script vẽ đồ thị với dữ liệu UART mô phỏng qua serial ảo; không phải phép đo biến trở hoặc chân ADC thả nổi.

Kết

Vẽ đồ thị thời gian thực giúp các bạn “nhìn thấy” tín hiệu, rất đáng dùng mỗi khi debug cảm biến, bộ lọc hay vòng điều khiển. Từ code này có thể mở rộng thêm: vẽ cùng lúc cả nhiệt độ và ADC bằng 2 đường, hoặc kết hợp với bài trước để vừa vẽ vừa lưu file CSV.

Bài tiếp theo chúng ta sẽ dùng Python để tự động test firmware qua cổng Serial. Có thắc mắc gì các bạn để lại bình luận bên dưới nhé!

Tài liệu tham khảo: FuncAnimation trong tài liệu Matplotlib.

Rate this post

Để lại một bình luận

Email của bạn sẽ không được hiển thị công khai. Các trường bắt buộc được đánh dấu *