PyQtGraph: Realtime python plotting

Realtime plotting

Realtime plotting refers to plots that updates as represent the data as it is available. There are many applications that allows to do this, but we will focus on custom, ad-hoc solution using PyQtGraph and Python3 scripts.

When working on maker projects, whether you are monitoring sensors with an Arduino, a Raspberry Pi, or an ESP32, you eventually hit a wall: you want to see your data in real-time. If you have tried using Matplotlib for this, you probably noticed that once you hit a few hundred data points, the interface starts to stutter and freeze. This is where PyQtGraph saves the day.

Why PyQtGraph?

Unlike other libraries, PyQtGraph is built on top of Qt and leverages NumPy for heavy data lifting. It is incredibly fast, allowing you to zoom and pan through your data even while it’s updating at high frequencies without any lag.

Setting up the environment

First, let’s make sure you have the necessary dependencies. We will use the latest versions compatible with Python 3.

python3 -m pip install pyqt6 pyqtgraph numpy

Note

In recent updates, pyqtgraph recommends using PyQt6 or PySide6 for better compatibility with modern operating systems.

The “Hello World” of Real-Time Plotting

In this example, we will simulate a live sensor signal. The secret to smooth performance is using a QTimer. This ensures the UI stays resposive while the data updates in the background.

1
import pyqtgraph as pg
2
from pyqtgraph.Qt import QtCore, QtWidgets
3
import numpy as np
4

5
class RealTimePlot:
6
    def __init__(self):
7
        # 1. Initialize the application and the window
8
        self.app = QtWidgets.QApplication([])
9
        self.win = pg.GraphicsLayoutWidget(show=True, title="Laboratorio Gluon: Real-Time Plot")
10
        self.plot = self.win.addPlot(title="Live Sensor Data")
11

12
        # 2. Configure the curve and data buffer
13
        self.curve = self.plot.plot(pen='y') # Yellow pen for that classic lab look
14
        self.data = np.zeros(100)
15
        self.ptr = 0
16

17
        # 3. Setup a QTimer for periodic updates
18
        self.timer = QtCore.QTimer()
19
        self.timer.timeout.connect(self.update)
20
        self.timer.start(50) # Update every 50ms (approx. 20 FPS)
21

22
    def update(self):
23
        # Shift data to the left to create a scrolling effect
24
        self.data[:-1] = self.data[1:]
25
        self.data[-1] = np.random.normal() # Replace this with your sensor read!
26

27
        # Update the plot curve
28
        self.curve.setData(self.data)
29

30
    def run(self):
31
        self.app.exec()
32

33
if __name__ == '__main__':
34
    graph = RealTimePlot()
35
    graph.run()

Pro Tips for your script

A common mistake when starting out is using a while True loop with time.sleep(). Don’t do this! It will freeze your GUI. QTimer is the proper way to tell your computer: “Hey, run this function every X milliseconds, but let me keep interacting with the window.”

There are two points that need attention:

Antialiasing: It makes the lines look much smoother, though it requires a bit more GPU power.
Frame rate: 50ms (20 FPS) is the “sweet spot.” It looks fluid to the human eye but keeps the CPU usage low enough for a Raspberry Pi to handle.

Using real data from PySerial into PyQtGraph

To make this useful for a real lab setup, we need to pull data from a microcontroller. We’ll use the pyserial library.

python3 -m pip install pyserial

Now, we need to modify our script. Instead of generating random numbers, we will read the values from the serial line, and plot them. For this example, we expect the data come as one float number per line.

1
import serial
2
import pyqtgraph as pg
3
from pyqtgraph.Qt import QtCore, QtWidgets
4
import numpy as np
5

6
class RealTimeSerialPlot:
7
    def __init__(self, port='/dev/ttyUSB0', baudrate=9600):
8
        # Initialize Serial Connection
9
        # Use 'COM3' for Windows or '/dev/ttyACM0' for most Arduinos on Linux/Pi
10
        self.ser = serial.Serial(port, baudrate, timeout=0.1)
11

12
        # UI Setup
13
        self.app = QtWidgets.QApplication([])
14
        self.win = pg.GraphicsLayoutWidget(show=True, title="Laboratorio Gluon: Serial Monitor")
15
        self.plot = self.win.addPlot(title="Real-Time Sensor Feed")
16
        self.curve = self.plot.plot(pen='g') # Green for a "Matrix" feel
17

18
        self.data_buffer = np.zeros(200) # Store the last 200 readings
19

20
        # Timer setup
21
        self.timer = QtCore.QTimer()
22
        self.timer.timeout.connect(self.update)
23
        self.timer.start(10) # High frequency update
24

25
    def update(self):
26
        # Read all available data from the serial buffer
27
        while self.ser.in_waiting > 0:
28
            try:
29
                line = self.ser.readline().decode('utf-8').strip()
30
                if line:
31
                    value = float(line)
32

33
                    # Update data buffer
34
                    self.data_buffer[:-1] = self.data_buffer[1:]
35
                    self.data_buffer[-1] = value
36
            except ValueError:
37
                pass # Ignore corrupted lines or headers
38

39
        # Update the plot with the new buffer
40
        self.curve.setData(self.data_buffer)
41

42
    def run(self):
43
        self.app.exec()
44
        self.ser.close() # Clean up the port when closing
45

46
if __name__ == '__main__':
47
    # Adjust port name based on your OS
48
    monitor = RealTimeSerialPlot(port='/dev/ttyUSB0', baudrate=115200)
49
    monitor.run()

Notice the while self.ser.in_waiting > 0:. This is critical. If your sensor sends data faster than your QTimer refreshes, the serial buffer will fill up, and your graph will show “old” data (lag). This loop clears the entire buffer in every frame so you always see the latest value.

Sending data from Arduino

The previous script wanted the data in a float number, one data per line. This can be implemented in many ways. The easiest one Arduino:

1
void loop() {
2
  Serial.println(analogRead(A0)); // Just the number and a newline
3
  delay(10);
4
}