Python-Schnittstelle

Die miniSMU MS01 lässt sich mit der offiziellen Python-Bibliothek minismu_py programmgesteuert bedienen. Mit dieser Schnittstelle können Sie bequem Messungen automatisieren, komplexe Prüfabläufe ausführen und die miniSMU in eigene Anwendungen und Forschungsabläufe einbinden.

Installation

Installieren Sie die Bibliothek minismu_py mit pip direkt aus PyPI:

pip install minismu_py

Die Bibliothek hat nur wenige Abhängigkeiten und benötigt:

Python 3.6 oder neuer
Das Paket pyserial für USB-Verbindungen
Das Paket tqdm (optional, für Fortschrittsbalken in den Beispielen)

Erste Schritte

Einfache Verbindung

Um mit der Python-Schnittstelle zu arbeiten, stellen Sie zunächst eine Verbindung zu Ihrer miniSMU MS01 her:

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())

Kontextmanager verwenden

Die Klasse SMU unterstützt das Kontextmanager-Protokoll von Python, das die Freigabe der Ressourcen automatisch übernimmt:

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

Einfaches Messbeispiel

Dieses einfache Beispiel konfiguriert einen Kanal, stellt eine Spannung ein und nimmt Messwerte auf:

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)

Grundbegriffe

Verbindungsarten

Die Bibliothek unterstützt zwei Verbindungsarten:

USB-Verbindung: Direkte Verbindung über ein USB-Kabel
```
smu = SMU(ConnectionType.USB, port="COM3")
```

Netzwerkverbindung: Verbindung über WLAN

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

Messmodi

Die miniSMU unterstützt zwei grundlegende Messmodi:

FVMI (Force Voltage, Measure Current: Spannung vorgeben, Strom messen)
- Eine festgelegte Spannung anlegen und den resultierenden Strom messen
- Geeignet für die Charakterisierung von Widerständen, die Prüfung von Dioden usw.
```
smu.set_mode(1, "FVMI")
```
FIMV (Force Current, Measure Voltage: Strom vorgeben, Spannung messen)
- Einen festgelegten Strom einprägen und die resultierende Spannung messen
- Geeignet für die Prüfung von LEDs, die Charakterisierung von Batterien usw.
```
smu.set_mode(1, "FIMV")
```

Fehlerbehandlung

Die Bibliothek bietet eine eigene Ausnahmebehandlung über die Klasse 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}")

Häufige Operationen

Geräteinformationen

# 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")

Kanalkonfiguration

# 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)

Ausgangswerte einstellen

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

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

Messwerte aufnehmen

# 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")

Kanalzustand steuern

# Enable channel
smu.enable_channel(1)

# Disable channel
smu.disable_channel(1)

Erweiterte Funktionen

Spannungs-Sweep

Mit einem Spannungs-Sweep können Sie I-V-Kennlinien aufnehmen:

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")

Daten-Streaming

Für die schnelle Datenerfassung unterstützt die miniSMU das Streaming von Daten:

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
    )

4-Leiter-Kelvin-Messungen

Für hochgenaue Messungen ohne Einfluss des Leitungswiderstands:

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()

WLAN-Konfiguration

Die Bibliothek bietet Funktionen zur Verwaltung der WLAN-Einstellungen:

# 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")

Anwendungsbeispiele

Bauelementcharakterisierung

Dieses Beispiel charakterisiert eine Diode mit einem Spannungs-Sweep und wertet die Ergebnisse aus:

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()

Automatisierter Prüfablauf

Dieses Beispiel zeigt einen automatisierten Prüfablauf für eine 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
    )

API-Referenz

Verbindungsverwaltung

Methode	Beschreibung
`SMU(connection_type, port, host, tcp_port)`	SMU-Verbindung initialisieren
`close()`	Verbindung schließen
`get_identity()`	Geräteidentifikation abfragen
`reset()`	Gerät zurücksetzen

Quelle und Messung

Methode	Beschreibung
`set_voltage(channel, voltage)`	Spannung für den angegebenen Kanal einstellen
`set_current(channel, current)`	Strom für den angegebenen Kanal einstellen
`measure_voltage(channel)`	Spannung am angegebenen Kanal messen
`measure_current(channel)`	Strom am angegebenen Kanal messen
`measure_voltage_and_current(channel)`	Spannung und Strom messen

Kanalkonfiguration

Methode	Beschreibung
`enable_channel(channel)`	Angegebenen Kanal aktivieren
`disable_channel(channel)`	Angegebenen Kanal deaktivieren
`set_voltage_range(channel, range_type)`	Spannungsbereich einstellen (AUTO/LOW/HIGH)
`set_mode(channel, mode)`	Kanalmodus einstellen (FIMV/FVMI)

Daten-Streaming

Methode	Beschreibung
`start_streaming(channel)`	Daten-Streaming starten
`stop_streaming(channel)`	Daten-Streaming beenden
`read_streaming_data()`	Streaming-Datenpaket lesen (Kanal, Zeitstempel, Spannung, Strom)
`set_sample_rate(channel, rate)`	Abtastrate in Hz einstellen

Systemkonfiguration

Methode	Beschreibung
`set_led_brightness(brightness)`	LED-Helligkeit einstellen (0–100)
`get_led_brightness()`	Aktuelle LED-Helligkeit abfragen
`get_temperatures()`	Systemtemperaturen abfragen (ADC, Kanal 1, Kanal 2)
`set_time(timestamp)`	Interne Uhr des Geräts stellen (Unix-Zeitstempel in Millisekunden)
`enable_fourwire_mode()`	4-Leiter-Kelvin-Messung aktivieren
`disable_fourwire_mode()`	4-Leiter-Modus deaktivieren, unabhängige Kanäle wiederherstellen
`get_fourwire_mode()`	Status des 4-Leiter-Modus abfragen (gibt bool zurück)

WLAN-Konfiguration

Methode	Beschreibung
`wifi_scan()`	Nach verfügbaren WLAN-Netzwerken suchen
`get_wifi_status()`	Aktuellen WLAN-Status abfragen
`set_wifi_credentials(ssid, password)`	WLAN-Zugangsdaten festlegen
`enable_wifi()`	WLAN aktivieren
`disable_wifi()`	WLAN deaktivieren

Bewährte Vorgehensweisen

Diese Vorgehensweisen empfehlen wir für die Arbeit mit der Bibliothek minismu_py:

1. Kontextmanager verwenden

Verwenden Sie immer die Kontextmanager von Python, damit Ressourcen ordnungsgemäß freigegeben werden:

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

2. Kanäle immer deaktivieren

Deaktivieren Sie die Kanäle, wenn die Messungen abgeschlossen sind:

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

3. Einschwingzeit einplanen

Planen Sie eine Einschwingzeit ein, damit die Messwerte stabil sind:

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

4. Ausnahmen richtig behandeln

Sorgen Sie für eine ordnungsgemäße Ausnahmebehandlung:

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

5. Verbindungsstatus prüfen

Prüfen Sie die Verbindung, bevor Sie Operationen ausführen:

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

6. Verbindungen schließen

Schließen Sie Verbindungen immer, wenn Sie fertig sind:

smu.close()

Fehlerbehebung

Häufige Probleme

Keine Verbindung zum Gerät
- Prüfen Sie, ob das Gerät eingeschaltet ist
- Prüfen Sie die USB-Kabelverbindung
- Prüfen Sie, ob der Portname stimmt
- Stellen Sie sicher, dass keine andere Software den Port verwendet
Kommunikationsfehler
- Setzen Sie das Gerät zurück
- Schließen Sie die Verbindung und öffnen Sie sie erneut
- Prüfen Sie auf Störungen oder Kabelprobleme
- Prüfen Sie, ob die Baudrate stimmt (115200)
Unerwartete Messergebnisse
- Prüfen Sie die Kanalkonfiguration (Modus, Bereich)
- Planen Sie eine ausreichende Einschwingzeit ein
- Prüfen Sie die Verbindungen zum Prüfling
- Prüfen Sie die Schutzgrenzen
Probleme mit der WLAN-Verbindung
- Stellen Sie sicher, dass die WLAN-Antenne richtig angeschlossen ist
- Prüfen Sie die WLAN-Zugangsdaten
- Prüfen Sie die Signalstärke
- Konfigurieren Sie das WLAN zunächst über eine USB-Verbindung

Weitere Ressourcen

Weitere fortgeschrittene Beispiele und ausführliche Dokumentation finden Sie im offiziellen Repository und in der oben verlinkten Dokumentation.

Python-Schnittstelle

Installation

Erste Schritte

Einfache Verbindung

Kontextmanager verwenden

Einfaches Messbeispiel

Grundbegriffe

Verbindungsarten

Messmodi

Fehlerbehandlung

Häufige Operationen

Geräteinformationen

Kanalkonfiguration

Ausgangswerte einstellen

Messwerte aufnehmen

Kanalzustand steuern

Erweiterte Funktionen

Spannungs-Sweep

Daten-Streaming

4-Leiter-Kelvin-Messungen

WLAN-Konfiguration

Anwendungsbeispiele

Bauelement­charakterisierung

Automatisierter Prüfablauf

API-Referenz

Verbindungs­verwaltung

Quelle und Messung

Kanalkonfiguration

Daten-Streaming

Systemkonfiguration

WLAN-Konfiguration

Bewährte Vorgehensweisen

1. Kontextmanager verwenden

2. Kanäle immer deaktivieren

3. Einschwingzeit einplanen

4. Ausnahmen richtig behandeln

5. Verbindungsstatus prüfen

6. Verbindungen schließen

Fehlerbehebung

Häufige Probleme

Weitere Ressourcen

Bauelementcharakterisierung

Verbindungsverwaltung