Interface Python

Le miniSMU MS01 peut être piloté par programme à l’aide de la bibliothèque Python officielle, minismu_py. Cette interface offre un moyen pratique d’automatiser des mesures, d’exécuter des séquences de test complexes et d’intégrer le miniSMU à vos applications personnalisées et à vos flux de travail de recherche.

Installation

Installez la bibliothèque minismu_py directement depuis PyPI avec pip :

pip install minismu_py

La bibliothèque a peu de dépendances et nécessite :

Python 3.6 ou version ultérieure
Le paquet pyserial pour les connexions USB
Le paquet tqdm (facultatif, utilisé pour les barres de progression dans les exemples)

Prise en main

Connexion de base

Pour commencer à utiliser l’interface Python, vous devez d’abord établir une connexion avec votre miniSMU MS01 :

from minismu_py import SMU, ConnectionType

# For USB connection
smu = SMU(ConnectionType.USB, port="/dev/ttyACM0")  # Linux/Mac
# or
smu = SMU(ConnectionType.USB, port="COM3")  # Windows

# For WiFi connection
smu = SMU(ConnectionType.NETWORK, host="192.168.1.100", tcp_port=3333)

# Verify connection
print("Device Info:", smu.get_identity())

Utiliser un gestionnaire de contexte

La classe SMU prend en charge le protocole de gestionnaire de contexte de Python, qui libère automatiquement les ressources :

from minismu_py import SMU, ConnectionType

# Using context manager ensures proper cleanup
with SMU(ConnectionType.USB, port="COM3") as smu:
    # Work with the SMU
    print("Device Info:", smu.get_identity())
    
    # No need to explicitly close the connection
    # It will be closed automatically when exiting the 'with' block

Exemple de mesure simple

Voici un exemple simple qui configure une voie, règle une tension et effectue des mesures :

from minismu_py import SMU, ConnectionType
import time

with SMU(ConnectionType.USB, port="COM3") as smu:
    # Configure channel 1
    smu.set_mode(1, "FVMI")  # Force Voltage, Measure Current mode
    smu.set_voltage_range(1, "AUTO")
    smu.enable_channel(1)
    
    # Set voltage to 3.3V
    smu.set_voltage(1, 3.3)
    time.sleep(0.1)  # Allow settling time
    
    # Take measurements
    voltage, current = smu.measure_voltage_and_current(1)
    print(f"Voltage: {voltage:.6f}V")
    print(f"Current: {current:.6f}A")
    
    # Disable the channel when done
    smu.disable_channel(1)

Notions clés

Types de connexion

La bibliothèque prend en charge deux modes de connexion :

Connexion USB : connexion directe par un câble USB
```
smu = SMU(ConnectionType.USB, port="COM3")
```

Connexion réseau : connexion en Wi-Fi

smu = SMU(ConnectionType.NETWORK, host="192.168.1.100")

Modes de mesure

Le miniSMU prend en charge deux modes de mesure principaux :

FVMI (Force Voltage, Measure Current) (tension imposée, courant mesuré)
- Applique une tension donnée et mesure le courant qui en résulte
- Convient à la caractérisation de résistances, au test de diodes, etc.
```
smu.set_mode(1, "FVMI")
```
FIMV (Force Current, Measure Voltage) (courant imposé, tension mesurée)
- Applique un courant donné et mesure la tension qui en résulte
- Convient au test de LED, à la caractérisation de batteries, etc.
```
smu.set_mode(1, "FIMV")
```

Gestion des erreurs

La bibliothèque propose une gestion des exceptions qui lui est propre, grâce à la classe SMUException :

from minismu_py import SMU, ConnectionType, SMUException

try:
    with SMU(ConnectionType.USB, port="COM3") as smu:
        # SMU operations
        pass
except SMUException as e:
    print(f"SMU Error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

Opérations courantes

Informations sur l’appareil

# Get device identity
identity = smu.get_identity()
print(f"Connected to: {identity}")

# Get system temperatures
adc_temp, ch1_temp, ch2_temp = smu.get_temperatures()
print(f"Temperatures: ADC: {adc_temp}°C, CH1: {ch1_temp}°C, CH2: {ch2_temp}°C")

Configuration des voies

# Select channel to configure
channel = 1

# Set mode (FVMI: Force Voltage, Measure Current)
smu.set_mode(channel, "FVMI")

# Set voltage range (AUTO, LOW, HIGH)
smu.set_voltage_range(channel, "AUTO")

# Enable channel
smu.enable_channel(channel)

Réglage des valeurs de sortie

# Set voltage (in volts)
smu.set_voltage(1, 3.3)

# Set current (in amperes)
smu.set_current(2, 0.01)  # 10mA

Réalisation de mesures

# Measure voltage only
voltage = smu.measure_voltage(1)
print(f"Voltage: {voltage}V")

# Measure current only
current = smu.measure_current(1)
print(f"Current: {current}A")

# Measure both voltage and current in one command
voltage, current = smu.measure_voltage_and_current(1)
print(f"Voltage: {voltage}V, Current: {current}A")

Pilotage de l’état des voies

# Enable channel
smu.enable_channel(1)

# Disable channel
smu.disable_channel(1)

Fonctions avancées

Balayage en tension

Vous pouvez effectuer un balayage en tension pour tracer des courbes I-V :

import csv
from tqdm import tqdm
import time

def voltage_sweep(smu, channel=1, start=-1.0, stop=1.0, step=0.1):
    """Perform a voltage sweep and measure current"""
    try:
        # Configure channel
        smu.set_mode(channel, "FVMI")
        smu.set_voltage_range(channel, "AUTO")
        smu.enable_channel(channel)
        
        # Create voltage points
        voltages = [round(v, 3) for v in 
                   [start + step*i for i in range(int((stop-start)/step) + 1)]]
        results = []
        
        # Create progress bar
        for voltage in tqdm(voltages, desc="Voltage Sweep"):
            smu.set_voltage(channel, voltage)
            time.sleep(0.1)  # Allow settling time
            v, i = smu.measure_voltage_and_current(channel)
            results.append({
                'target_voltage': voltage,
                'measured_voltage': v,
                'measured_current': i
            })
        
        return results
            
    finally:
        # Always disable channel after measurement
        smu.disable_channel(channel)

# Run voltage sweep and save results
with SMU(ConnectionType.USB, port="COM3") as smu:
    sweep_results = voltage_sweep(smu, channel=1, start=-1.0, stop=1.0, step=0.05)
    
    # Save results to CSV
    with open('voltage_sweep_results.csv', 'w', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=[
            'target_voltage', 'measured_voltage', 'measured_current'])
        writer.writeheader()
        writer.writerows(sweep_results)
    print("Results saved to voltage_sweep_results.csv")

Streaming de données

Pour l’acquisition de données à haute vitesse, le miniSMU prend en charge le streaming de données :

import time
import csv
from tqdm import tqdm
from datetime import datetime

def stream_data(smu, channel=1, duration=10.0, sample_rate=100.0, voltage=3.3):
    """Stream data from the SMU for a specified duration"""
    try:
        # Configure channel
        smu.set_mode(channel, "FVMI")
        smu.enable_channel(channel)
        smu.set_voltage(channel, voltage)
        
        # Configure streaming
        smu.set_sample_rate(channel, sample_rate)
        
        # Set miniSMU's internal time for timestamping
        current_time = int(time.time() * 1000)  # Convert to milliseconds
        smu.set_time(current_time)
        
        # Calculate number of samples
        num_samples = int(duration * sample_rate)
        
        # Prepare data storage
        timestamps = []
        voltages = []
        currents = []
        
        # Start streaming
        print("Starting streaming...")
        smu.start_streaming(channel)
        
        # Collect data with progress bar
        pbar = tqdm(total=num_samples, desc="Streaming Data")
        while len(timestamps) < num_samples:
            try:
                # Read streaming data packet
                data_channel, t, v, i = smu.read_streaming_data()
                
                # Only process data from the requested channel
                if data_channel == channel:
                    timestamps.append(t)
                    voltages.append(v)
                    currents.append(i)
                    pbar.update(1)
                
            except Exception as e:
                print(f"\nError reading streaming data: {e}")
                break
        
        # Stop streaming
        smu.stop_streaming(channel)
        pbar.close()
        
        # Save data to CSV
        filename = f'streaming_data_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv'
        with open(filename, 'w', newline='') as f:
            writer = csv.writer(f)
            writer.writerow(['Timestamp (s)', 'Voltage (V)', 'Current (A)'])
            for t, v, i in zip(timestamps, voltages, currents):
                writer.writerow([t, v, i])
        
        print(f"Data saved to {filename}")
        return timestamps, voltages, currents
            
    finally:
        # Always cleanup
        smu.disable_channel(channel)
        smu.stop_streaming(channel)

# Stream data for 5 seconds at 100Hz
with SMU(ConnectionType.USB, port="COM3") as smu:
    timestamps, voltages, currents = stream_data(
        smu,
        channel=1,
        duration=5.0,
        sample_rate=100.0,
        voltage=3.3
    )

Mesures Kelvin 4 fils

Pour des mesures de haute précision, sans l’effet de la résistance des cordons :

with SMU(ConnectionType.USB, port="COM3") as smu:
    # Enable 4-wire mode (CH2 becomes sense channel)
    smu.enable_fourwire_mode()

    # Configure CH1 as voltage source
    smu.set_mode(1, "FVMI")
    smu.set_voltage(1, 1.0)
    smu.enable_channel(1)

    # Measure - returns CH1 current and CH2 (sense) voltage
    voltage, current = smu.measure_voltage_and_current(1)
    resistance = voltage / current
    print(f"True resistance: {resistance:.6f} Ohm")

    # Disable 4-wire mode when done
    smu.disable_fourwire_mode()

Configuration du Wi-Fi

La bibliothèque fournit des fonctions de gestion des paramètres Wi-Fi :

# Scan for available networks
networks = smu.wifi_scan()
for network in networks:
    print(f"SSID: {network['ssid']}, RSSI: {network['rssi']}")

# Configure WiFi credentials
smu.set_wifi_credentials("YourNetworkSSID", "YourPassword")

# Enable WiFi
smu.enable_wifi()

# Check WiFi status
status = smu.get_wifi_status()
print(f"Connected: {status.connected}")
print(f"SSID: {status.ssid}")
print(f"IP Address: {status.ip_address}")
print(f"Signal Strength: {status.rssi}dBm")

Exemples d’application

Caractérisation de composants

Cet exemple caractérise une diode en effectuant un balayage en tension et en analysant les résultats :

import numpy as np
import matplotlib.pyplot as plt
from minismu_py import SMU, ConnectionType

with SMU(ConnectionType.USB, port="COM3") as smu:
    # Configure channel
    smu.set_mode(1, "FVMI")
    smu.enable_channel(1)
    
    # Perform voltage sweep
    voltages = np.linspace(-0.5, 1.0, 100)  # -0.5V to 1.0V in 100 steps
    measured_voltages = []
    measured_currents = []
    
    for v in voltages:
        smu.set_voltage(1, v)
        time.sleep(0.05)  # Allow settling time
        mv, mi = smu.measure_voltage_and_current(1)
        measured_voltages.append(mv)
        measured_currents.append(mi)
    
    # Disable channel when done
    smu.disable_channel(1)
    
    # Plot results
    plt.figure(figsize=(10, 6))
    plt.plot(measured_voltages, measured_currents * 1000)  # Convert to mA
    plt.grid(True)
    plt.xlabel('Voltage (V)')
    plt.ylabel('Current (mA)')
    plt.title('Diode I-V Characteristic')
    plt.savefig('diode_iv_curve.png')
    plt.show()

Séquence de test automatisée

Cet exemple présente une séquence de test automatisée pour une batterie :

import time
import csv
from datetime import datetime
from minismu_py import SMU, ConnectionType

def battery_discharge_test(smu, channel=1, discharge_current=0.01, cutoff_voltage=3.0):
    """Perform battery discharge test until cutoff voltage is reached"""
    try:
        # Configure for constant current discharge (FIMV mode)
        smu.set_mode(channel, "FIMV")
        smu.enable_channel(channel)
        
        # Set discharge current (negative for discharge)
        smu.set_current(channel, -discharge_current)
        
        # Prepare data storage
        start_time = time.time()
        results = []
        
        print(f"Starting battery discharge test at {discharge_current*1000:.1f}mA")
        print(f"Test will run until battery voltage reaches {cutoff_voltage}V")
        
        # Run test until cutoff voltage is reached
        while True:
            # Measure voltage and current
            voltage, current = smu.measure_voltage_and_current(channel)
            
            # Calculate elapsed time
            elapsed_time = time.time() - start_time
            
            # Record data
            results.append({
                'time': elapsed_time,
                'voltage': voltage,
                'current': current
            })
            
            # Display progress
            print(f"\rTime: {elapsed_time:.1f}s, Voltage: {voltage:.3f}V, Current: {current*1000:.1f}mA", end="")
            
            # Check if cutoff voltage reached
            if voltage <= cutoff_voltage:
                print("\nCutoff voltage reached. Test complete.")
                break
            
            # Wait before next measurement
            time.sleep(5)  # Take measurements every 5 seconds
        
        # Save results
        filename = f'battery_discharge_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv'
        with open(filename, 'w', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=['time', 'voltage', 'current'])
            writer.writeheader()
            writer.writerows(results)
        print(f"Results saved to {filename}")
        
        return results
    
    finally:
        # Always disable channel when done
        smu.disable_channel(channel)

# Run battery discharge test
with SMU(ConnectionType.USB, port="COM3") as smu:
    battery_discharge_test(
        smu,
        channel=1,
        discharge_current=0.01,  # 10mA discharge
        cutoff_voltage=3.0       # 3.0V cutoff
    )

Référence de l’API

Gestion de la connexion

Méthode	Description
`SMU(connection_type, port, host, tcp_port)`	Initialise la connexion à la SMU
`close()`	Ferme la connexion
`get_identity()`	Lit l’identification de l’appareil
`reset()`	Réinitialise l’appareil

Source et mesure

Méthode	Description
`set_voltage(channel, voltage)`	Règle la tension de la voie indiquée
`set_current(channel, current)`	Règle le courant de la voie indiquée
`measure_voltage(channel)`	Mesure la tension sur la voie indiquée
`measure_current(channel)`	Mesure le courant sur la voie indiquée
`measure_voltage_and_current(channel)`	Mesure à la fois la tension et le courant

Configuration des voies

Méthode	Description
`enable_channel(channel)`	Active la voie indiquée
`disable_channel(channel)`	Désactive la voie indiquée
`set_voltage_range(channel, range_type)`	Règle la gamme de tension (AUTO/LOW/HIGH)
`set_mode(channel, mode)`	Règle le mode de la voie (FIMV/FVMI)

Streaming de données

Méthode	Description
`start_streaming(channel)`	Démarre le streaming de données
`stop_streaming(channel)`	Arrête le streaming de données
`read_streaming_data()`	Lit un paquet de données de streaming (voie, horodatage, tension, courant)
`set_sample_rate(channel, rate)`	Règle la fréquence d’échantillonnage, en Hz

Configuration du système

Méthode	Description
`set_led_brightness(brightness)`	Règle la luminosité des LED (0-100)
`get_led_brightness()`	Lit la luminosité actuelle des LED
`get_temperatures()`	Lit les températures du système (ADC, voie 1, voie 2)
`set_time(timestamp)`	Règle l’horloge interne de l’appareil (horodatage Unix en millisecondes)
`enable_fourwire_mode()`	Active le mode de mesure Kelvin 4 fils
`disable_fourwire_mode()`	Désactive le mode 4 fils et rétablit des voies indépendantes
`get_fourwire_mode()`	Interroge l’état du mode 4 fils (renvoie un booléen)

Configuration du Wi-Fi

Méthode	Description
`wifi_scan()`	Recherche les réseaux Wi-Fi disponibles
`get_wifi_status()`	Lit l’état actuel du Wi-Fi
`set_wifi_credentials(ssid, password)`	Règle les identifiants Wi-Fi
`enable_wifi()`	Active le Wi-Fi
`disable_wifi()`	Désactive le Wi-Fi

Bonnes pratiques

Voici quelques pratiques recommandées pour travailler avec la bibliothèque minismu_py :

1. Utilisez des gestionnaires de contexte

Utilisez toujours les gestionnaires de contexte de Python pour garantir la bonne libération des ressources :

with SMU(ConnectionType.USB, port="COM3") as smu:
    # Code here

2. Désactivez toujours les voies

Désactivez les voies une fois les mesures terminées :

try:
    smu.enable_channel(1)
    # Your measurement code
finally:
    smu.disable_channel(1)

3. Prévoyez un temps d’établissement

Prévoyez un temps d’établissement pour obtenir des mesures stables :

smu.set_voltage(1, 3.3)
time.sleep(0.1)  # Allow settling time before measuring

4. Gérez correctement les exceptions

Mettez en place une gestion correcte des exceptions :

try:
    # SMU operations
except SMUException as e:
    print(f"SMU Error: {e}")

5. Vérifiez l’état de la connexion

Vérifiez la connexion avant d’exécuter des opérations :

identity = smu.get_identity()
if not identity:
    print("Device not responding")

6. Fermez les connexions

Fermez toujours les connexions lorsque vous avez terminé :

smu.close()

Dépannage

Problèmes courants

Impossible de se connecter à l’appareil
- Vérifiez que l’appareil est sous tension
- Vérifiez le branchement du câble USB
- Vérifiez que le nom du port est correct
- Assurez-vous qu’aucun autre logiciel n’utilise le port
Erreurs de communication
- Réinitialisez l’appareil
- Fermez puis rouvrez la connexion
- Recherchez d’éventuelles interférences ou un problème de câble
- Vérifiez que le débit est correct (115 200 bauds)
Résultats de mesure inattendus
- Vérifiez la configuration de la voie (mode, gamme)
- Laissez un temps d’établissement suffisant
- Vérifiez les connexions au dispositif sous test
- Vérifiez les limites de protection
Problèmes de connexion Wi-Fi
- Assurez-vous que l’antenne Wi-Fi est correctement fixée
- Vérifiez les identifiants Wi-Fi
- Vérifiez la puissance du signal
- Essayez d’abord une connexion USB pour configurer le Wi-Fi

Ressources complémentaires

Pour des exemples plus avancés et une documentation détaillée, consultez le dépôt officiel et les liens de documentation ci-dessus.