Créer un oscilloscope en temps réel avec Matplotlib

Introduction

Ce tutoriel est un guide étape par étape sur la création d'un oscilloscope à l'aide de la bibliothèque Matplotlib de Python. Un oscilloscope est un appareil utilisé pour mesurer et afficher des signaux de tension au fil du temps. Dans ce tutoriel, nous utiliserons le module d'animation de Matplotlib pour créer un affichage en temps réel d'un signal de tension.

Conseils pour la machine virtuelle (VM)

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook afin d'accéder à Jupyter Notebook pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes que Jupyter Notebook ait terminé de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes lors de votre apprentissage, n'hésitez pas à poser vos questions à Labby. Fournissez vos commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques

Avant de commencer à coder, nous devons importer les bibliothèques nécessaires. Nous utiliserons Matplotlib, NumPy et le module d'animation.

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

Configuration de la classe Scope

La classe Scope contiendra les données et les méthodes nécessaires pour créer l'oscilloscope. Dans le constructeur, nous initialisons les variables nécessaires et configurons le graphique.

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)

Définition de la méthode de mise à jour

La méthode de mise à jour est appelée pour chaque image de l'animation. Elle prend une nouvelle valeur en entrée et met à jour le graphique en conséquence.

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,

Création de la fonction émettrice

La fonction émettrice génère les données qui seront transmises à la méthode de mise à jour. Dans ce cas, nous générons des données aléatoires avec une probabilité de 0,1.

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

Configuration du graphique

Nous créons un nouvel objet figure et un nouvel objet axe, puis nous initialisons la classe Scope. Ensuite, nous passons les fonctions de mise à jour et d'émission à la méthode FuncAnimation pour créer l'animation.

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

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

plt.show()

Résumé

Dans ce tutoriel, nous avons appris à utiliser Matplotlib pour créer un oscilloscope qui affiche les signaux de tension au fil du temps. Nous avons défini une classe Scope pour contenir les données et les méthodes nécessaires à l'oscilloscope, créé une méthode de mise à jour pour mettre à jour le graphique et utilisé la fonction émettrice pour générer les données. Enfin, nous avons configuré le graphique et passé les fonctions de mise à jour et d'émission à la méthode FuncAnimation pour créer l'animation.