Spritzenpumpe dienen als unverzichtbare Werkzeuge für die genaue Dosierung von Flüssigkeitsvolumina. Unter diesen hebt sich die LSPone in der Welt der Laborautomatisierung durch ihre außergewöhnliche Leistung und Vielseitigkeit hervor.
In diesem Blogbeitrag untersuchen wir, wie sich die Spritzenpumpe LSPone mit Python und Matlab steuern lässt. Von den grundlegenden Funktionen bis hin zu einfachen Schritt-für-Schritt-Anleitungen für die Einrichtung von Kommunikationsschnittstellen und die Pumpensteuerung soll dieser Beitrag Forschende aller Erfahrungsstufen unterstützen. Ganz gleich, ob Sie zum ersten Mal eine Pumpensteuerung einrichten oder nach fortgeschrittenen Techniken suchen – diese Anleitung hilft Ihnen dabei, Ihre Spritzenpumpe LSPone optimal zu beherrschen.
INHALTSVERZEICHNIS
Warum die Labor-Spritzenpumpe LSPone wählen?
Die Labor-Spritzenpumpe LSPone von Advanced Microfluidics SA ist eine innovative Lösung für die hochpräzise Dosierung in der mikrofluidischen Forschung und kombiniert hochpräzises Pumpen mit einem totvolumenarmen Drehschieberventil. In Verbindung mit der Software LSPoneQuick können damit Flüssigkeiten aspiriert oder dosiert, die Durchflussrate gesteuert und das Fluidik-Handling automatisiert werden.
Die LSPone zeichnet sich durch eine außergewöhnliche Dosiergenauigkeit und einen nahezu pulsationsfreien Fluss aus und deckt vielfältige Anforderungen an das Flüssigkeitsmanagement von Millilitern bis hin zu Nanolitern ab. Ihr Auswahlluftventil ohne Totvolumen ermöglicht ein effizientes Management mehrerer Medien mit minimalem Verschleppungsvolumen (Carryover), während die benutzerfreundliche Oberfläche eine mühelose Bedienung gewährleistet, was die LSPone zur perfekten Wahl für Laborexperimente macht.
Zu den Hauptvorteilen der LSPone gehören ihre hervorragenden Tot-, Innen- und Verschleppungsvolumina, die ihre Überlegenheit zusätzlich unterstreichen. Ohne Totvolumen, mit einem auf 1,5 μL begrenzten Verschleppungsvolumen und einem durch den geringen Kanalendurchmesser von 0,5 mm auf nur 4 μL reduzierten Innenvolumen bietet diese Spritzenpumpe eine unerreichte Präzision und Kontrolle, die schnelle Flüssigkeitswechsel erlaubt.
Darüber hinaus gewährleisten die optimierten Strömungswege der LSPone, die nicht nur eine Kontamination minimieren, sondern auch die Reinigbarkeit maximieren, eine tadellose biochemische Kompatibilität. Ihr hohes Verdünnungsverhältnis, begünstigt durch ein minimales Verschleppungsvolumen, sorgt für eine maximale Verdünnung mit dem Verdünnungsmittel, während ihr einzigartiges Ventildesign Luft unmittelbar aus Spritze und Ventil verdrängt und somit ein blasenfreies Ansaugen ermöglicht.
Was wird für die Kommunikation mit der LSPone benötigt?
Für die Kommunikation mit der Labor-Spritzenpumpe LSPone benötigen Sie einige wesentliche Komponenten:
- Eine Labor-Spritzenpumpe LSPone mit einer Spritze Ihrer Wahl,
- Ein Mini-USB-/USB-Kabel oder einen DB9-Anschluss (wobei RS-232 oder RS-485 darin implementiert werden können) für die serielle Kommunikation und den Datentransfer zwischen Spritzenpumpe und Computer,
- Eine serielle Schnittstelle: Der Computer muss über einen verfügbaren seriellen Anschluss oder einen USB-zu-Seruell-Adapter verfügen, um das Kabel anzuschließen.
- Die Software LSPoneQuick oder eine Programmierumgebung (Matlab- oder Python-Umgebung mit dem PySerial-Paket, das den Zugriff auf die serielle Schnittstelle kapselt),
- Ein grundlegendes Verständnis des LSPone-Befehlssatzes, der im Benutzerhandbuch der Pumpe beschrieben ist.
Wie richtet man den Kommunikationsport ein?
Bevor Sie mit der Steuerung Ihrer LSPone-Pumpe beginnen können, ist es wichtig, den Kommunikationsport zu konfigurieren. Befolgen Sie diese Schritte, um eine Verbindung herzustellen 🔧:
- Schließen Sie das Mini-USB/USB-Kabel oder den DB9-Stecker an den seriellen Anschluss an der Rückseite der Pumpe und an den entsprechenden Anschluss am Computer an.
- Schalten Sie die Pumpe ein.
- Identifizieren Sie den Namen des seriellen Ports, der der Verbindung auf Ihrem Computer zugewiesen ist (z. B. COM4 unter Windows oder /dev/ttyUSB0 unter Linux). Diese Information finden Sie typischerweise im Geräte-Manager oder durch die Verwendung von Terminalbefehlen.
- Stellen Sie sicher, dass die Einstellungen des seriellen Ports den Spezifikationen Ihrer Spritzenpumpe entsprechen:
- 1 Startbit,
- 8 Datenbits,
- Parität: keine,
- 1 Stoppbit,
- eine Baudrate von 9600 Bit/s.
- Testen Sie die Verbindung, indem Sie einen einfachen Befehl senden, beispielsweise das Abfragen des Pumpenstatus.
Der LSPone-Befehlssatz
Der LSPone bietet eine Reihe von Befehlen für die contrôle externe, die für eine präzise Handhabung in verschiedene Typen unterteilt sind. Dazu gehören Steuerungsanweisungen, Initialisierungsbefehle, Valve-Einstellungen, Kolbenbewegungen, Konfigurationseinstellungen und umfassende Berichtsfunktionen. Jeder Befehl, mit Ausnahme von Abfragen und speziellen Anweisungen, die mit „?“ oder „!“ beginnen, erfordert zur Ausführung das angehängte Markerzeichen [R].
Bemerkenswert ist, dass das System nach dem Start eines Befehls keine neuen Befehle mehr annimmt, es sei denn, es handelt sich um Unterbrechungen oder Berichtsanfragen. Darüber hinaus reagiert das System umgehend auf Befehlseingaben und meldet Fehler bei ungültigen Einträgen innerhalb der Befehlssequenz.
Der zur Steuerung der LSPone Spritzenpumpe verwendete LSPone-Befehlssatz ist in der Tabelle unten zusammengefasst. Weitere Befehle sind im Benutzerhandbuch der Pumpe detailliert beschrieben.
| Befehl | Operand | Operand-Beschreibung | Befehlsbeschreibung |
|---|---|---|---|
| R | N. z. | Befehlsstring ausführen | |
| X | N. z. | Kein nachgestelltes [R] | Zuletzt ausgeführten Befehlsstring erneut ausführen |
| G<n> | 0-60000 | 0 = Unendlich oft wiederholen | Befehlssequenz wiederholen |
| g | N. z. | Maximale Schleifentiefe = 10 | Den Start einer Wiederholungssequenz markieren |
| M<n> | 0-86400000 | Millisekunden | Befehlsausführung verzögern |
| H | N. z. | Kein nachgestelltes [R] | Befehl anhalten |
| @POWEROFF | N. z. | Pumpe herunterfahren | |
| Z<n> or Y<n> | (void) oder 0-3 | (void) oder 0 = hohe Kraft, 1 = normale Kraft, 2 = mittlere Kraft, 3 = geringe Kraft | Den plunger drive initialisieren und das Valve in die Home-Position bringen |
| O<n> | 1 bis max. Anzahl der Valve-Positionen (4, 6, 8, 10 oder 12) | Gegenuhrzeigersinn-Bewegung des Kükens (Ventil von oben betrachtet) | Zu Ventilport bewegen |
| I<n> | 1 bis max. Anzahl der Valve-Positionen (4, 6, 8, 10 oder 12) | Uhrzeigersinn-Bewegung des Kükens (Ventil von oben betrachtet) | Zu Ventilport bewegen |
| B<n> | 1 bis max. Anzahl der Valve-Positionen (4, 6, 8, 10 oder 12) | Kürzeste Kükenbewegung (Uhrzeigersinn wird bevorzugt) | Zu Ventilport bewegen |
| A<n> | 0-3000 mit N=0 0-24000 mit N=1 | Absolute Position | |
| P<n> | 0-3000 mit N=0 0-24000 mit N=1 | Relative Aufnahme | |
| D<n> | 0-3000 mit N=0 0-24000 mit N=1 | Relative Abgabe | |
| V<n> | 1-1600 | Spitzengeschwindigkeit (Impulse/s) | Spitzengeschwindigkeit einstellen |
| N<n> | 0-1 | <0> = microstep of 0.01 mm resolution <1> = microstep of 0.00125 mm resolution | Skalierung von Abgabe/Aufnahme. Der Motor wird stets im Mikroschrittmodus betrieben |
Einige Statusabfragebefehle sind in der Tabelle unten aufgeführt, während der vollständige Satz von Abfragebefehlen im Benutzerhandbuch der Pumpe zu finden ist. Diese Befehle erfordern kein abschließendes [R]-Zeichen.
| Befehl | Beschreibung |
|---|---|
| Q | Aktueller Status |
| ? | Absolute Kolbenposition |
| ?2 | Maximale Geschwindigkeit |
| ?4 | Tatsächliche Kolbenposition |
| ?6 | Ventilposition |
| ?26 | Pumpenadresse |
Beispiele für Befehle
- /1Z2R<CR>: Initialize the plunger drive with medium force and home the valve.
- /1V250R<CR>: Set the peak speed to 250 pulses/sec.
- /1I4P500M2000I8D500R<CR>: Move clockwise to valve port 4, trigger a pick-up move of 500 steps, delay the next command execution by 2 seconds, move clockwise to valve port 8 and execute a 500-step dispense.
- /1I2P1000B9gM1000D200G5R<CR>: Move clockwise to valve port 2, trigger a pick-up move of 1000 steps, move to valve port 9 with the shortest path then repeat the following 5 times: delay the command execution by 1 second before executing a 200-step dispense.
Wie steuert man die LSPone Pumpe mit der LSPoneQuick Software?
Die LSPoneQuick Software bietet eine benutzerfreundliche grafische Oberfläche für eine einfache und effiziente Navigation. Dank der Makroaufnahme-Funktion können Benutzer schrittweise benutzerdefinierte automatisierte Abläufe erstellen und diese bei Bedarf problemlos anpassen und modifizieren. Das schlichte Design der Software ermöglicht einen schnellen Zugriff auf die Funktionen der LSPone und erleichtert so die Handhabung der Pumpenaufgaben.
Um die Pumpe mit der Software zu verbinden, folgen Sie den Anweisungen im Modus „Auto“ auf dem Startbildschirm oder wechseln Sie in den Modus „Manual“ und wählen Sie einen spezifischen serielle Port aus. Nach der Verbindung wird die Pumpe automatisch initialisiert und die Registerkarte „Home“ der Software wird angezeigt.
Die Software verfügt über drei verschiedene Registerkarten, wie im Screenshot unten zu sehen ist: die Startseite, die Makroaufzeichnung und die Einstellungen.
Auf der Startseite können Sie die Pumpe neu initialisieren, anhalten, die Auflösung für den Hubweg wählen, das gewünschte Volumen zum Aufnehmen oder Abgeben einstellen, die Spritzengeschwindigkeit festlegen, den Ventilanschluss auswählen usw.
In der Registerkarte Makroaufzeichnung sehen Sie die Befehlsliste, in der alle auf der Startseite ausgeführten Aktionen automatisch gespeichert werden. Dies ermöglicht es, das Pumpprogramm zu steuern, zu wiederholen und für zukünftige Anwendungen zu sichern.
In den Einstellungen können Sie den Kommunikationsport, das Ventilmodul und das Spritzenvolumen eingeben.
Weitere Einzelheiten zur LSPoneQuick-Software finden Sie im Benutzerhandbuch der Software.
Wie steuert man die LSPone Pumpe mit Python?
Die LSPone kann auch aus der Ferne über Programmierplattformen wie Python oder MATLAB gesteuert werden, was Ihnen mehr Flexibilität und Komfort bietet – insbesondere dann, wenn Sie kontinuierlich komplexe Pumpprogramme mit Schleifen, Pausen und variierenden Flussraten ausführen möchten. Programmierplattformen sind zudem von besonderem Interesse, wenn verschiedene Geräte gleichzeitig eingesetzt werden, da sie die Automatisierung von Abläufen über alle Geräte hinweg ermöglichen.
In diesem Abschnitt werden Python-Codeausschnitte vorgestellt, die zeigen, wie man die serielle Schnittstelle öffnet, Steuerbefehle an die Pumpe schreibt und sendet sowie ein Pumpprogramm für die LSPone erstellt. Wir gehen anhand von Codeausschnitten durch, wie gängige Aufgaben wie das Anfahren eines bestimmten Ventilanschlusses sowie das Aufnehmen und Abgeben von Flüssigkeiten ausgeführt werden. Diese Beispiele vermitteln ein praxisnahes Verständnis der Python-basierten Steuerung der LSPone Spritzenpumpe.
Zunächst nutzen wir die AMF Tools Python-Bibliothek, die speziell für die Steuerung von AMF-Produkten wie der LSPone entwickelt wurde. Darüber hinaus zeigen wir, wie Sie eine eigene Python-Bibliothek erstellen, die speziell auf die Befehle der LSPone zugeschnitten ist.
AMF Tools Python-Bibliothek
Advanced Microfluidics (AMF) hat eine Python-Bibliothek eingeführt, die speziell für die Steuerung ihrer Instrumente wie RVM, SPM und LSPone entwickelt wurde. Um das AMFTools-Paket zu installieren und zu verwenden, kann der folgende Befehl in der Python-Konsole ausgeführt werden:
pip install AMFTools
Die Bibliothek stellt einen strukturierten Satz von Befehlen zur Verfügung, die für die Interaktion mit AMF-Geräten verwendet werden. Diese Befehle umfassen wesentliche Operationen, angefangen beim Aufbau von Verbindungen bis hin zur Ausführung präziser Bewegungen und Einstellungen. Sie sind wie folgt gruppiert:
- Allgemeine Methoden: wie das Herstellen und Trennen von Verbindungen, das Senden von Befehlen und das Empfangen von Antworten des Geräts.
- Set-Funktionen: Funktionen zur Konfiguration verschiedener Parameter des AMF-Geräts, einschließlich Adresse, Spritzengrösse, Antwortmodus, Portnummer, Geschwindigkeit, Beschleunigung und mehr.
- Get-Funktionen: Funktionen, die das Abrufen von Informationen über den Gerätestatus, die Konfiguration, die Firmware-Version, die Ventilposition, die Kolbenposition und andere relevante Parameter ermöglichen.
- Globale Aktionen: einschließlich Aktionen wie das Überprüfen des Ventil- und Pumpenstatus, das Bewegen des Ventils zum Zielport, das Zurücksetzen des Geräts und das Ausschalten.
- Pumpen-Aktionen: Diese Kategorie zielt speziell auf pumpenbezogene Operationen ab und umfasst Funktionen für die absolute und relative Positionierung, die Volumensteuerung sowie das Aufnehmen und Abgeben von Flüssigkeiten.
Weitere Einzelheiten zu der umfassenden Liste der Funktionen sowie deren jeweilige Erklärungen finden Sie auf der AMF Tools Seite im Python Package Index.
Unten sehen Sie ein praktisches Codeausschnitt-Beispiel, das demonstriert, wie man die AMF Tools Python-Bibliothek verwendet, um ein Pumpprogramm zu erstellen, das die im Video (LSPone-Labor-Spritzenpumpe von der Advanced Microfluidics SA YouTube-Seite) gezeigten Aktionen repliziert: Initialisierung (Ansaugen / Entlüften) einer LSPone Spritzenpumpe mit integriertem Verteilerventil mit 6 Anschlüssen, die jeweils als Ein- oder Ausgang genutzt werden können.
'''
----------------------------------------------------------------------------
Initialisation (priming/air purge) of an LSPone syringe pump with an integrated distribution valve with 6 ports each usable as input or output
----------------------------------------------------------------------------
'''
# Import the required module or class
from amfTools import AMF
#--------------------------------------#
# Establish a connection with the pump #
#--------------------------------------#
# Specify the serial port, the baud rate and the number of valve ports
serial_port = 'COM4' # change this according to your COM port
baud_rate = 9600
valve_ports = 6 # adjust the number of valve ports to the number you have
# Initialize the LSPone, create an instance of the AMFDevice class
LSPone = AMF(serial_port, baud_rate, valve_ports)
# Connect to the device
connected = LSPone.connect()
# Check if the connection is successful and print the appropriate message
if connected:
print("Connection successful!")
else:
print("Failed to connect.")
# Home the device, ensuring it is in a known state
LSPone.home()
#-----------------------------#
# Start the priming procedure #
#-----------------------------#
# Liquid picked-up from port 2 then expelled in port 6 used as an output. Pickup and dispense repeated a second time. Air totally removed after first priming. Same procedure applied for inputs 3, 4 and 5 for a bubble-free priming.
# Define the ports to be used as inputs in this pumping program
ports = [2, 3, 4, 5]
# Iterate through each port in the list
for port in ports:
# Perform pumping action twice for each port
for _ in range(2):
# Move to the specified input port with the shortest path
LSPone.valveShortestPath(port)
# Pickup 100 µL of the liquid knowing that the syringe size is 500 µL
LSPone.pumpPickupVolume(100,500)
# Move to port 6 with the shortest path
LSPone.valveShortestPath(6)
# Dispense the previously picked-up volume
LSPone.pumpDispenseVolume(100,500)
Wie kommuniziert man mit der LSPone über die Pyserial-Bibliothek?
In diesem Teil untersuchen wir die Kommunikation mit der LSPone Pumpe mithilfe der PySerial-Bibliothek, die für den Zugriff auf und die Steuerung von seriellen Schnittstellen verwendet wird und eine komfortable Schnittstelle zum Senden und Empfangen von Daten an bzw. von seriellen Geräten bietet.
Der bereitgestellte Codeausschnitt zeigt, wie Befehle an die LSPone Pumpe gesendet werden, wobei mehrere Beispiele aufgeführt sind (die bereits oben erwähnten), einschließlich der Initialisierung der Pumpe, der Einstellung von Parametern wie der Höchstgeschwindigkeit und der Ausführung komplexer Aktionssequenzen. Jeder Befehl wird über die Methode `send_command` gesendet.
'''
--------------------------------------------------
Writing/Reading Single Commands to/from the LSPone
--------------------------------------------------
'''
import serial
import time
class AMF:
# Initializing the object and establishing a serial connection with the corresponding data format
def __init__(self, COM):
self.COM = COM
self.ser = serial.Serial(COM, baudrate=9600, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS)
# Send a command to the device
def send_command(self, command, with_trailing_R=True):
# Wait for any previous response to clear
time.sleep(0.05)
self.ser.read_all()
command_str = f'/1{command}'
# Append 'R' to the command if specified
if with_trailing_R:
command_str += 'R'
# Append '\r' (carriage return) to the command
command_str += '\r'
# Write the command to the serial port
self.ser.write(command_str.encode())
time.sleep(0.05)
#------------------------------------------------#
# To execute a command with a trailing 'R': #
# send_command("command") #
# #
# To execute a command without a trailing 'R': #
# send_command("command", with_trailing_R=False) #
#------------------------------------------------#
# Get a response from the device
def get_response(self):
response = self.ser.readline().decode().strip()
return response
#----------------------------------------------#
# Examples on how to send commands to the pump #
#----------------------------------------------#
# Initialize the pump (12 port valve) with the specified COM port
LSPone = AMF('COM4')
# Initialize the plunger drive with medium force and home the valve
LSPone.send_command('Z2')
# Set the peak speed to 250 pulses/sec
LSPone.send_command('V250')
# Move clockwise to valve port 4, trigger a pick-up move of 500 steps, delay the next command execution by 2 seconds, move clockwise to valve port 8 and execute the 500-step dispense
LSPone.send_command('I4P500M2000I8D500')
# Move clockwise to valve port 2, trigger a pick-up move of 1000 steps, move to valve port 9 with the shortest path then repeat the following 5 times: delay the command execution by 1 second before executing a 200-step dispense
LSPone.send_command('I2P1000B9gM1000D200G5')
# Verify the valve port position
LSPone.send_command('?6', with_trailing_R=False)
LSPone.get_response()
Wie steuert man die LSPone Pumpe mit MATLAB?
In diesem Abschnitt wird ein MATLAB-Codeausschnitt vorgestellt, der zeigt, wie man die serielle Schnittstelle öffnet, Steuerbefehle an die Pumpe schreibt und sendet. Zu diesem Zweck wird eine Quick-Start-Adapterklasse definiert, die speziell auf die Befehle der LSPone ausgelegt ist.
Wir gehen Codezeilen durch, die demonstrieren, wie gängige Aufgaben wie das Anfahren eines bestimmten Ventilanschlusses, das Aufnehmen und Abgeben von Flüssigkeiten usw. ausgeführt werden.
classdef LSPone
properties
COM
ser
end
methods
% Initializing the object and establishing a serial connection
function obj = LSPone(COM)
obj.COM = COM;
obj.ser = serialport(obj.COM, 9600, 'Parity', 'none', 'StopBits', 1, 'DataBits', 8);
end
% Closing the serial connection and deleting the object
function delete(obj)
delete(obj.ser);
obj.ser = [];
end
% Sending a command to the device
function send_command(obj, command, with_trailing_R)
% make with_trailing_R true by default
if nargin 1600
error('Speed must be a positive integer smaller than 1600.');
end
obj.send_command(['V', num2str(speed)]);
end
% Get the valve position
function valve_position = get_valve_position(obj)
obj.send_command('?6',false);
valve_position = obj.get_response();
end
end
end
%----------------------------------------------------------------%
% Examples on how to use the defined class to control the LSPone %
%----------------------------------------------------------------%
% Connect the pump
% pump = LSPone('COM4');
% Initialize the plunger drive with medium force and home the valve
% pump.initialize_plunger(2);
% Move to port 4 with shortest path
% pump.move_shortest(4);
% Trigger a pick-up move of 1000 steps
% pump.relative_pickup(1000);
% Verify the valve port position
% pump.get_valve_position();
% Execute a 400-step dispense
% pump.relative_dispense(400);
% Move clockwise to valve port 2, trigger a pick-up move of 1000 steps, move to valve port 9 with the shortest path then repeat the following 5 times: delay the command execution by 1 second before executing a 200-step dispense
% pump.send_command('I2P1000B9gM1000D200G5');
% Disconnect and delete device
% delete(pump);
Fazit
In diesem Blogbeitrag haben wir die Labor-Spritzenpumpe LSPone vorgestellt und die Grundlagen für deren contrôle externe über zwei Programmierplattformen, Python und Matlab, unter Verwendung des LSPone-Kommunikationsbefehlssatzes untersucht. Wir hoffen, dass dieser Beitrag Forschern und Ingenieuren als wertvoller Leitfaden dient, die die Labor-Spritzenpumpe LSPone in ihrer mikrofluidischen Forschung und ihren Experimenten einsetzen möchten.
Bleiben Sie dran für weitere Einblicke, Tutorials und praktische Anwendungen in unseren zukünftigen Beiträgen. Bis dahin viel Erfolg beim Pumpen und Programmieren 💻!
📧 Bei Fragen oder Anmerkungen können Sie uns gerne kontaktieren unter support@darwin-microfluidics.com.

