Spuitpompen zijn onmisbare hulpmiddelen voor het nauwkeurig doseren van vloeistoffen. Binnen deze categorie onderscheidt de LSPone zich in de wereld van laboratoriumautomatisering door zijn uitzonderlijke prestaties en veelzijdigheid.
In dit blogbericht onderzoeken we hoe u de LSPone spuitpomp kunt aansturen met Python en Matlab. Van het begrijpen van de mogelijkheden tot eenvoudige stapsgewijze instructies voor het instellen van communicatie-interfaces en het aansturen van de pomp; dit artikel is bedoeld om onderzoekers van elk niveau te ondersteunen. Of u nu voor het eerst werkt aan pompaansturing of op zoek bent naar geavanceerde technieken, deze handleiding helpt u om de LSPone spuitpomp volledig te beheersen.
INHOUDSOPGAVE
Waarom kiezen voor de LSPone laboratoriumspuitpomp?
De LSPone laboratoriumspuitpomp van Advanced Microfluidics SA is een innovatieve oplossing voor zeer nauwkeurige dosering in microfluïdica-onderzoek, waarbij precisiepumping wordt gecombineerd met een roterende klep met een laag volume. In combinatie met de LSPoneQuick-software kan deze vloeistoffen aanzuigen of doseren, het debiet regelen en vloeistofbehandeling automatiseren.
De LSPone onderscheidt zich door zijn uitzonderlijke doseernauwkeurigheid en nagenoeg pulsvrije stroming, wat aansluit bij uiteenlopende behoeften op het gebied van vloeistofbehandeling, variërend van milliliter- tot nanoliterniveaus. De selectieklep met een dood volume van nul vergemakkelijkt een efficiënt beheer van meerdere vloeistoffen met minimale kruisbesmetting, terwijl de gebruiksvriendelijke interface zorgt voor een moeiteloze bediening, waardoor de LSPone een perfecte keuze is voor laboratoriumexperimenten.
Belangrijke voordelen van de LSPone zijn onder andere het uitzonderlijke dode volume, interne volume en kruisbesmettingsvolume, wat de superioriteit ervan nog eens onderstreept. Met een dood volume van nul, een kruisbesmettingsvolume beperkt tot 1,5 µL en een intern volume van slechts 4 µL — gerealiseerd door de kleine kanaaldiameter van 0,5 mm — biedt deze spuitpomp ongeëvenaarde precisie en controle, waardoor snelle vloeistofwisselingen mogelijk zijn.
Bovendien garanderen de geoptimaliseerde stromingsbanen van de LSPone een onberispelijke biochemische compatibiliteit, doordat deze niet alleen verontreiniging beperken maar ook de reinigbaarheid maximaliseren. De hoge verdunningsverhouding, mogelijk gemaakt door het minimale kruisbesmettingsvolume, zorgt voor een maximale verdunning met het verdunningsmiddel, terwijl het unieke klepontwerp onmiddellijk lucht uit de spuit en klep verwijdert, wat zorgt voor een belletjesvrije ontluchting.
Wat heeft u nodig om te communiceren met de LSPone?
Om te communiceren met de LSPone laboratoriumspuitpomp heeft u een aantal essentiële componenten nodig:
- Een LSPone laboratoriumspuitpomp met een spuit naar keuze,
- Een mini-usb/usb-kabel of een DB9-connector (waarin RS-232 of RS-485 kan worden geïmplementeerd) voor seriële communicatie en gegevensoverdracht tussen de spuitpomp en de computer,
- Een seriële poort: de computer moet beschikken over een beschikbare seriële poort of een usb-naar-serieel-adapter om de kabel aan te sluiten
- De LSPoneQuick-software of een programmeerplatform (Matlab of een Python-omgeving met het PySerial-pakket dat de toegang tot de seriële poort inkapselt),
- Een basisbegrip van de LSPone-commandoset zoals beschreven in de gebruikershandleiding van de pomp.
Hoe configureert u de communicatiepoort?
Voordat u uw LSPone-pomp kunt gaan aansturen, is het essentieel om de communicatiepoort te configureren. Volg deze stappen om een verbinding tot stand te brengen 🛠️:
- Sluit de mini-usb/usb-kabel of DB9-connector aan op de seriële poort aan de achterkant van de pomp en de bijbehorende poort op de computer.
- Schakel de pomp in.
- Identificeer de naam van de seriële poort die aan de verbinding op uw computer is toegewezen (bijv. COM4 voor Windows of /dev/ttyUSB0 voor Linux). Deze informatie vindt u meestal in apparaatbeheer of door terminalcommando's te gebruiken.
- Zorg ervoor dat de instellingen van de seriële poort overeenkomen met de specificaties van uw spuitpomp:
- 1 startbit,
- 8 databits,
- Pariteit: geen,
- 1 stopbit,
- een baudrate van 9600 bit/s.
- Test de verbinding door een eenvoudig commando te verzenden, zoals het opvragen van de pompstatus.
De LSPone-commandoset
De LSPone biedt een reeks commando's voor contrôle externe, onderverdeeld in verschillende categorieën voor nauwkeurige aansturing. Deze omvatten sturingsinstructies, initialisatieprompts, klepafstellingen, zuigerbewegingen, configuratie-instellingen en uitgebreide rapportagefunctionaliteiten. Elk commando, met uitzondering van query's en speciale instructies die beginnen met "?" of "!", vereist de toegevoegde markering [R] voor uitvoering.
Merk op dat zodra een commando is gestart, het systeem geen nieuwe commando's accepteert, met uitzondering van onderbrekingen of statusverzoeken. Bovendien reageert het systeem onmiddellijk op ingevoerde commando's en meldt het fouten in geval van ongeldige invoer binnen de commandoreeks.
De LSPone-commandoset die wordt gebruikt om de LSPone-spuitpomp te besturen, wordt samengevat in de tabel hieronder. Meer commando's worden beschreven in de gebruikershandleiding van de pomp.
| Commando | Operand | Operandbeschrijving | Commandobeschrijving |
|---|---|---|---|
| R | N.v.t. | Commandoreeks uitvoeren | |
| X | N.v.t. | Geen volgende [R] | Laatst uitgevoerde commandoreeks opnieuw uitvoeren |
| G<n> | 0-60000 | 0 = Oneindig herhalen | Commandoreeks herhalen |
| g | N.v.t. | Maximale lusdiepte = 10 | Markeer het begin van een herhalingsreeks |
| M<n> | 0-86400000 | Milliseconden | Opdrachtuitvoering vertragen |
| H | N.v.t. | Geen volgende [R] | Opdracht onderbreken |
| @POWEROFF | N.v.t. | De pomp uitschakelen | |
| Z<n> or Y<n> | (void) of 0-3 | (void) of 0 = hoge kracht, 1 = normale kracht, 2 = gemiddelde kracht, 3 = lage kracht | De plunger drive initialiseren en de klep naar de nulpositie (home) brengen |
| O<n> | 1-max aantal klepposities (4, 6, 8, 10 of 12) | Beweging van de rotor tegen de klok in (klep van bovenaf gezien) | Verplaatsen naar kleppoort |
| I<n> | 1-max aantal klepposities (4, 6, 8, 10 of 12) | Beweging van de rotor met de klok mee (klep van bovenaf gezien) | Verplaatsen naar kleppoort |
| B<n> | 1-max aantal klepposities (4, 6, 8, 10 of 12) | Kortste verplaatsing van de rotor (richting met de klok mee heeft de voorkeur) | Verplaatsen naar kleppoort |
| A<n> | 0-3000 met N=0 0-24000 met N=1 | Absolute positie | |
| P<n> | 0-3000 met N=0 0-24000 met N=1 | Relatieve aanzuiging | |
| D<n> | 0-3000 met N=0 0-24000 met N=1 | Relatieve afgifte | |
| V<n> | 1-1600 | Piekwaarde snelheid (pulsen/sec) | Piekwaarde snelheid instellen |
| N<n> | 0-1 | <0> = microstep of 0.01 mm resolution <1> = microstep of 0.00125 mm resolution | Schaling van afgifte/aanzuiging. Motor wordt altijd in microstep-modus aangedreven |
Enkele rapportageopdrachten worden weergegeven in de tabel hieronder, terwijl de gedetailleerde set rapportageopdrachten te vinden is in de gebruikershandleiding van de pomp. Deze opdrachten hebben geen [R]-teken aan het einde nodig.
| Commando | Beschrijving |
|---|---|
| V | Huidige status |
| ? | Absolute plungerpositie |
| ?2 | Maximale snelheid |
| ?4 | Actuele plungerpositie |
| ?6 | Kleppositie |
| ?26 | Pompadres |
Voorbeelden van commando's
- /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.
Hoestuurt u de LSPone-pomp aan met de LSPoneQuick-software?
De LSPoneQuick-software biedt een gebruiksvriendelijke grafische interface die is ontworpen voor eenvoudige en efficiënte navigatie. Met de macro-opnamefunctie kunnen gebruikers stapsgewijs aangepaste geautomatiseerde reeksen creëren, en deze indien nodig eenvoudig raadplegen en aanpassen. Dankzij het eenvoudige ontwerp van de software heeft u snel toegang tot de functies van de LSPone, wat de bediening van de pomptaken vereenvoudigt.
Om de pomp met de software te verbinden, volgt u de instructies in de "Auto"-modus op het startscherm of schakelt u over naar de "Handmatige" modus en selecteert u een specifieke seriële poort. Zodra de verbinding tot stand is gebracht, wordt de pomp automatisch geïnitialiseerd en verschijnt het starttabblad van de software.
De software heeft drie verschillende tabbladen, zoals te zien is in de onderstaande schermafbeelding: het starttabblad, het tabblad voor macro-opname en het tabblad met instellingen.
Vanuit het starttabblad kunt u de pomp opnieuw initialiseren, stoppen, de resolutie van uw verplaatsing kiezen, het gewenste volume voor aanzuigen of dispenseren selecteren, de spuitsnelheid instellen, de kleppoort selecteren, enz.
In het tabblad macro-opname ziet u de commandolijst waarin alle acties die op het starttabblad zijn uitgevoerd automatisch worden opgeslagen. Dit maakt het mogelijk om het pompprogramma aan te sturen, te herhalen en op te slaan voor toekomstige toepassingen.
Vanuit het tabblad instellingen kunt u de communicatiepoort, de klepmodule en het spuitvolume invoeren.
Meer details over de LSPoneQuick-software zijn te vinden in de gebruikershandleiding van de software.
Hoe stuurt u de LSPone-pomp aan met Python?
De LSPone kan ook op afstand worden aangestuurd via programmeerplatforms zoals Python of Matlab. Dit biedt meer flexibiliteit en gemak, met name wanneer u continu complexe pompprogramma's wilt uitvoeren met lussen, pauzes en variërende debieten. Programmeerplatforms zijn bovendien bijzonder nuttig wanneer er tegelijkertijd verschillende apparaten worden gebruikt, omdat hiermee de automatisering van reeksen waarin al deze apparaten zijn opgenomen mogelijk wordt.
In dit gedeelte worden Python-codefragmenten gepresenteerd die tonen hoe u de seriële poort opent, aansturingscommando's naar de pomp schrijft en verzendt, en een pompprogramma voor de LSPone schrijft. We doorlopen codefragmenten die demonstreren hoe u veelvoorkomende taken uitvoert, zoals het verplaatsen naar een opgegeven kleppoort, het aanzuigen en dispenseren van vloeistoffen, enz. Deze voorbeelden zorgen voor een praktisch begrip van de op Python gebaseerde aansturing van de LSPone-spuitpomp.
Eerst maken we gebruik van de AMF Tools Python-bibliotheek, die specifiek is ontwikkeld voor de aansturing van AMF-producten zoals de LSPone. Daarnaast tonen we hoe u een eigen, aangepaste Python-bibliotheek kunt maken die is toegespitst op de commando's van de LSPone.
AMF Tools Python-bibliotheek
Advanced Microfluidics (AMF) heeft een python-bibliotheek geïntroduceerd die speciaal is ontworpen voor de aansturing van hun instrumenten, waaronder de RVM, SPM en LSPone. Om het AMFTools-pakket te installeren en te gebruiken, kunt u het volgende commando uitvoeren in de Python-console:
pip install AMFTools
De bibliotheek biedt een gestructureerde set commando's die worden gebruikt om te communiceren met AMF-apparaten. Deze commando's omvatten essentiële handelingen, variërend van het opzetten van verbindingen tot het uitvoeren van nauwkeurige bewegingen en aanpassingen. Deze zijn als volgt gegroepeerd:
- Algemene methoden: zoals het tot stand brengen en verbreken van verbindingen, het verzenden van commando's en het ontvangen van antwoorden van het apparaat.
- Instelfuncties: functies die bestemd zijn voor het configureren van verschillende parameters van het AMF-apparaat, waaronder adres, spuitgrootte, antwoordmodus, poortnummer, snelheid, versnelling en meer.
- Ophaalfuncties (get-functies): functies die het opvragen van informatie vergemakkelijken over de status van het apparaat, de configuratie, de firmwareversie, de kleppositie, de zuigerpositie en andere relevante parameters.
- Algemene actievensterfuncties: waaronder acties zoals het controleren van de klep- en pompstatus, het verplaatsen van de klep naar de doelpoort, het resetten van het apparaat en het uitschakelen ervan.
- Pompactiefuncties: deze categorie is specifiek gericht op gerelateerde pompbewerkingen en omvat functies voor absolute en relatieve positionering, volumeregeling, aanzuig- en dispenseeracties.
Voor verdere details met betrekking tot het volledige overzicht van functies, samen met de bijbehorende uitleg, verwijzen we u naar de pagina van AMF Tools op de Python Package Index.
Hieronder vindt u een praktisch codefragmentvoorbeeld dat demonstreert hoe u de AMF Tools Python-bibliotheek kunt gebruiken om een pompprogramma te construeren dat de acties uit de video (LSPone laboratorium-spuitpomp van de YouTube-pagina van Advanced Microfluidics SA) nabootst: de initialisatie (priming/ontluchting) van een LSPone-spuitpomp met een geïntegreerd distributieventiel met 6 poorten, die elk bruikbaar zijn als invoer of uitvoer.
'''
----------------------------------------------------------------------------
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)
Hoe communiceert u met de LSPone met behulp van de PySerial-bibliotheek?
In dit deel onderzoeken we hoe we kunnen communiceren met de LSPone-pomp met behulp van de PySerial-bibliotheek die wordt gebruikt voor toegang tot en besturing van seriële poorten, wat een handige interface biedt voor het verzenden en ontvangen van data naar en van seriële apparaten.
Het bijgeleverde codefragment demonstreert hoe commando's naar de LSPone-pomp worden verzonden, met verschillende voorbeelden (de reeds hierboven genoemde), waaronder het initialiseren van de pomp, het instellen van parameters zoals de pieksnelheid en het uitvoeren van complexe actiereeksen. Elk commando wordt verzonden via de `send_command`-methodefunctie.
'''
--------------------------------------------------
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()
Hoe stuurt u de LSPone-pomp aan met behulp van Matlab?
In deze sectie wordt een Matlab-codefragment gepresenteerd dat laat zien hoe u de seriële poort opent en besturingscommando's naar de pomp schrijft en verzendt. Hiervoor wordt een quick-start adapterklasse gedefinieerd, specifiek voor de commando's van de LSPone.
We doorlopen coderegels die aantonen hoe u veelvoorkomende taken uitvoert, zoals het verplaatsen naar een opgegeven kleppoort, het opzuigen en doseren van vloeistoffen, enz.
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);
Conclusie
In dit blogbericht hebben we de LSPone-laboratoriumspuitpomp geïntroduceerd en de grondbeginselen van de contrôle externe via twee programmeerplatforms, Python en Matlab, onderzocht met behulp van de LSPone-communicatiecommandoset. We hopen dat dit bericht dient als een waardevolle gids voor onderzoekers en ingenieurs die de LSPone-laboratoriumspuitpomp willen inzetten in hun microfluïdica-onderzoek en -experimenten.
Blijf op de hoogte voor meer inzichten, tutorials en praktijktoepassingen in onze toekomstige berichten. Veel succes met pompen en programmeren 💻!
📧 Als u vragen of opmerkingen heeft, neem dan gerust contact met ons op via support@darwin-microfluidics.com.

