Spritzenpumpen sind unverzichtbare Hilfsmittel für die präzise Dosierung von Flüssigkeitsmengen. Zu diesen gehört die LSPone hebt sich in der Welt der Laborautomatisierung durch ihre außergewöhnliche Leistung und Vielseitigkeit hervor.
In diesem Blogbeitrag werden wir uns damit befassen, wie man die LSPone-Spritzenpumpe mit Python und MATLAB steuert. Vom Verständnis ihrer Funktionen bis hin zu einfachen Schritt-für-Schritt-Anleitungen zur Einrichtung von Kommunikationsschnittstellen und zur Steuerung der Pumpe – dieser Beitrag soll Forschern aller Erfahrungsstufen neue Möglichkeiten eröffnen. Ganz gleich, ob Sie sich zum ersten Mal mit der Pumpensteuerung beschäftigen oder nach fortgeschrittenen Techniken suchen: Dieser Leitfaden wird Ihnen helfen, Ihre LSPone-Spritzenpumpe optimal zu nutzen.
INHALTSVERZEICHNIS
Warum sollten Sie sich für die LSPone-Laborspritzenpumpe entscheiden?
Die Laborspritzenpumpe LSPone von Advanced Microfluidics SA ist eine innovative Lösung für die hochpräzise Dosierung in der Mikrofluidik-Forschung, die hochpräzises Pumpen mit einem Rotationsventil für kleine Volumina kombiniert. In Verbindung mit der Software LSPoneQuick kann sie Flüssigkeiten ansaugen oder abgeben, die Durchflussrate steuern und die Handhabung von Flüssigkeiten automatisieren.
Der LSPone zeichnet sich durch seine außergewöhnliche Dosiergenauigkeit und einen nahezu pulsationsfreien Durchfluss aus und eignet sich für vielfältige Anforderungen im Bereich der Flüssigkeitshandhabung – von Millilitern bis hin zu Nanolitern. Sein Auswahlventil ohne Totvolumen ermöglicht eine effiziente Handhabung mehrerer Flüssigkeiten bei minimaler Verschleppung, während die benutzerfreundliche Oberfläche eine mühelose Bedienung gewährleistet, was den LSPone zur perfekten Wahl für Laborexperimente macht.
Zu den wichtigsten Vorteilen der LSPone zählen ihr außergewöhnlich geringes Totvolumen, ihr geringes Innenvolumen und ihr geringes Übertragungsvolumen, die ihre Überlegenheit noch weiter unterstreichen. Dank des fehlenden Totvolumens, eines auf 1,5 μl begrenzten Übertragungsvolumens und eines Innenvolumens von nur 4 μl – das durch den kleinen Kanaldurchmesser von 0,5 mm noch weiter reduziert wird – bietet diese Spritzenpumpe unübertroffene Präzision und Kontrolle und ermöglicht so schnelle Flüssigkeitswechsel.
Darüber hinaus gewährleisten die optimierten Strömungswege des LSPone, die nicht nur die Kontamination begrenzen, sondern auch die Reinigungsfähigkeit maximieren, eine einwandfreie biochemische Verträglichkeit. Sein hohes Verdünnungsverhältnis, das durch ein minimales Mitnahmevolumen ermöglicht wird, sorgt für eine maximale Verdünnung mit dem Verdünnungsmittel, während sein einzigartiges Ventildesign Luft sofort aus der Spritze und dem Ventil ablässt und so eine blasenfreie Vorfüllung ermöglicht.
Was benötigen Sie, um mit dem LSPone zu kommunizieren?
Für die Kommunikation mit der LSPone-Laborspritzenpumpe benötigen Sie einige wichtige Komponenten:
- Eine LSPone-Laborspritzenpumpe mit einer Spritze Ihrer Wahl,
- Ein Mini-USB-/USB -Kabel oder ein DB9-Stecker (RS-232 oder RS-485 kann darin verbaut werden), der die serielle Kommunikation ermöglicht und den Datenaustausch zwischen der Spritzenpumpe und dem Computer gewährleistet,
- Eine serielle Schnittstelle: Der Computer muss über eine freie serielle Schnittstelle oder einen Adapter für die Umwandlung von „ USB “ in ein serielles Signal verfügen, um das Kabel anschließen zu können.
- Die Software „LSPoneQuick“ oder eine Programmierplattform (Matlab- oder Python-Umgebung mit dem PySerial-Paket, das den Zugriff auf die serielle Schnittstelle kapseln),
- Grundlegende Kenntnisse des LSPone-Befehlssatzes, wie er im Benutzerhandbuch der Pumpe beschrieben ist.
Wie richte ich den Kommunikationsanschluss ein?
Bevor Sie mit der Steuerung Ihrer LSPone-Pumpe beginnen können, müssen Sie unbedingt den Kommunikationsanschluss 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 auf der Rückseite der Pumpe und an den entsprechenden Anschluss am Computer an.
- Schalten Sie die Pumpe ein.
- Ermitteln Sie den Namen der seriellen Schnittstelle, die der Verbindung auf Ihrem Computer zugewiesen ist (z. B. COM4 unter Windows oder /dev/ttyUSB0 unter Linux). Diese Information finden Sie in der Regel im Gerätemanager oder mithilfe von Terminalbefehlen.
- Stellen Sie sicher, dass die Einstellungen der seriellen Schnittstelle mit den Spezifikationen Ihrer Spritzenpumpe übereinstimmen:
- 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 eine Abfrage des Pumpenstatus.
Der LSPone-Befehlssatz
Das LSPone bietet eine Vielzahl von Befehlen für contrôle externe, die zur präzisen Steuerung in verschiedene Kategorien unterteilt sind. Dazu gehören Steuerbefehle, Initialisierungsaufforderungen, Ventileinstellungen, Kolbenbewegungen, Konfigurationsanpassungen und umfassende Berichtsfunktionen. Jeder Befehl – mit Ausnahme von Abfragen und Sonderbefehlen, die mit „?“ oder „!“ beginnen – erfordert zur Ausführung den angehängten Marker [R].
Insbesondere akzeptiert das System nach dem Start eines Befehls keine neuen Befehle mehr, mit Ausnahme von Unterbrechungen oder Abfrageanforderungen. Darüber hinaus reagiert das System umgehend auf Befehlseingaben und meldet Fehler, falls innerhalb der Befehlsfolge ungültige Eingaben auftreten.
Der LSPone-Befehlssatz zur Steuerung der LSPone-Spritzenpumpe ist in der folgenden Tabelle zusammengefasst. Weitere Befehle sind im Benutzerhandbuch der Pumpe ausführlich beschrieben.
| Befehl | Operand | Beschreibung des Operanden | Befehlsbeschreibung |
|---|---|---|---|
| R | k. A. | Befehlszeichenfolge ausführen | |
| X | k. A. | Kein nachgestelltes [R] | Zuletzt ausgeführte Befehlszeichenfolge erneut ausführen |
| G<n> | 0–60.000 | 0 = Endlosschleife | Befehlsfolge wiederholen |
| g | k. A. | Maximale Schleifentiefe = 10 de | Den Beginn einer Wiederholungssequenz markieren |
| M<n> | 0-86400000 | Millisekunden | Ausführung des Befehls verzögern |
| H | k. A. | Kein nachgestelltes [R] | Befehl „Halt“ |
| @POWEROFF | k. A. | Schalten Sie die Pumpe aus | |
| Z<n> or Y<n> | (leer) oder 0–3 | (void) oder 0 = hohe Kraft, 1 = normale Kraft, 2 = mittlere Kraft, 3 = geringe Kraft | Den Kolben drive initialisieren und das Ventil in die Ausgangsposition bringen |
| O<n> | 1 – maximale Anzahl der Ventilpositionen (4, 6, 8, 10 oder 12) | Bewegung des Ventilkegels gegen den Uhrzeigersinn (Ventil von oben betrachtet) | Zum Ventilanschluss bewegen |
| I<n> | 1 – maximale Anzahl der Ventilpositionen (4, 6, 8, 10 oder 12) | Bewegung des Stopfens im Uhrzeigersinn (Ventil von oben betrachtet) | Zum Ventilanschluss bewegen |
| B<n> | 1 – maximale Anzahl der Ventilpositionen (4, 6, 8, 10 oder 12) | Kürzeste Steckerbewegung (vorzugsweise im Uhrzeigersinn) | Zum Ventilanschluss bewegen |
| A<n> | 0–3000 bei N=0 0–24000 bei N=1 | Absolute Position | |
| P<n> | 0–3000 bei N=0 0–24000 bei N=1 | Relative Abholung | |
| D<n> | 0–3000 bei N=0 0–24000 bei N=1 | Relative Dosierung | |
| V<n> | 1–1600 | Spitzengeschwindigkeit (Impulse/Sek.) | 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 Berichtsbefehle sind in der folgenden Tabelle aufgeführt; eine vollständige Liste der Berichtsbefehle finden Sie im Benutzerhandbuch der Pumpe. Bei diesen Befehlen muss am Ende kein [R] stehen.
| Befehl | Beschreibung |
|---|---|
| F | Aktueller Stand |
| ? | Absolute Kolbenposition |
| ?2 | Höchstgeschwindigkeit |
| ?4 | Aktuelle Kolbenposition |
| ?6 | Ventilstellung |
| ?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 lässt sich die LSPone-Pumpe mit der LSPoneQuick-Software steuern?
Die LSPoneQuick-Software verfügt über eine benutzerfreundliche grafische Oberfläche, die für eine einfache und effiziente Navigation ausgelegt ist. Mit der Makroaufzeichnungsfunktion können Anwender Schritt für Schritt individuelle automatisierte Abläufe erstellen und diese bei Bedarf problemlos erneut aufrufen und anpassen. Das übersichtliche Design der Software ermöglicht einen schnellen Zugriff auf die Funktionen des LSPone, was die Handhabung der Pumpenaufgaben vereinfacht.
Um die Pumpe mit der Software zu verbinden, befolgen Sie die Anweisungen im Modus „Auto“ auf dem Startbildschirm oder wechseln Sie in den Modus „Manuell“ und wählen Sie einen bestimmten seriellen Anschluss aus. Sobald die Verbindung hergestellt ist, wird die Pumpe automatisch initialisiert und die Registerkarte „Startseite“ der Software angezeigt.
Die Software verfügt über drei verschiedene Registerkarten, wie auf dem folgenden Screenshot zu sehen ist: die Registerkarte „Startseite“, die Registerkarte „Makroaufzeichnung“ und die Registerkarte „Einstellungen“.
Auf der Registerkarte „Startseite“ können Sie die Pumpe neu initialisieren, sie anhalten, die Auflösung Ihrer Dosiermenge festlegen, das aufzunehmende oder abzugebende Volumen auswählen, die Spritzengeschwindigkeit einstellen, den Ventilanschluss auswählen usw.
Auf der Registerkarte „Makroaufzeichnung“ sehen Sie die Befehlsliste, in der alle auf der Registerkarte „Startseite“ ausgeführten Aktionen automatisch gespeichert werden. So können Sie das Pumpenprogramm steuern, wiederholen und für spätere Anwendungen speichern.
Auf der Registerkarte „Einstellungen“ können Sie den Kommunikationsanschluss, das Ventilmodul und das Spritzenvolumen eingeben.
Weitere Informationen zur LSPoneQuick-Software finden Sie im Benutzerhandbuch der Software.
Wie lässt sich die LSPone-Pumpe mit Python steuern?
Der LSPone lässt sich auch über Programmierplattformen wie Python oder Matlab fernsteuern, was Ihnen mehr Flexibilität und Komfort bietet, insbesondere wenn Sie kontinuierlich komplexe Pumpenprogramme mit Schleifen, Pausen und variierenden Durchflussraten ausführen möchten. Programmierplattformen sind zudem besonders interessant, wenn mehrere Geräte gleichzeitig zum Einsatz kommen, da sie die Automatisierung von Abläufen ermöglichen, an denen alle Geräte beteiligt sind.
In diesem Abschnitt werden Python-Codeausschnitte vorgestellt, die zeigen, wie man den seriellen Port öffnet, Steuerbefehlszeichenfolgen an die Pumpe schreibt und sendet sowie ein Pumpenprogramm auf den LSPone schreibt. Wir gehen Codeausschnitte durch, die veranschaulichen, wie man gängige Aufgaben wie das Ansteuern eines bestimmten Ventilanschlusses, das Aufnehmen und Abgeben von Flüssigkeiten usw. ausführt. Diese Beispiele vermitteln ein praxisnahes Verständnis der Python-basierten Steuerung der LSPone-Spritzenpumpe.
Zunächst werden wir die Python-Bibliothek „AMF Tools“ verwenden, die speziell für die Steuerung von AMF-Produkten wie dem LSPone entwickelt wurde. Darüber hinaus werden wir zeigen, wie man eine eigene Python-Bibliothek erstellt, die speziell auf die Befehle des LSPone zugeschnitten ist.
AMF Tools Python-Bibliothek
Advanced Microfluidics (AMF) hat einePython-Bibliothekeingeführt, die speziell für die Steuerung ihrer Geräte wie RVM, SPM und LSPone entwickelt wurde. Um das AMFTools-Paket zu installieren und zu nutzen, kann man den folgenden Befehl in der Python-Konsole ausführen:
pip install AMFTools
Die Bibliothek stellt eine strukturierte Sammlung von Befehlen zur Verfügung, die zur Interaktion mit AMF-Geräten dienen. Diese Befehle umfassen wesentliche Vorgänge, die vom Aufbau von Verbindungen bis hin zur Ausführung präziser Bewegungen und Einstellungen reichen. Sie sind wie folgt gruppiert:
- Allgemeine Methoden:beispielsweise das Herstellen und Beenden von Verbindungen, das Senden von Befehlen und das Empfangen von Antworten vom Gerät.
- Einstellungsfunktionen: Funktionen zur Konfiguration verschiedener Parameter des AMF-Geräts, darunter Adresse, Spritzengröße, Antwortmodus, Portnummer, Geschwindigkeit, Beschleunigung und mehr.
- Abfragefunktionen: Funktionen, die das Abrufen von Informationen zum Status des Geräts, zur Konfiguration, zur Firmware-Version, zur Ventilstellung, zur Kolbenstellung und zu anderen relevanten Parametern ermöglichen.
- Globale Aktionsfunktionen: Dazu gehören Aktionen wie die Überprüfung des Ventil- und Pumpenstatus, das Bewegen des Ventils zum Zielanschluss, das Zurücksetzen des Geräts und das Ausschalten des Geräts.
- Pumpenfunktionen: Diese Kategorie ist speziell auf pumpenbezogene Vorgänge ausgerichtet und umfasst Funktionen für die absolute und relative Positionierung, die Volumensteuerung sowie das Ansaugen und Dosieren.
Weitere Informationen zur umfassenden Liste der Funktionen sowie deren Erläuterungen finden Sie auf der Seite „AMF Tools“ im Python Package Index.
Im Folgenden finden Sie ein praktisches Code-Beispiel, das veranschaulicht, wie Sie mithilfe der AMF Tools Python-Bibliothek ein Pumpenprogramm erstellen können, das die im Video gezeigten Vorgänge nachbildet (LSPone-Labor-Spritzenpumpe von der YouTube-Seite von Advanced Microfluidics SA): Initialisierung (Befüllung/Entlüftung) 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 dem LSPone mithilfe der Pyserial-Bibliothek?
In diesem Abschnitt befassen wir uns damit, wie man mit der LSPone-Pumpe kommuniziert. Dabei nutzen wir die PySerial-Bibliothek, die für den Zugriff auf und die Steuerung von seriellen Schnittstellen dient und eine praktische Schnittstelle für das Senden und Empfangen von Daten zu und von seriellen Geräten bietet.
Der bereitgestellte Codeausschnitt veranschaulicht, wie Befehle an die LSPone-Pumpe gesendet werden, und enthält mehrere Beispiele (die oben aufgeführten), darunter die Initialisierung der Pumpe, die Einstellung von Parametern wie der Spitzendrehzahl und die Ausführung komplexer Aktionsabläufe. Jeder Befehl wird mithilfe der 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 lässt sich die LSPone-Pumpe mit MATLAB steuern?
In diesem Abschnitt wird ein Matlab-Codeausschnitt vorgestellt, der zeigt, wie man die serielle Schnittstelle öffnet, Steuerbefehlszeichenfolgen schreibt und an die Pumpe sendet. Zu diesem Zweck wird eine Schnellstart-Adapterklasse definiert, die speziell auf die Befehle des LSPone zugeschnitten ist.
Wir werden uns Codezeilen ansehen, die veranschaulichen, wie man gängige Aufgaben ausführt, wie z. B. das Anfahren eines bestimmten Ventilanschlusses, das Aufnehmen und Abgeben von Flüssigkeiten usw.
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 LSPone-Laborspritzenpumpe vorgestellt und die Grundlagen ihrer Programmierung ( contrôle externe ) über zwei Programmierplattformen – Python und MATLAB – unter Verwendung des LSPone-Kommandosatzes erläutert. Wir hoffen, dass dieser Beitrag Forschern und Ingenieuren, die die LSPone-Laborspritzenpumpe in ihrer Mikrofluidik-Forschung und bei ihren Experimenten einsetzen möchten, als wertvolle Orientierungshilfe dient.
Freut euch auf weitere Einblicke, Tutorials und praktische Anwendungsbeispiele in unseren kommenden Beiträgen. Bis dahin: Viel Spaß beim Pumpen und Programmieren 💻!
📧 Wenn Sie Fragen oder Anregungen haben, können Sie sich gerne an uns wenden unter support@darwin-microfluidics.com.

