Sélection de données pour tracer des graphes

[glmplx]

Bonjour ! Je voulais savoir s'il était possible de tracer plusieurs graphes sur LabVIEW à partir de données reçues d'un multimètre par communication GPIB, par exemple avec une périodisation de 1 secondes :
la valeur reçue à 1 seconde est tracé sur un premier graphe,
la valeur reçue à 2 seconde est tracé sur un deuxième graphe,
la valeur reçue à 3 seconde est tracé sur un troisième graphe,
la valeur reçue à 4 seconde est tracé sur le premier graphe,
la valeur reçue à 5 seconde est tracé sur le deuxième graphe,
la valeur reçue à 6 seconde est tracé sur le troisième graphe,
etc...

Voici un peu plus de précision : 

J'ai plusieurs capteurs résistifs, et un système de multiplexage fonctionnel permettant d'alterner entre chaque capteur afin de lire leur résistance avec un multimètre Keitlhey 6517 (appareil à plusieurs dizaines de milliers d'euros donc inutile de me conseiller de mettre un multimètre par capteurs). Et j'ai déjà un programme (ci-joints) pour afficher la valeur de la conductance (donc l'inverse de la résistance) sur un graphe.

[LVNinja]

sim, eh possivel. 

Vc precisa associar cada medida a uma variavel e plot em graphs separados. 

[glmplx]

Thank you much for your message, the problem is that I don't know how to select the values. Let's say there are 4 sensors, would I need a while loop to select the values and put them in a different array?

For example, in programming, it looks like this, with k sensors:

array = [[] for _ in range(k)]

while(1):

   array_index = (value of multimeter) % k

   array_index].append(value of multimeter)

[LVNinja]

I'm going to assume that the multiplexer switches between channels, and One multimeter reads the value , at every second switch and read. I will also assume that you want the plots to be updated continusouly until the user press stop. 

there are several ways to implement this: 

one way is to create a loop with one shift register for each channel. 

at each channel switch there is a case structure that will direct the reading to the appropriate Shift register. 

[glmplx]

Thank you much for your answer, I'll try to implement it in my program!

[glmplx]

So I managed to solve my problem using python, which was easier because I don't know much about LabVIEW :

import time

import pyvisa

import matplotlib.pyplot as plt

import pandas as pd

import serial

# Paramètres de communication série

port = 'COM8'  # Remplacez par le port série de votre Arduino

baudrate = 9600

# Ouvrir la connexion série

ser = serial.Serial(port, baudrate)

k = 8  # Nombre de capteurs, donc le nombre de graphes

tableaux = [[] for _ in range(k)]  # Création d'une liste de k tableaux vides

# Ouvrir une connexion avec le Keithley 6517

rm = pyvisa.ResourceManager()

keithley = rm.open_resource("GPIB0::27::INSTR")  # Remplacez l'adresse GPIB par celle de votre Keithley 6517

# Configurer le Keithley 6517

keithley.write(":SENS:FUNC 'RES'")

keithley.write(":SENS:RES:RANG:AUTO:LLIM 100")  # Limite inférieure automatique à 100 ohms

keithley.write(":SENS:RES:RANG:AUTO:ULIM 100000")  # Limite supérieure automatique à 100 000 ohms

keithley.write(":SOUR:VOLT:RANG 10")  # Plage de tension de 10V

keithley.write(":SOUR:VOLT:LEV 10")  # Niveau de tension de 10V

# Préparer les tracés des graphes

plt.ion()  # Activer le mode interactif

figure, axes = plt.subplots(k, 1, sharex=True)  # Créer k sous-graphes partageant l'axe des x

figure.suptitle("Mesure de conductance en direct", fontsize=14)

figure.subplots_adjust(hspace=0.5)  # Espacement vertical entre les sous-graphes

# Mesurer et tracer les graphes

timeList = [[] for _ in range(k)]  # Liste pour stocker les temps de mesure dans chaque tableau

start_time = time.time()  # Temps de référence pour le calcul du temps écoulé

# Activer la sortie du Keithley 6517

keithley.write(":OUTP ON")

# Effectuer les mesures et mettre à jour les graphes en direct

for _ in range(100😞  # Par exemple, effectuer 10 mesures

    time.sleep(1)  # Attendre 1 seconde pour la mesure

    line = ser.readline().decode('utf-8').strip()

    pin_number = line.split("PIN ")[1].split(" ")[0]

    capteur = int(pin_number) + 1

    response = keithley.query(':SENSe:DATA:FRESh?')

    data = response.split(',')

    resistance = float(data[0].replace('NOHM', ''))

    conductance =  resistance

    timestamp = time.time() - start_time  # Calcul du temps écoulé depuis le début

    # Ajouter la valeur de conductance au tableau correspondant

    tableau_index = capteur - 1

    tableaux[tableau_index].append(conductance)

    timeList[tableau_index].append(timestamp)  # Ajouter le temps correspondant

    # Tracer les graphes correspondants

    for i in range(k):

        axes[i].clear()

        axes[i].plot(timeList[i], tableaux[i], color='blue', linewidth=2)

        axes[i].set_xlabel('Temps (s)', fontsize=10)

        axes[i].set_ylabel(f'Conductance (Graphe {i + 1})', fontsize=10)

        axes[i].tick_params(labelsize=8)

    plt.draw()  # Dessiner les graphes mis à jour

    plt.pause(0.01)  # Pause pour permettre la mise à jour des graphes

# Désactiver la sortie du Keithley 6517

keithley.write(":OUTP OFF")

# Enregistrer les données dans des fichiers Excel

for i in range(k):

    data = {'Temps': timeList[i], 'Conductance': tableaux[i]}  # Création d'un dictionnaire avec les données du graphe i

    df = pd.DataFrame(data)  # Création d'un DataFrame à partir du dictionnaire

    filename = f'donnees_graphe_{i+1}.xlsx'  # Nom du fichier Excel de sortie pour le graphe i

    df.to_excel(filename, index=False)  # Écrire le DataFrame dans un fichier Excel

    print(f"Les données du graphe {i+1} ont été enregistrées dans le fichier", filename)

keithley.close()

plt.ioff()  # Désactiver le mode interactif

plt.show()  # Afficher les graphes finaux