La bomba peristáltica Reglo ICC (Control de Canal Independiente) de Masterflex Ismatec es un instrumento de alta precisión diseñado para ofrecer un control y una exactitud inigualables en la dispensación y transferencia de fluidos. Destaca por su capacidad para controlar de forma independiente la dirección y la velocidad de hasta cuatro canales, cada uno con programas únicos de inicio, parada, calibración, entre otros.
Con un rango de caudal de trabajo de 0,001 a 35 mL/min por canal y niveles de pulsación personalizables, esta bomba ofrece la flexibilidad necesaria para una gran variedad de aplicaciones. La interfaz digital intuitiva y la conectividad por rs-232 permiten la creación de secuencias de bombeo complejas y el control de varias bombas simultáneamente.
En esta entrada del blog, exploraremos cómo controlar la bomba peristáltica Reglo ICC utilizando el protocolo de comandos serie de Reglo ICC a través de dos plataformas de programación: Python y Matlab.
ÍNDICE
¿Por qué elegir la bomba peristáltica Reglo ICC?
La bomba peristáltica Reglo ICC es versátil y fácil de usar, destacando como una opción de primera línea para las necesidades de manipulación de fluidos tanto en laboratorios como en entornos industriales. Estas son algunas de sus ventajas clave:
- Control de canal independiente de hasta cuatro canales simultáneamente, cada uno con su propio programa, caudales y direcciones.
- Alta precisión y reproducibilidad, lo que garantiza una dispensación de fluidos precisa y uniforme al minimizar las diferencias entre tubos.
- Rango de caudal y pulsación ajustable con 6, 8 o 12 rodillos utilizados para ajustar la pulsación y el rango de caudal (un mayor número de rodillos se traduce en menor pulsatilidad y caudales más bajos).
- Opciones de control versátiles a través de su interfaz digital o conexión rs-232 (hasta ocho bombas en cadena tipo margarita).
- Modos de funcionamiento completos, que incluyen dispensación continua a un ritmo establecido, dispensación de un volumen en un período específico, calibración de cada canal, entre otros.
¿Qué se necesita para comunicarse con la bomba Reglo ICC?
Para comunicarse con la bomba peristáltica Reglo ICC, necesitará algunos componentes clave:
- Una bomba Reglo ICC con un cabezal de bomba y un tube de su elección,
- Un cable mini-usb/usb o un conector DB9 (conectado a un módulo de control rs-232) que permita la comunicación serie y la transferencia de datos entre la bomba de jeringa y el ordenador,
- Una plataforma de programación (Python y Matlab en este caso) o un emulador de terminal,
- Una comprensión básica del protocolo serie de comandos de la Reglo ICC explicado a continuación 👇 y detallado en la guía del usuario de la bomba.
¿Cómo configurar el puerto de comunicación?
Antes de comenzar a enviar y recibir datos de la bomba, debe configurar el puerto de comunicación correctamente. Siga estos pasos:
- 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). Normalmente puede encontrar esta información en el administrador de dispositivos o utilizando 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.
- El modo remoto en la pantalla de la bomba confirma que la conexión se ha establecido correctamente, lo que indica que la bomba está siendo controlada de forma remota por un ordenador a través de una conexión usb 2.0, Mini-B o rs-232.
El protocolo serie de comandos de la Reglo ICC
El protocolo de comandos de la Reglo ICC ofrece una serie de comandos para el contrôle externe, categorizados en distintos tipos para una manipulación precisa. Estos incluyen la gestión de la comunicación, los modos y ajustes de operación, las directivas de control, las configuraciones de ajustes, la calibración y más.
Existen dos tipos de mensajes: mensajes de respuesta enviados desde la bomba al PC y mensajes de solicitud enviados desde el PC a la bomba. Todos los mensajes se componen de una cadena de caracteres ASCII imprimibles. Cada mensaje termina con un retorno de carro o un retorno de carro y un avance de línea.
El protocolo de comandos de la Reglo ICC utilizado para controlar la bomba peristáltica Reglo ICC se resume a continuación. Puede encontrar más detalles en el manual de usuario de la bomba.
Formatos de tipo de datos
| Tipo de datos | Ancho | Unidad | Rango | Formato |
|---|---|---|---|---|
| Dirección | 1 | - | - | J = sentido horario K = sentido antihorario |
| Tipo discreto 1 | 1 a 4 | - | 0 a 9999 | 1 a 4 caracteres en base 10. Los dígitos no utilizados no se devuelven. |
| Tipo discreto 2 | 4 | - | 0 a 9999 | 4 caracteres en base 10. Valor justificado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo discreto 3 | 6 | - | 0 a 999999 | 6 caracteres en base 10. Valor justificado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo discreto 4 | 10 | - | 0 a 4294967295 | 10 caracteres en base 10. Valor justificado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo discreto 5 | 3 | - | 0 a 999 | 3 caracteres en base 10. Valor justificado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo discreto 6 | 5 | - | 0 a 99999 | 5 caracteres en base 10. Valor justificado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo fraccional 1 | Variable | - | - | XXXX.DD Ancho variable de la parte entera (XXXX). Punto decimal y dos dígitos a la derecha (.DD) siempre incluidos. |
| Tipo de volumen 1 | 7 | mL | - | mmmmEse ⇒ m.mmm × 10^se: mmmm — mantisa de 4 caracteres Punto decimal inferido después del primer carácter. E — carácter 'E' s — signo del exponente: + o - e — exponente de un solo dígito |
| Tipo de tiempo 1 | 1 a 8 | 0.1s | 0 a 35964000 (0 a 999 h) | 1 a 8 caracteres que representan el tiempo. Los dígitos no utilizados no se devuelven. |
| Tipo de tiempo 2 | 8 | 0.1s | 0 a 35964000 (0 a 999 h) | 8 caracteres que representan el tiempo. Valor justificado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
Mensajes de respuesta
Un mensaje de respuesta es un mensaje enviado desde la bomba al PC en respuesta a un mensaje de solicitud enviado por este último. Puede adoptar la forma de una respuesta de estado o de datos.
Un mensaje de respuesta de estado es un único carácter ASCII que indica si el comando se ha ejecutado con éxito o no. Los diferentes caracteres ASCII que indican el estado de ejecución del comando solicitado se representan en la tabla siguiente.
| Carácter ASCII | Definición | En hexadecimal | En base 10 |
|---|---|---|---|
| * | comando ejecutado con éxito | 0x2a | 42 |
| # | comando no ejecutado con éxito | 0x23 | 35 |
| + | respuesta positiva utilizada para ciertos comandos | 0x2b | 43 |
| - | respuesta negativa utilizada para ciertos comandos | 0x2d | 45 |
Se recibe una respuesta de datos de la bomba cuando el PC solicita los valores de los parámetros. Está compuesta por uno o más valores de parámetros de datos delimitados por espacios. Cada parámetro de datos en el mensaje de respuesta es un valor devuelto por la bomba en un formato definido por el mensaje de solicitud.
| Parámetro de datos 1 | [SP] | Parámetro de datos 2 | [SP] | … | Parámetro de datos n | [CR] | [LF] |
Mensajes de solicitud
Los mensajes de solicitud son enviados desde el PC hacia la bomba. Estos deben ser respondidos por un mensaje de respuesta procedente de la bomba.
Un comando de control de dispositivo (como se muestra a continuación) está compuesto por una cadena de caracteres ASCII imprimibles y finaliza con un retorno de carro [CR] o un retorno de carro [CR] y un avance de línea [LF]. Se dirige a una bomba o canal individual para consultar o configurar parámetros específicos.
| Dirección (1-4) | Código de comando | Parámetro de datos 1 | [VB] | Parámetro de datos 2 | [VB] | … | Parámetro de datos n | [CR] | [LF] |
En el caso de un bus de bombas conectadas en cadena («daisy-chained»), la dirección va de 1 a 8 (número máximo de bombas controladas simultáneamente). En el caso de que se controle una sola bomba, la dirección va de 1 a 4, correspondiendo al número de canales controlados de forma independiente, tal como se presenta en el comando de control anterior.
La cadena de comando consta típicamente de uno o dos caracteres que indican el tipo de comando. Los parámetros de datos son valores opcionales que pueden proporcionarse al configurar el valor de un parámetro. Por último, el carácter de barra vertical delimita los parámetros de datos.
Se pueden enviar diferentes comandos a la bomba relacionados con la gestión de comunicaciones, el drive de la bomba, modos de operación y ajustes, calibración, entre otros. Algunos de estos comandos direccionados directamente se enumeran en la tabla siguiente. Puede encontrar más comandos detallados en el manual de operación.
| Comando | Función | Establecer/Consultar | Respuesta de la bomba |
|---|---|---|---|
| H | Iniciar bomba | Establecer | * - : configuración de canal incorrecta |
| I | Detener bomba | Establecer | * |
| xI | Pausar el bombeo (STOP en modo RPM o caudal) | Establecer | * |
| J | Establecer el sentido de giro en sentido horario | Establecer | * |
| K | Establecer el sentido de giro en sentido antihorario | Establecer | * |
| xD | Consultar sentido de giro | Consultar | J : horario K : antihorario |
| xM | Obtener el modo actual de la bomba/canal | Consultar | L : RPM M : Caudal O : Volumen a caudal específico G : Volumen en función del tiempo Q : Volumen+Pausa N : Tiempo P : Tiempo+Pausa |
| L | Configurar la bomba/canal en modo RPM | Establecer | * |
| M | Configurar la bomba/canal en modo de caudal | Establecer | * |
| O | Configurar la bomba/canal en modo de volumen a caudal específico | Establecer | * |
| G | Configurar la bomba/canal en modo de volumen en función del tiempo | Establecer | * - : configuración de canal incorrecta |
| S | Configuración del caudal en modo RPM (0,01 RPM). Tipo discreto 3. | Establecer | * |
| S | Obtener la configuración de velocidad actual en RPM | Consultar | Tipo fraccional 1 |
| f | Configurar el caudal en RPM en el modo volumen/tiempo (mL/min). Tipo de volumen 2 (similar al tipo 1 pero sin el carácter 'E'). | Establecer | Tipo de volumen 1 |
| f | Obtener el caudal actual en volumen/tiempo (mL/min) | Consultar | Tipo de volumen 1 |
| xP | Obtener el tiempo de pausa del bombeo | Consultar | Tipo de tiempo 1 |
| xY | Iniciar la calibración en un canal | Establecer | * |
| xZ | Cancelar la calibración | Establecer | * |
Se utilizan diferentes símbolos para representar caracteres ASCII en los mensajes de solicitud definidos. Algunos de ellos se presentan en la tabla siguiente.
| Símbolo | Definición | En hexadecimal | En base 10 |
|---|---|---|---|
| [CR] | retorno de carro | 0x0d | 13 |
| [LF] | salto de línea | 0x0a | 10 |
| [SP] | espacio | 0x20 | 32 |
| [VB] | barra vertical | 0x7c | 124 |
| @ | carácter '@' | 0x40 | 64 |
Ejemplos de comandos
Para comunicarse con la bomba, es necesario comprender los distintos comandos que acepta y preparar las cadenas de comandos de control requeridas para el equipo.
En la tabla siguiente se presentan y explican algunos ejemplos de comandos con direccionamiento directo.
| Comando | Definición | Respuesta de la bomba | Definición |
|---|---|---|---|
| 1H[CR] | Iniciar el canal 1 | * | Comando ejecutado con éxito |
| 4I[CR] | Detener el canal 4 | * | Comando ejecutado con éxito |
| 2xD[CR] | Obtener la dirección del canal 2 | K[CR][LF] | La dirección de rotación es antihoraria |
| 3J[CR] | Establecer la dirección de rotación del canal 3 en sentido horario | * | Comando ejecutado con éxito |
| 1xM[CR] | Obtener el modo operativo del canal 1 | L[CR][LF] | El modo actual es RPM |
| 3G[CR] | Establecer el modo operativo del canal 3 en volumen por tiempo | * | Comando ejecutado con éxito |
| 1S[CR] | Obtener la velocidad del drive del canal 1 | 22.50[CR][LF] | Respuesta en formato de «tipo fraccional 1». La velocidad del drive es de 22.5 RPM |
| 1S004500[CR] | Establecer la velocidad del drive del canal 1 en 45 RPM. El ajuste de velocidad tiene una resolución de 0.01 RPM (45 asignado como 4500) en formato de «tipo discreto 3» con un ancho de 6 caracteres y los dígitos no utilizados a la izquierda rellenados con ceros (=> 004500). | * | Comando ejecutado con éxito |
| 3f[CR] | Obtener el caudal de bombeo del canal 3 | 1275E+1[CR][LF] | Respuesta en formato de «tipo de volumen 1» (mmmmEse => m.mmm x10se):
|
| 3f1500-3[CR] | Establecer el caudal de bombeo del canal 3 en 1.5 μL/min. Ajuste del caudal de bombeo en formato de «tipo de volumen 2» (mmmmse => m.mmm x10se). 1.5 µL/min = 1.500x10-3 mL/min, por lo tanto:
| 1500E-3[CR][LF] | Respuesta en formato de "tipo de volumen 1". |
¿Cómo controlar la bomba Reglo ICC utilizando IsmaTerm?
IsmaTerm es un software que permite controlar la bomba Reglo ICC. Se trata de un software de emulación de terminal que se comunica con la bomba a través del puerto serie rs-232. IsmaTerm se puede utilizar para poner en marcha y detener la bomba, configurar y consultar los parámetros de la bomba, así como programar su funcionamiento. Es compatible con sistemas operativos Windows y se puede descargar a través de este enlace.
Para comunicarse con la bomba, inicie el software IsmaTerm, seleccione el puerto COM correspondiente a la bomba e introduzca la configuración del puerto para modificar sus características (tal como se muestra en la figura siguiente). La velocidad de transmisión (baud rate) predeterminada es de 9600 bits/s, con 8 bits de datos, 1 bit de parada y sin paridad.
En la ventana de IsmaTerm, se pueden introducir comandos para controlar la bomba y visualizar sus respuestas. Estos comandos distinguen entre mayúsculas y minúsculas, y deben ir seguidos de un retorno de carro (tecla Intro).
La ventana de IsmaTerm presentada a continuación muestra algunos mensajes enviados y recibidos de la bomba, lo que permite iniciar/detener la bomba y establecer/consultar los parámetros de la misma. En este ejemplo, solo se está controlando el canal 3. Cada comando enviado a la bomba recibe una respuesta por parte de esta (mensajes previstos en la figura siguiente).
Los comandos recién presentados en la ventana de IsmaTerm se explican brevemente en la tabla a continuación.
| Comando | Definición | Respuesta de la bomba | Definición |
|---|---|---|---|
| 3H | Iniciar canal 3 | * | Comando ejecutado con éxito |
| 3xD | Obtener la dirección | K{13}{10} | El sentido de rotación es antihorario {13} — retorno de carro [CR] {10} — avance de línea [LF] |
| 3J | Establecer el sentido de rotación del canal en sentido horario | * | Comando ejecutado con éxito |
| 3xM | Obtener el modo operativo del canal 3 | L{13}{10} | El modo actual es RPM |
| 3S | Obtener la velocidad de consigna en RPM | 10.00{13}{10} | Tipo fraccional 1. Velocidad de rotación de 10 RPM. |
| 3S002400 | Establecer la velocidad a 24 RPM | * | Comando ejecutado con éxito |
| 3I | Detener canal 3 | * | Comando ejecutado con éxito |
Un comando de control enviado a la bomba se obtiene a veces tras realizar ciertos cálculos y conversiones. Por lo tanto, es importante preparar todos los comandos necesarios antes de iniciar el contrôle externe de la bomba.
Además, resulta más sencillo redactar estos comandos de control y transmitirlos a la bomba mediante un conjunto de códigos (previamente preparados), utilizando plataformas de programación como Python y Matlab, en lugar de escribir y enviar un comando de forma esporádica a la bomba a través de un programa de terminal. Estas plataformas no solo facilitan la comunicación con la bomba, sino también el contrôle externe con un bus de bombas, permitiendo además redactar un programa de bombeo con bucles, pausas, etc.
A continuación, se proporcionan y explican fragmentos de código de comunicación serie para un inicio rápido utilizando Python y Matlab, los cuales sirven como una breve introducción sobre cómo comunicarse con la bomba Reglo ICC a través de estas dos plataformas de programación.
¿Cómo controlar la bomba Reglo ICC usando Python?
La bomba Reglo ICC se puede controlar de forma remota mediante Python, lo que ofrece una mayor flexibilidad y comodidad para ejecutar programas de bombeo complejos con bucles, pausas y velocidades o caudales variables. Este enfoque es especialmente útil al integrar múltiples dispositivos, ya que permite la automatización de secuencias que involucran a todo el equipo conectado.
En esta sección, mostraremos primero cómo abrir el puerto serie y enviar comandos simples a la bomba utilizando Python. A continuación, se presentará una librería de Python personalizada y dedicada que utiliza el protocolo de comandos de Reglo ICC, lo que permite abrir el puerto serie y enviar cadenas de comandos de control a la bomba Reglo ICC. Cubriremos ejemplos que muestran cómo iniciar y detener la bomba, configurar la velocidad, establecer el caudal, etc., proporcionando una guía práctica para usar Python en el control de la bomba Reglo ICC.
'''
------------------------------------------------
Writing/Reading Simple Commands to/from the Pump
------------------------------------------------
'''
import serial # Python module for serial communication
# Open the serial port with the data format corresponding to the Reglo ICC pump
ser = serial.Serial('COM5', 9600, parity=serial.PARITY_NONE, bytesize=8, stopbits=1, timeout=None, xonxoff=0, rtscts=0) # modify your COM#
### Start channel 3 of the pump
# Method 1
cmd = str(3) + 'H' + chr(13) # concatenate strings :
# 3 represents channel 3
# 'H' to start the channel
# 13 for the carriage return [CR]
ser.write(cmd.encode()) # write the concatenated string to ser
# Method 2
ser.write(f'{3}H{chr(13)}'.encode()) # write string literals to ser
read_data = ser.read(ser.in_waiting).decode()
# read all the available bytes from the serial port connection as a char vector
# The pump returns '*' after a successful execution of the command
### Read the rotation direction of channel 3
ser.write(f'{3}xD{chr(13)}'.encode()) # 'xD' to get the rotation direction
read_data = ser.read(ser.in_waiting).decode()
# The pump returns : K[CR][LF] --> counter-clockwise
### Change the rotation direction of channel 3 to clockwise
ser.write((str(3) + 'J' + chr(13)).encode()) # 'J' to set the direction to clockwise
read_data = ser.read(ser.in_waiting).decode()
# The pump returns '*' after a successful execution of the command
### Change the setting speed to 24 RPM
ser.write((str(3) + 'S002400' + chr(13)).encode())
# Setting speed has a resolution of 0.01 RPM so 24 RPM is assigned as 2400
# Discrete type 3 data has a width of 6 characters with unused digits to the left being zeros --> 002400
read_data = ser.read(ser.in_waiting).decode()
# The pump returns '*' after a successful execution of the command
### Stop channel 3 of the pump
ser.write((str(3) + 'I' + chr(13)).encode()) # 'I' to stop the channel
read_data = ser.read(ser.in_waiting).decode()
# The pump returns '*' after a successful execution of the command
A continuación, se presenta la librería de Python personalizada que utiliza el protocolo de comandos de Reglo ICC. Esta librería permite la creación de programas de bombeo complejos, incluyendo características como pausas, bucles, lógica condicional y más, facilitando el control de un bus de bombas.
'''
------------------------------------------
Reglo ICC Peristaltic Pump Control Library
------------------------------------------
'''
import serial
import time
#---------------------------------------------------------------------------------#
# LIBRARY MANAGING THE COMMUNICATION WITH A REGLO ICC WITH 3 INDEPENDENT CHANNELS #
#---------------------------------------------------------------------------------#
class RegloICC:
# Initialize the pump
def __init__(self, COM):
self.COM = COM
# Open the serial port with the data format corresponding to the RegloICC pump
self.sp = serial.Serial(self.COM, 9600, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS)
self.direction = [0, 0, 0] # 0 = clockwise, 1 = counter-clockwise
self.mode = [0, 0, 0] # 0 = RPM, 1 = Flow Rate, 2 = Volume (over time), one can add here all other modes
self.speed = [0, 0, 0] # rotation speed for each channel in RPM mode
# Change the size of 'direction', 'mode' and 'speed' according to the total number of channels to control.
# In the case herein, 3 channels are being independently controlled
# Delete the pump
def __del__(self):
self.sp.close()
# Start the corresponding channel
def start_channel(self, channel):
command = f'{channel}H\r'.encode() # 'H' to start the channel
# \r for the carriage return [CR] required to tell the pump that the command is finished
self.sp.write(command) # write the command to the pump
time.sleep(0.1) # give the pump time to process the command after sending it before reading the response
return self.sp.read(self.sp.in_waiting).decode() # read the pump response
# Stop the corresponding channel
def stop_channel(self, channel):
command = f'{channel}I\r'.encode() # 'I' to stop the channel
self.sp.write(command)
time.sleep(0.1)
return self.sp.read(self.sp.in_waiting).decode()
# Set the rotation direction for a single channel
def set_direction(self, channel, direction):
if direction == 1:
command = f'{channel}K\r'.encode() # counter-clockwise
else:
command = f'{channel}J\r'.encode() # clockwise
self.sp.write(command)
self.direction[channel - 1] = direction # pyhton count starts from 0
time.sleep(0.1)
return self.sp.read(self.sp.in_waiting).decode()
# Get the rotation direction of a single channel
def get_direction(self, channel):
command = f'{channel}xD\r'.encode() # 'xD' to get the rotation direction
self.sp.write(command)
time.sleep(0.1)
# read the rotation direction from the corresponding channel
return self.sp.read(self.sp.in_waiting).decode()
# Set the speed for a single channel in RPM when in RPM mode
def set_speed(self, channel, speed): # in RPM, with speed less then 100
speed = max(min(speed, 100), 0) # speed between 0 and 100 RPM
speed_string = f'{int(speed):03d}{int((speed - int(speed)) * 100)}' # format speed explained below
command = f'{channel}S0{speed_string}\r'.encode()
self.sp.write(command) # set the speed for the corresponding channel
self.speed[channel - 1] = speed
time.sleep(0.1)
return self.sp.read(self.sp.in_waiting).decode()
#--------------------------------------------------------------------------------#
# SPEED_STRING EXAMPLE #
## Speed value : #
# speed = 123.456 #
# #
## Convert the integer part to a string with at least three digits : #
# integer_part = f'{int(speed):03d}'; ## --> Result: '123' #
# #
## Convert the decimal part to a string with two digits : #
# decimal_part = f'{int((speed - int(speed)) * 100)}'; ## --> Result: '45' #
# #
## Concatenate the two parts : #
# speed_string = f'{int(speed):03d}{int((speed - int(speed)) * 100)}'; #
## --> Result: '12345' representing 123.45 in fixed-point notation #
# #
## When the two strings are concatenated, the result is a string that represents #
## the original speed value in a fixed-point notation with three digits before #
## the decimal point and two digits after, without the decimal separator. #
#--------------------------------------------------------------------------------#
# Read out speed of a single channel in RPM when in RPM mode
def get_speed(self, channel):
command = f'{channel}S\r'.encode() # 'S' to get the setting speed in RPM
self.sp.write(command)
time.sleep(0.1)
return self.sp.read(self.sp.in_waiting).decode()
# Set the operational mode for a single channel (you can add all other modes)
def set_mode(self, channel, mode):
if mode == 0:
command = f'{channel}L\r'.encode() # RPM mode
elif mode == 1:
command = f'{channel}M\r'.encode() # Flow rate mode
else:
command = f'{channel}G\r'.encode() # Volume (over time) mode
self.sp.write(command)
self.mode[channel - 1] = mode
time.sleep(0.1)
return self.sp.read(self.sp.in_waiting).decode()
# Get the operational mode of a single channel
def get_mode(self, channel):
command = f'{channel}xM\r'.encode() # 'xM' to get the operational mode
self.sp.write(command)
time.sleep(0.1)
return self.sp.read(self.sp.in_waiting).decode()
#----------------------------------------------------------------------------#
# EXAMPLES ON HOW TO USE THE DEFINED CLASS TO CONTROL THE Reglo ICC PUMP #
#----------------------------------------------------------------------------#
### Initialize the pump with the specified COM port
pump = RegloICC('COM5') # Replace 'COM5' with your actual COM port
### Start channel 3
pump.start_channel(3)
### Get the rotation direction of channel 3
print(pump.get_direction(3))
### Set the rotation direction of channel 3 to clockwise
pump.set_direction(3, 0)
### Get the current operational mode of channel 3
print(pump.get_mode(3))
### Set the operational mode of channel 3 to RPM
pump.set_mode(3, 0)
### Get the current speed setting of channel 3
print(pump.get_speed(3))
### Set the setting speed of channel 3 to 24 RPM
pump.set_speed(3, 24)
### Stop channel 3
pump.stop_channel(3)
### Delete the pump object
del pump
¿Cómo controlar la bomba Reglo ICC usando Matlab?
En esta sección, se presentarán fragmentos de código de Matlab que muestran cómo abrir el puerto serie, escribir y enviar cadenas de comandos de control a la bomba. A continuación, se define una clase adaptadora de inicio rápido diseñada específicamente para gestionar los comandos de Reglo ICC.
Repasaremos líneas de código que demuestran cómo realizar tareas comunes como iniciar o detener la bomba, configurar la velocidad, obtener la dirección de rotación, etc.
%-------------------------------------------------
% Writing/Reading Simple Commands to/from the Pump
%-------------------------------------------------
%% Open the serial port with the data format corresponding to the Reglo ICC pump
sp = serialport('COM5',9600,'Parity','None','DataBits',8,'StopBits',1); % open the serial port
%% Start channel 3 of the pump (method 1)
cmd = strcat(num2str(3),'H',13); % concatenate strings :
% 3 represents channel 3,
% 'H' to start the channel
% 13 for the carriage return [CR]
write(sp,cmd,"uint8"); % write the concatenated string to sp
%% Start channel 3 of the pump (method 2)
fprintf(sp,'%s',strcat(num2str(3),'H',13)); % formats the concatenated string according to '%s' (character vector or string array) and writes it to sp
read_data = read(sp,sp.NumBytesAvailable,"char");
% read all the available bytes from the serial port connection as a char vector
%% Read the rotation direction of channel 3
cmd = strcat(num2str(3),'xD',13); % 'xD' to get the rotation direction
write(sp,cmd,"uint8");
read_data = read(sp,sp.NumBytesAvailable,"char");
%% The pump returns : K[CR][LF]. Change the rotation direction of channel 3 to clockwise
write(sp,strcat(num2str(3),'J',13),"uint8"); % 'J' to set the direction to clockwise
read_data = read(sp,sp.NumBytesAvailable,"char");
%% Change the setting speed to 24 RPM
write(sp,strcat(num2str(3),'S002400',13),"uint8");
% Setting speed has a resolution of 0.01 RPM so 24 RPM is assigned as 2400
% Discrete type 3 data has a width of 6 characters with unused digits to the left being zeros --> 002400
read_data = read(sp,sp.NumBytesAvailable,"char");
%% Stop channel 3 of the pump
write(sp,strcat(num2str(3),'I',13),"uint8"); % 'I' to stop the channel
read_data = read(sp,sp.NumBytesAvailable,"char");
%-----------------------------------------
% Reglo ICC Peristaltic Pump Adapter Class
%-----------------------------------------
%--------------------------------------------------------------------------------------%
% CUSTOM CLASS MANAGING THE COMMUNICATION WITH A REGLO ICC WITH 3 INDEPENDENT CHANNELS %
%--------------------------------------------------------------------------------------%
classdef RegloICC
%%% Define the class properties
properties
% Change the size of 'direction', 'mode' and 'speed' according to the total number of
% channels to control. In the case herein, 3 channels are being independently controlled
sp = []; % serial port
COM = ''; % input parameter: COM port to use for the pump
direction = [0 0 0]; % direction of rotation of each channel: 0 = clockwise, 1 = counter-clockwise
mode = [0 0 0]; % operational mode of each channel: 0 = RPM, 1 = Flow Rate, 2 = Volume (over time), one can add here all other modes (check Table 3)
speed = zeros(3,1); % rotation speed for each channel in case of RPM mode
end
%%% Define the class methods
methods
% Initialize the pump
function obj = RegloICC(COM)
obj.COM = COM;
obj.sp = serialport(obj.COM,9600,'Parity','None','DataBits',8,'StopBits',1); % open the serial port with the data format corresponding to the RegloICC pump
end
% Delete the pump
function obj = delete(obj)
delete(obj.sp);
obj.sp = [];
end
% Start the corresponding channel
function start_channel(obj,channel)
write(obj.sp,strcat(num2str(channel),'H',13),"uint8"); % 'H' to start the channel
% 13 for the carriage return [CR] required to tell the pump that the command is finished
pause(0.1); % give the pump time to process the command before reading the response
while obj.sp.NumBytesAvailable > 0 % clear the buffer
read(obj.sp, obj.sp.NumBytesAvailable, "char");
end
end
% Stop the corresponding channel
function stop_channel(obj,channel)
write(obj.sp,strcat(num2str(channel),'I',13),"uint8"); % 'I' to stop the channel
pause(0.1);
while obj.sp.NumBytesAvailable > 0
read(obj.sp, obj.sp.NumBytesAvailable, "char");
end
end
% Set the rotation direction for a single channel
function obj = set_direction(obj,channel,direction)
if direction == 1
write(obj.sp,strcat(num2str(channel),'K',13),"uint8"); % counter-clockwise rotation
pause(0.1);
while obj.sp.NumBytesAvailable > 0
read(obj.sp, obj.sp.NumBytesAvailable, "char");
end
else
write(obj.sp,strcat(num2str(channel),'J',13),"uint8"); % clockwise rotation
pause(0.1);
while obj.sp.NumBytesAvailable > 0
read(obj.sp, obj.sp.NumBytesAvailable, "char");
end
end
obj.direction(channel) = direction;
end
% Get the rotation direction of a single channel
function getDirection = get_direction(obj,channel)
write(obj.sp,strcat(num2str(channel),'xD',13),"uint8"); % 'xD' to get the rotation direction
pause(0.1);
getDirection = read(obj.sp,obj.sp.NumBytesAvailable,"char"); % read the rotation direction from the corresponding channel
end
% Set the speed for a single channel in RPM when in RPM mode
function obj = set_speed(obj,channel,speed) % in RPM, with speed 100
disp('Speed higher than maximum (100 RPM), reduced to maximum.');
end
speed = max(min(speed,100),0); % speed between 0 and 100 rpm
speedstring = strcat(sprintf('%03d',floor(speed)), num2str(floor((speed-floor(speed))*100))); % format speed explained below
obj.speed(channel) = speed; % set the speed for the corresponding channel
write(obj.sp,strcat(num2str(channel),'S0',speedstring,13),"uint8"); % write the speed to the corresponding channel
pause(0.1);
while obj.sp.NumBytesAvailable > 0
read(obj.sp, obj.sp.NumBytesAvailable, "char");
end
end
%----------------------------------------------------------------------------------%
% SPEEDSTRING EXAMPLE %
%% Speed value : %
% speed = 123.456 %
% %
%% Convert the integer part to a string with at least three digits : %
% integer_part = sprintf('%03d', floor(speed)); %% --> Result: '123' %
% %
%% Convert the decimal part to a string with two digits : %
% decimal_part = num2str(floor((speed - floor(speed)) * 100)); %% --> Result: '45' %
% %
%% Concatenate the two parts : %
% speedstring = strcat(integer_part, decimal_part); %
%% --> Result: '12345' representing 123.45 in fixed-point notation %
% %
%% When the two strings are concatenated, the result is a string that represents %
%% the original speed value in a fixed-point notation with three digits before %
%% the decimal point and two digits after, without the decimal separator. %
%----------------------------------------------------------------------------------%
% Read out speed of a single channel in RPM when in RPM mode
function getRPM = get_speed(obj,channel)
write(obj.sp,strcat(num2str(channel),'S',13),"uint8"); % 'S' to get the setting speed in RPM
pause(0.1);
getRPM = read(obj.sp,obj.sp.NumBytesAvailable,"char");
end
% Set the operational mode for a single channel (you can add all other modes)
function obj = set_mode(obj,channel,mode)
if mode == 0
write(obj.sp,strcat(num2str(channel),'L',13),"uint8"); % RPM mode
pause(0.1);
while obj.sp.NumBytesAvailable > 0
read(obj.sp, obj.sp.NumBytesAvailable, "char");
end
elseif mode == 1
write(obj.sp,strcat(num2str(channel),'M',13),"uint8"); % Flow rate mode
pause(0.1);
while obj.sp.NumBytesAvailable > 0
read(obj.sp, obj.sp.NumBytesAvailable, "char");
end
else
write(obj.sp,strcat(num2str(channel),'G',13),"uint8"); % Volume (over time) mode
pause(0.1);
while obj.sp.NumBytesAvailable > 0
read(obj.sp, obj.sp.NumBytesAvailable, "char");
end
end
obj.mode(channel) = mode;
end
% Get the operational mode of a single channel
function getMd = get_mode(obj,channel)
write(obj.sp,strcat(num2str(channel),'xM',13),"uint8"); % 'xM' to get the operational mode
pause(0.1);
getMd = read(obj.sp,obj.sp.NumBytesAvailable,"char");
end
end
end
%-------------------------------------------------------------------%
% Examples on how to use the defined class to control the Reglo ICC %
%-------------------------------------------------------------------%
%%% To start the communication and open the serial port %%%
% pump = RegloICC('COM5') % Replace 'COM5' with your actual COM port
%%% Start channel 3 %%%
% pump.start_channel(3)
%%% Get the rotation direction of channel 3 %%%
% pump.get_direction(3)
%%% Set the rotation direction of channel 3 to clockwise %%%
% pump.set_direction(3,0)
%%% Get the current operational mode of channel 3 %%%
% pump.get_mode(3)
%%% Set the operational mode of channel 3 to RPM %%%
% pump.set_mode(3,0)
%%% Get the current speed setting of channel 3 %%%
% pump.get_speed(3)
%%% Set the setting speed of channel 3 to 24 RPM %%%
% pump.set_speed(3,24)
%%% Stop channel 3 %%%
% pump.stop_channel(3)
%%% Delete pump %%%
% pump = delete(pump)
Conclusión
En esta entrada de blog, hemos presentado la bomba peristáltica Reglo ICC (Independent Channel Control) y explorado los fundamentos 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 de Reglo ICC. Esperamos que esta publicación sirva como una guía valiosa para investigadores e ingenieros que buscan emplear la bomba peristáltica Reglo ICC en sus investigaciones y experimentos de microfluidos.
¡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 ponerse en contacto con nosotros en support@darwin-microfluidics.com.


