Le siringhe pompa rappresentano strumenti indispensabili per l'erogazione accurata di volumi di liquido. Tra queste, l'LSPone si distingue nel panorama dell'automazione di laboratorio per le sue eccezionali prestazioni e versatilità.
In questo articolo del blog, esploreremo come controllare la siringa pompa LSPone utilizzando Python e Matlab. Dalla comprensione delle sue funzionalità alla fornitura di semplici istruzioni dettagliate per la configurazione delle interfacce di comunicazione e il controllo della pompa, questo articolo si propone di offrire supporto a ricercatori di qualsiasi livello. Che tu stia lavorando al controllo di una pompa per la primissima volta o che tu sia alla ricerca di tecniche avanzate, questa guida ti permetterà di padroneggiare la tua siringa pompa LSPone.
SOMMARIO
Perché scegliere la siringa pompa da laboratorio LSPone?
La siringa pompa da laboratorio LSPone di Advanced Microfluidics SA rappresenta una soluzione innovativa per il dosaggio ad alta precisione nella ricerca microfluidica, combinando un pompaggio di elevata precisione con una valvola rotativa a basso volume. Abbinata al software LSPoneQuick, consente di aspirare o erogare liquidi, controllare la portata e automatizzare la gestione dei fluidi.
L'LSPone si distingue per la sua eccezionale precisione di dosaggio e un flusso quasi privo di pulsazioni, rispondendo a diverse esigenze di manipolazione dei liquidi che vanno dai millilitri ai nanolitri. La sua valvola di selezione a volume morto zero agevoli una gestione efficiente di fluidi multipli con un carryover minimo, mentre l'interfaccia intuitiva garantisce un funzionamento agevole, rendendo l'LSPone la scelta ideale per gli esperimenti di laboratorio.
I principali vantaggi dell'LSPone includono i suoi eccezionali volumi morti, interni e di carryover, che ne sottolineano ulteriormente la superiorità. Senza volume morto, con un volume di carryover limitato a 1,5 μL e un volume interno di soli 4 μL ridotti dal diametro del canale ridotto a 0,5 mm, questa siringa pompa offre precisione e controllo ineguagliabili, consentendo rapidi cambi di liquido.
Inoltre, i percorsi di flusso ottimizzati dell'LSPone, che non solo limitano la contaminazione ma massimizzano anche la pulibilità, garantiscono un'impeccabile compatibilità biochimica. Il suo elevato rapporto di diluizione, favorito dal volume minimo di carryover, assicura la massima diluizione con il diluente, mentre il design unico della valvola espelle immediatamente l'aria dalla siringa e dalla valvola, consentendo un innesco privo di bolle.
Di cosa hai bisogno per comunicare con l'LSPone?
Per comunicare con la siringa pompa da laboratorio LSPone sono necessari alcuni componenti chiave:
- Una siringa pompa da laboratorio LSPone con una siringa a scelta,
- Un cavo mini-usb/usb o un connettore DB9 (è possibile implementare all'interno rs-232 o rs-485) che consenta la comunicazione seriale e il trasferimento dei dati tra la siringa pompa e il computer,
- Una porta seriale: il computer deve disporre di una porta seriale disponibile o di un adattatore da usb a seriale per collegare il cavo
- Il software LSPoneQuick o una piattaforma di programmazione (ambiente Matlab o Python con il pacchetto PySerial che incapsula l'accesso alla porta seriale),
- Una comprensione di base del set di comandi LSPone descritto in dettaglio nel manuale utente della pompa.
Come configurare la porta di comunicazione?
Prima di iniziare a controllare la pompa LSPone, è fondamentale configurare la porta di comunicazione. Seguire questi passaggi per stabilire una connessione 🔧:
- Collegare il cavo mini-usb/usb o il connettore DB9 alla porta seriale sul retro della pompa e alla porta corrispondente sul computer.
- Accendere la pompa.
- Identificare il nome della porta seriale assegnato alla connessione sul computer (ad esempio, COM4 per Windows o /dev/ttyUSB0 per Linux). In genere è possibile trovare queste informazioni in gestione dispositivi o utilizzando i comandi del terminale.
- Assicurarsi che le impostazioni della porta seriale corrispondano alle specifiche della siringa pompa:
- 1 bit di avvio,
- 8 bit di dati,
- Parità: nessuna,
- 1 bit di stop,
- una velocità di trasmissione (baud rate) di 9600 bit/s.
- Testare la connessione inviando un comando semplice, come l'interrogazione dello stato della pompa.
Il set di comandi LSPone
L'LSPone offre una serie di comandi per il contrôle externe, suddivisi in categorie distinte per una manipolazione precisa. Questi includono direttive di controllo, prompt di inizializzazione, regolazioni delle valvole, movimenti dello stantuffo, configurazioni delle impostazioni e funzionalità di reportistica complete. Ciascun comando, escluse le interrogazioni e le direttive speciali che iniziano con "?" o "!", richiede l'aggiunta del marcatore [R] per l'esecuzione.
In particolare, una volta avviato un comando, il sistema non accetta nuovi comandi, ad eccezione di interruzioni o richieste di report. Inoltre, il sistema risponde tempestivamente agli input di comando e segnala eventuali errori in caso di voci non valide all'interno della sequenza di comandi.
Il set di comandi LSPone utilizzato per controllare la siringa siringa LSPone è riassunto nella tabella sottostante. Ulteriori comandi sono descritti in dettaglio nel manuale utente della pompa.
| Comando | Operando | Descrizione dell'operando | Descrizione del comando |
|---|---|---|---|
| R | N/D | Esegue la stringa di comando | |
| X | N/D | Nessun [R] finale | Esegue nuovamente l'ultima stringa di comando eseguita |
| G<n> | 0-60000 | 0 = Ciclo continuo | Ripete la sequenza di comandi |
| g | N/D | Profondità massima del ciclo = 10 | Contrassegna l'inizio di una sequenza di ripetizione |
| M<n> | 0-86400000 | Millisecondi | Ritarda l'esecuzione del comando |
| H | N/D | Nessun [R] finale | Arresta il comando |
| @POWEROFF | N/D | Arresta la pompa | |
| Z<n> or Y<n> | (void) o 0-3 | (void) o 0 = forza alta, 1 = forza normale, 2 = forza media, 3 = forza bassa | Inizializza il drive del pistone e posiziona la valvola in posizione di home |
| O<n> | 1-numero massimo di posizioni della valvola (4, 6, 8, 10 o 12) | Movimento del rotore in senso antiorario (valvola vista dall'alto) | Sposta alla porta della valvola |
| I<n> | 1-numero massimo di posizioni della valvola (4, 6, 8, 10 o 12) | Movimento del rotore in senso orario (valvola vista dall'alto) | Sposta alla porta della valvola |
| B<n> | 1-numero massimo di posizioni della valvola (4, 6, 8, 10 o 12) | Movimento del rotore più breve (preferita la direzione oraria) | Sposta alla porta della valvola |
| A<n> | 0-3000 con N=0 0-24000 con N=1 | Posizione assoluta | |
| P<n> | 0-3000 con N=0 0-24000 con N=1 | Aspirazione relativa | |
| D<n> | 0-3000 con N=0 0-24000 con N=1 | Erogazione relativa | |
| V<n> | 1-1600 | Velocità di picco (impulsi/sec) | Imposta la velocità di picco |
| N<n> | 0-1 | <0> = microstep of 0.01 mm resolution <1> = microstep of 0.00125 mm resolution | Ridimensionamento di erogazione/aspirazione. Il motore viene sempre azionato in modalità microstep |
Alcuni comandi di report sono presentati nella tabella sottostante, mentre l'elenco dettagliato dei comandi di report è reperibile nel manuale utente della pompa. Questi comandi non richiedono un carattere [R] finale.
| Comando | Descrizione |
|---|---|
| Q | Stato attuale |
| ? | Posizione assoluta del pistone |
| ?2 | Velocità massima |
| ?4 | Posizione effettiva del pistone |
| ?6 | Posizione della valvola |
| ?26 | Indirizzo della pompa |
Esempi di comandi
- /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.
Come controllare la pompa LSPone utilizzando il software LSPoneQuick?
Il software LSPoneQuick presenta un'interfaccia grafica user-friendly progettata per una navigazione semplice ed efficiente. Grazie alla funzione di registrazione delle macro, gli utenti possono creare sequenze automatizzate personalizzate passo dopo passo, rivedendole e modificandoli facilmente secondo necessità. Il design essenziale del software consente un accesso rapido alle funzioni dell'LSPone, semplificando la gestione delle attività della pompa.
Per connettere la pompa al software, seguire le istruzioni in modalità "Auto" nella schermata iniziale oppure passare alla modalità "Manual" e selezionare una porta seriale specifica. Una volta stabilita la connessione, la pompa viene inizializzata automaticamente e viene visualizzata la scheda principale del software.
Il software è dotato di tre schede distinte, come si può osservare nello screenshot sottostante: la scheda principale, la scheda di registrazione delle macro e la scheda delle impostazioni.
Dalla scheda principale è possibile reinizializzare la pompa, arrestarla, selezionare la risoluzione dello spostamento, impostare il volume desiderato per l'aspirazione o l'erogazione, configurare la velocità della siringa, selezionare la porta della valvola, ecc.
Nella scheda di registrazione delle macro è possibile visualizzare l'elenco dei comandi in cui tutte le azioni eseguite nella scheda principale vengono salvate automaticamente, consentendo di controllare il programma di pompaggio, ripeterlo e salvarlo per applicazioni future.
Dalla scheda delle impostazioni è possibile inserire la porta di comunicazione, il modulo della valvola e il volume della siringa.
Ulteriori dettagli sul software LSPoneQuick sono disponibili nella guida utente del software.
Come controllare la pompa LSPone utilizzando Python?
L'LSPone può anche essere controllato da remoto tramite piattaforme di programmazione come Python o MATLAB, offrendo maggiore flessibilità e praticità, soprattutto quando si eseguono programmi di pompaggio complessi e continui con cicli, pause e portate variabili. Le piattaforme di programmazione risultano particolarmente utili quando si utilizzano diversi dispositivi contemporaneamente, poiché consentono l'automazione di sequenze che coinvolgono l'intero sistema di dispositivi.
In questa sezione verranno presentati frammenti di codice Python che mostrano come aprire la porta seriale, scrivere e inviare stringhe di comando di controllo alla pompa e scrivere un programma di pompaggio per l'LSPone. Esamineremo blocchi di codice che dimostrano come eseguire operazioni comuni, come lo spostamento verso una porta specifica della valvola, l'aspirazione e l'erogazione di liquidi, ecc. Questi esempi forniranno una comprensione pratica del controllo basato su Python della pompa siringa LSPone.
Innanzitutto, utilizzeremo la libreria Python AMF Tools, progettata specificamente per il controllo dei prodotti AMF come l'LSPone. Inoltre, mostreremo come creare una libreria Python personalizzata dedicata ai comandi dell'LSPone.
Libreria Python AMF Tools
Advanced Microfluidics (AMF) ha introdotto una libreria Python dedicata al controllo dei propri strumenti, tra cui RVM, SPM e LSPone. Per installare e utilizzare il pacchetto AMFTools, è possibile eseguire il seguente comando nella console Python:
pip install AMFTools
La libreria fornisce un insieme strutturato di comandi utilizzati per interagire con i dispositivi AMF. Questi comandi includono operazioni essenziali che vanno dalla configurazione delle connessioni all'esecuzione di movimenti e regolazioni precise, raggruppate come segue:
- Metodi generali: come l'apertura e la chiusura delle connessioni, l'invio di comandi e la ricezione di risposte dal dispositivo.
- Funzioni di impostazione (Set): funzioni dedicate alla configurazione di vari parametri del dispositivo AMF, tra cui indirizzo, dimensioni della siringa, modalità di risposta, numero di porta, velocità, accelerazione e altro.
- Funzioni di lettura (Get): funzioni che facilitano il recupero di informazioni sullo stato del dispositivo, sulla configurazione, sulla versione del firmware, sulla posizione della valvola, sulla posizione dello stantuffo e su altri parametri rilevanti.
- Funzioni di azione globale: incluse azioni come la verifica dello stato della valvola e della pompa, lo spostamento della valvola verso la porta di destinazione, il ripristino del dispositivo e lo spegnimento.
- Funzioni di azione della pompa: mirate specificamente alle operazioni correlate alla pompa, questa categoria comprende funzioni per il posizionamento assoluto e relativo, il controllo del volume e le azioni di aspirazione ed erogazione.
Per ulteriori dettagli sull'elenco completo delle funzioni e sulle relative spiegazioni, fare riferimento alla pagina di AMF Tools su Python Package Index.
Di seguito viene presentato un pratico esempio di snippet di codice che mostra come utilizzare la libreria Python AMF Tools per costruire un programma di pompaggio che replichi le azioni illustrate nel video (siringa siringa LSPone di laboratorio dalla pagina YouTube di Advanced Microfluidics): inizializzazione (adescamento/spurgo dell'aria) di una siringa LSPone dotata di una valvola di distribuzione integrata con 6 porte, ciascuna utilizzabile come ingresso o uscita.
'''
----------------------------------------------------------------------------
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)
Come comunicare con la pompa LSPone utilizzando la libreria Pyserial?
In questa parte esploriamo come comunicare con la pompa LSPone utilizzando la libreria PySerial, impiegata per accedere e controllare le porte seriali, fornendo una comoda interfaccia per l'invio e la ricezione di dati da e verso dispositivi seriali.
Il snippet di codice fornito mostra come inviare comandi alla pompa LSPone, con diversi esempi proposti (quelli presentati sopra) che includono l'inizializzazione della pompa, l'impostazione di parametri come la velocità di picco e l'esecuzione di sequenze complesse di azioni. Ogni comando viene inviato tramite il metodo `send_command`.
'''
--------------------------------------------------
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()
Come controllare la pompa LSPone utilizzando Matlab?
In questa sezione verrà presentato uno snippet di codice Matlab che illustra come aprire la porta seriale, scrivere e inviare stringhe di comando di controllo alla pompa. A tale scopo viene definita una classe di adattatore di avvio rapido, dedicata ai comandi dell'LSPone.
Esamineremo righe di codice che dimostrano come eseguire attività comuni come lo spostamento verso una porta di valvola specificata, il prelievo e l'erogazione di liquidi, ecc.
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);
Conclusione
In questo articolo del blog abbiamo introdotto la siringa da laboratorio LSPone e ne abbiamo esplorato le nozioni di base del contrôle externe tramite due piattaforme di programmazione, Python e Matlab, utilizzando il set di comandi di comunicazione dell'LSPone. Ci auguriamo che questo articolo funga da guida preziosa per ricercatori e ingegneri che desiderano impiegare la siringa da laboratorio LSPone nelle loro ricerche ed esperimenti di microfluidica.
Rimanete sintonizzati per ulteriori approfondimenti, tutorial e applicazioni pratiche nei nostri prossimi articoli. Fino ad allora, buon lavoro con il pompaggio e la programmazione 💻!
📧 Per qualsiasi domanda o riscontro, non esitate a contattarci all'indirizzo support@darwin-microfluidics.com.

