Las bombas de jeringa son herramientas indispensables para la administración precisa de volúmenes de líquido. Entre ellas, la LSPone destaca en el ámbito de la automatización de laboratorios por su rendimiento excepcional y su versatilidad.
En esta publicación del blog, exploraremos cómo controlar la bomba de jeringa LSPone mediante Python y Matlab. Desde la comprensión de sus capacidades hasta sencillas instrucciones paso a paso para configurar las interfaces de comunicación y controlar la bomba, este artículo pretende servir de apoyo a investigadores de todos los niveles. Tanto si trabaja por primera vez en el control de una bomba como si busca técnicas avanzadas, esta guía le permitirá dominar su bomba de jeringa LSPone.
ÍNDICE
¿Por qué elegir la bomba de jeringa de laboratorio LSPone?
La bomba de jeringa de laboratorio LSPone de Advanced Microfluidics SA es una solución innovadora para la dosificación de alta precisión en la investigación microfluídica, que combina un bombeo de alta precisión con una válvula rotativa de bajo volumen. Combinada con el software LSPoneQuick, permite aspirar o dispensar líquidos, controlar el caudal y automatizar la manipulación de fluidos.
La LSPone destaca por su excepcional precisión de dosificación y un flujo prácticamente sin pulsos, adaptándose a diversas necesidades de manipulación de líquidos que van desde mililitros hasta nanolitros. Su válvula de selección sin volumen muerto facilita una gestión eficiente de múltiples fluidos con una contaminación cruzada mínima, mientras que su interfaz intuitiva garantiza un funcionamiento sin esfuerzo, lo que convierte a la LSPone en la opción perfecta para experimentos de laboratorio.
Entre las principales ventajas de la LSPone destacan sus excepcionales volúmenes muertos, internos y de arrastre, que reafirman su superioridad. Al carecer de volumen muerto, presentar un volumen de arrastre limitado a 1,5 μL y contar con un volumen interno de tan solo 4 μL —reducido gracias al pequeño diámetro de canal de 0,5 mm—, esta bomba de jeringa ofrece una precisión y un control inigualables que permiten realizar cambios rápidos de líquido.
Además, las trayectorias de flujo optimizadas de la LSPone, que no solo limitan la contaminación sino que también maximizan la facilidad de limpieza, aseguran una compatibilidad bioquímica impecable. Su elevada tasa de dilución, facilitada por el volumen mínimo de arrastre, garantiza una dilución máxima con el diluyente, mientras que su exclusivo diseño de válvula expulsa el aire de la jeringa y de la válvula de inmediato, permitiendo un cebado sin burbujas.
¿Qué necesita para comunicarse con la LSPone?
Para establecer comunicación con la bomba de jeringa de laboratorio LSPone, necesitará algunos componentes clave:
- Una bomba de jeringa de laboratorio LSPone con una jeringa de su elección,
- Un cable mini-USB/USB o un conector DB9 (en el cual se pueden implementar rs-232 o rs-485) que permita la comunicación serie y posibilite la transferencia de datos entre la bomba de jeringa y el ordenador,
- Un puerto serie: El ordenador debe disponer de un puerto serie disponible o de un adaptador de USB a puerto serie para conectar el cable,
- El software LSPoneQuick o una plataforma de programación (entorno Matlab o Python con el paquete PySerial que encapsula el acceso al puerto serie),
- Una comprensión básica del conjunto de comandos de la LSPone detallado en el manual de usuario de la bomba.
¿Cómo configurar el puerto de comunicación?
Antes de comenzar a controlar su bomba LSPone, es fundamental configurar el puerto de comunicación. Siga estos pasos para establecer la conexión 🔧:
- Conecte el cable mini-USB/USB o el conector DB9 al puerto serie situado en la parte posterior de la bomba y al puerto correspondiente del ordenador.
- Encienda la bomba.
- Identifique el nombre del puerto serie asignado a la conexión en su ordenador (por ejemplo, COM4 en Windows o /dev/ttyUSB0 en Linux). Por lo general, puede encontrar esta información en el administrador de dispositivos o mediante comandos de terminal.
- Asegúrese de que la configuración del puerto serie coincida con las especificaciones de su bomba de jeringa:
- 1 bit de inicio,
- 8 bits de datos,
- Paridad: ninguna,
- 1 bit de parada,
- una velocidad de transmisión (baud rate) de 9600 bits/s.
- Pruebe la conexión enviando un comando simple, como consultar el estado de la bomba.
El conjunto de comandos LSPone
El LSPone ofrece una serie de comandos para el contrôle externe, categorizados en distintos tipos para una manipulación precisa. Estos incluyen directrices de control, solicitudes de inicialización, ajustes de válvulas, movimientos de émbolo, configuraciones de parámetros y funcionalidades de informes completos. Cada comando, excluyendo las consultas y las directrices especiales que comienzan con "?" o "!", requiere el marcador adjunto [R] para su ejecución.
Cabe destacar que, una vez iniciado un comando, el sistema no acepta nuevos comandos, salvo interrupciones o solicitudes de informes. Asimismo, el sistema responde de inmediato a la entrada de comandos y notifica errores en caso de introducciones no válidas dentro de la secuencia de comandos.
El conjunto de comandos LSPone utilizado para controlar la bomba de jeringa LSPone se resume en la tabla a continuación. Encontrará más comandos detallados en el manual de usuario de la bomba.
| Comando | Operando | Descripción del operando | Descripción del comando |
|---|---|---|---|
| R | N/A | Ejecutar cadena de comandos | |
| X | N/A | Sin [R] final | Reecutar la última cadena de comandos ejecutada |
| G<n> | 0-60000 | 0 = Bucle infinito | Repetir secuencia de comandos |
| g | N/A | Profundidad máxima del bucle = 10 | Marcar el inicio de una secuencia de repetición |
| M<n> | 0-86400000 | Milisegundos | Retardar la ejecución del comando |
| H | N/A | Sin [R] final | Comando de parada |
| @POWEROFF | N/A | Apagar la bomba | |
| Z<n> or Y<n> | (void) o 0-3 | (void) o 0 = fuerza alta, 1 = fuerza normal, 2 = fuerza media, 3 = fuerza baja | Inicializar el drive del émbolo y llevar la válvula a la posición de referencia (home) |
| O<n> | 1-máx. n.º de posiciones de válvula (4, 6, 8, 10 o 12) | Movimiento del rotor en sentido antihorario (válvula vista desde arriba) | Mover al puerto de la válvula |
| I<n> | 1-máx. n.º de posiciones de válvula (4, 6, 8, 10 o 12) | Movimiento del rotor en sentido horario (válvula vista desde arriba) | Mover al puerto de la válvula |
| B<n> | 1-máx. n.º de posiciones de válvula (4, 6, 8, 10 o 12) | Movimiento del rotor más corto (se prefiere el sentido horario) | Mover al puerto de la válvula |
| A<n> | 0-3000 con N=0 0-24000 con N=1 | Posición absoluta | |
| P<n> | 0-3000 con N=0 0-24000 con N=1 | Aspiración relativa | |
| D<n> | 0-3000 con N=0 0-24000 con N=1 | Dispensación relativa | |
| V<n> | 1-1600 | Velocidad máxima (pulsos/s) | Establecer la velocidad máxima |
| N<n> | 0-1 | <0> = microstep of 0.01 mm resolution <1> = microstep of 0.00125 mm resolution | Escalado de dispensación/aspiración. El motor siempre se drive en modo de micropasos |
Algunos comandos de informe se presentan en la tabla siguiente, mientras que el conjunto detallado de comandos de informe se puede encontrar en el manual de usuario de la bomba. Estos comandos no necesitan un carácter [R] al final.
| Comando | Descripción |
|---|---|
| Q | Estado actual |
| ? | Posición absoluta del émbolo |
| ?2 | Velocidad máxima |
| ?4 | Posición actual del émbolo |
| ?6 | Posición de la válvula |
| ?26 | Dirección de la bomba |
Ejemplos de comandos
- /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.
¿Cómo controlar la bomba LSPone utilizando el software LSPoneQuick?
El software LSPoneQuick presenta una interfaz gráfica intuitiva diseñada para una navegación fácil y eficiente. Con su función de grabación de macros, los usuarios pueden crear secuencias automatizadas personalizadas paso a paso, revisándolas y modificándolas fácilmente según sea necesario. El diseño simple del software permite un acceso rápido a las características de la LSPone, lo que simplifica la gestión de las tareas de la bomba.
Para conectar la bomba al software, siga las instrucciones en el modo "Auto" de la pantalla de inicio o cambie al modo "Manual" y seleccione un puerto serie específico. Una vez conectada, la bomba se inicializa automáticamente y se muestra la pestaña de inicio del software.
El software cuenta con tres pestañas distintas, como se puede ver en la captura de pantalla a continuación: la pestaña de inicio, la pestaña de grabación de macros y la pestaña de configuración.
Desde la pestaña de inicio, puede reinicializar la bomba, detenerla, elegir la resolución de su desplazamiento, seleccionar el volumen que desea aspirar o dispensar, configurar la velocidad de la jeringa, seleccionar el puerto de la válvula, etc.
En la pestaña de grabación de macros, puede ver el listado de comandos en el cual todas las acciones realizadas en la pestaña de inicio se guardan automáticamente, lo que permite controlar el programa de bombeo, repetirlo y guardarlo para futuras aplicaciones.
Desde la pestaña de configuración, puede introducir el puerto de comunicación, el módulo de la válvula y el volumen de la jeringa.
Se pueden encontrar más detalles sobre el software LSPoneQuick en la guía del usuario del software.
¿Cómo controlar la bomba LSPone utilizando Python?
La LSPone también se puede controlar de forma remota mediante plataformas de programación como Python o Matlab, lo que le otorga mayor flexibilidad y comodidad, especialmente si desea ejecutar programas de bombeo complejos de forma continua con bucles, pausas y caudales variables. Las plataformas de programación también son de especial interés cuando se utilizan diferentes dispositivos al mismo tiempo, ya que permiten la automatización de secuencias que involucran a todos los dispositivos.
En esta sección, se presentarán fragmentos de código en Python que muestran cómo abrir el puerto serie, escribir y enviar cadenas de comandos de control a la bomba, y escribir un programa de bombeo para la LSPone. Analizaremos fragmentos de código que demuestran cómo realizar tareas comunes como moverse a un puerto de válvula especificado, aspirar y dispensar líquidos, etc. Estos ejemplos proporcionarán una comprensión práctica del control de la bomba de jeringa LSPone basado en Python.
En primer lugar, utilizaremos la biblioteca de Python AMF Tools, diseñada específicamente para controlar productos de AMF como el LSPone. Además, demostraremos cómo crear una biblioteca de Python personalizada dedicada a los comandos del LSPone.
Biblioteca de Python AMF Tools
Advanced Microfluidics (AMF) ha introducido una biblioteca de python dedicada a controlar sus instrumentos, incluidos el RVM, el SPM y el LSPone. Para instalar y utilizar el paquete AMF Tools, se puede ejecutar el siguiente comando en la consola de Python:
pip install AMFTools
La biblioteca proporciona un conjunto estructurado de comandos utilizados para interactuar con los dispositivos de AMF. Estos comandos abarcan operaciones esenciales que van desde el establecimiento de conexiones hasta la ejecución de movimientos y ajustes precisos. Se agrupan de la siguiente manera:
- Métodos generales: tales como establecer y terminar conexiones, enviar comandos y recibir respuestas del dispositivo.
- Funciones de configuración (Set): funciones dedicadas a configurar varios parámetros del dispositivo AMF, incluida la dirección, el tamaño de la jeringa, el modo de respuesta, el número de puerto, la velocidad, la aceleración y más.
- Funciones de consulta (Get): funciones que facilitan la recuperación de información sobre el estado del dispositivo, la configuración, la versión de firmware, la posición de la válvula, la posición del émbolo y otros parámetros relevantes.
- Funciones de acción global: incluyen acciones como verificar el estado de la válvula y la bomba, mover la válvula al puerto de destino, restablecer el dispositivo y apagarlo.
- Funciones de acción de la bomba: Dirigidas específicamente a operaciones relacionadas con la bomba, esta categoría incluye funciones para el posicionamiento absoluto y relativo, el control de volumen, y las acciones de aspiración y dispensación.
Para obtener más detalles sobre la lista completa de funciones, junto con sus respectivas explicaciones, consulte la página de AMF Tools en el Python Package Index.
A continuación, se muestra un fragmento de código de ejemplo práctico que demuestra cómo utilizar la biblioteca de Python AMF Tools para construir un programa de bombeo que replique las acciones mostradas en el vídeo (bomba de jeringa de laboratorio LSPone de la página de YouTube de Advanced Microfluidics SA): inicialización (cebado/purgado de aire) de una bomba de jeringa LSPone con una válvula de distribución integrada que cuenta con 6 puertos, cada uno utilizable como entrada o salida.
'''
----------------------------------------------------------------------------
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)
¿Cómo comunicarse con el LSPone utilizando la biblioteca PySerial?
En esta parte, exploramos cómo comunicarse con la bomba LSPone utilizando la biblioteca PySerial, empleada para acceder y controlar puertos serie, lo que proporciona una interfaz conveniente para enviar y recibir datos hacia y desde dispositivos serie.
El fragmento de código proporcionado demuestra cómo enviar comandos a la bomba LSPone, con varios ejemplos incluidos (los presentados justo arriba), como la inicialización de la bomba, el ajuste de parámetros como la velocidad máxima y la ejecución de secuencias complejas de acciones. Cada comando se envía utilizando la función del método `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()
¿Cómo controlar la bomba LSPone utilizando Matlab?
En esta sección, se presentará un fragmento de código de Matlab que muestra cómo abrir el puerto serie, escribir y enviar cadenas de comandos de control a la bomba. Para ello, se define una clase de adaptador de inicio rápido, dedicada a los comandos del LSPone.
Analizaremos líneas de código que demuestran cómo realizar tareas comunes como moverse a un puerto de válvula especificado, aspirar y dispensar líquidos, etc.
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);
Conclusión
En esta publicación del blog, hemos presentado la bomba de jeringa de laboratorio LSPone y explorado los conceptos básicos de su contrôle externe a través de dos plataformas de programación, Python y Matlab, utilizando el conjunto de comandos de comunicación del LSPone. Esperamos que esta publicación sirva como una guía valiosa para investigadores e ingenieros que buscan emplear la bomba de jeringa de laboratorio LSPone en sus investigaciones y experimentos de microfluídica.
¡Manténgase atento para más información, tutoriales y aplicaciones prácticas en nuestras futuras publicaciones! Hasta entonces, ¡feliz bombeo y programación 💻!
📧 Si tiene alguna pregunta o comentario, no dude en contactarnos en support@darwin-microfluidics.com.

