Echtzeit-Oszilloskop mit Matplotlib erstellen

Einführung

Dieses Tutorial ist eine Schritt-für-Schritt-Anleitung, wie man mit Python's Matplotlib-Bibliothek ein Oszilloskop erstellt. Ein Oszilloskop ist ein Gerät, das zur Messung und Darstellung von Spannungssignalen über die Zeit verwendet wird. In diesem Tutorial werden wir das Animationsmodul von Matplotlib nutzen, um eine Echtzeitdarstellung eines Spannungssignals zu erstellen.

Tipps für die virtuelle Maschine (VM)

Nachdem die virtuelle Maschine gestartet wurde, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und auf Jupyter Notebook für die Übung zuzugreifen.

Manchmal müssen Sie möglicherweise einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Operationen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie sich gerne an Labby wenden. Geben Sie uns nach der Sitzung Feedback, und wir werden das Problem umgehend für Sie lösen.

Bibliotheken importieren

Bevor wir mit dem Codieren beginnen, müssen wir die erforderlichen Bibliotheken importieren. Wir werden Matplotlib, NumPy und das Animationsmodul verwenden.

import matplotlib.pyplot as plt
import numpy as np
import matplotlib.animation as animation
from matplotlib.lines import Line2D

Die Scope-Klasse einrichten

Die Scope-Klasse wird die Daten und Methoden enthalten, die wir für die Erstellung des Oszilloskops benötigen. Im Konstruktor initialisieren wir die erforderlichen Variablen und richten das Diagramm ein.

class Scope:
    def __init__(self, ax, maxt=2, dt=0.02):
        self.ax = ax
        self.dt = dt
        self.maxt = maxt
        self.tdata = [0]
        self.ydata = [0]
        self.line = Line2D(self.tdata, self.ydata)
        self.ax.add_line(self.line)
        self.ax.set_ylim(-.1, 1.1)
        self.ax.set_xlim(0, self.maxt)

Die Update-Methode definieren

Die update-Methode wird für jeden Frame der Animation aufgerufen. Sie nimmt einen neuen Wert entgegen und aktualisiert das Diagramm entsprechend.

def update(self, y):
        lastt = self.tdata[-1]
        if lastt >= self.tdata[0] + self.maxt:  ## reset the arrays
            self.tdata = [self.tdata[-1]]
            self.ydata = [self.ydata[-1]]
            self.ax.set_xlim(self.tdata[0], self.tdata[0] + self.maxt)
            self.ax.figure.canvas.draw()

        t = self.tdata[0] + len(self.tdata) * self.dt

        self.tdata.append(t)
        self.ydata.append(y)
        self.line.set_data(self.tdata, self.ydata)
        return self.line,

Die Emitter-Funktion erstellen

Die emitter-Funktion generiert die Daten, die an die update-Methode übergeben werden. In diesem Fall generieren wir Zufallsdaten mit einer Wahrscheinlichkeit von 0,1.

def emitter(p=0.1):
    while True:
        v = np.random.rand()
        if v > p:
            yield 0.
        else:
            yield np.random.rand()

Das Diagramm einrichten

Wir erstellen ein neues Diagramm (Figure) und ein Achsenobjekt (Axis) und initialisieren die Scope-Klasse. Anschließend übergeben wir die update- und emitter-Funktionen an die FuncAnimation-Methode, um die Animation zu erstellen.

fig, ax = plt.subplots()
scope = Scope(ax)

ani = animation.FuncAnimation(fig, scope.update, emitter, interval=50,
                              blit=True, save_count=100)

plt.show()

Zusammenfassung

In diesem Tutorial haben wir gelernt, wie man Matplotlib verwendet, um ein Oszilloskop zu erstellen, das Spannungssignale über die Zeit anzeigt. Wir haben eine Scope-Klasse definiert, um die für das Oszilloskop benötigten Daten und Methoden zu speichern, eine update-Methode erstellt, um das Diagramm zu aktualisieren, und die emitter-Funktion verwendet, um die Daten zu generieren. Schließlich haben wir das Diagramm eingerichtet und die update- und emitter-Funktionen an die FuncAnimation-Methode übergeben, um die Animation zu erstellen.