La bomba peristálticaReglo ICC (Independent Channel Control) de Masterflex Ismatec es un instrumento de alta precisión diseñado para ofrecer un control y una precisión sin igual en la dosificación y el trasvase 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 específicos para el arranque, la parada, la calibración y mucho más.
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 c RS-232 a permiten crear secuencias de bombeo complejas y controlar varias bombas simultáneamente.
En esta entrada del blog, veremos 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, y destaca como una de las mejores opciones para las necesidades de manejo de fluidos tanto en laboratorios como en entornos industriales. Estas son algunas de sus principales ventajas:
- Control independientede hasta cuatro canales, cada uno con su propio programa, caudales y direcciones de forma simultánea.
- Alta precisión y reproducibilidad, lo que garantiza una dosificación precisa y uniforme de los fluidos al reducir al mínimo las diferencias entre tubos.
- Rango de pulsación y caudal ajustable mediante 6, 8 o 12 rodillos, que se utilizan para ajustar el rango de pulsación y caudal (cuantos más rodillos, menor es la pulsación y menor el caudal).
- Opciones de control versátilesa través de su interfaz digital o de una conexi RS-232 e (hasta ocho bombas en cadena).
- Modos de funcionamiento completos, entre los que se incluyen la dosificación continua a un caudal fijo, la dosificación de un volumen durante un periodo determinado, la calibración de cada canal y mucho más.
¿Qué se necesita para comunicarse con la bomba Reglo ICC?
Para comunicarte con la bomba peristáltica Reglo ICC, necesitarás algunos componentes clave:
- Una bomba Reglo ICC con un cabezal de bombeo y una 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 en serie y la transferencia de datos entre la bomba de jeringa y el ordenador,
- Una plataforma de programación (Python y Matlab, en el caso que nos ocupa) o un emulador de terminal,
- Una explicación básica del protocolo de comandos en serie ICC de Reglo, que se describe a continuación 👇 y se detalla en el manual de usuario de la bomba.
¿Cómo se configura el puerto de comunicación?
Antes de poder empezar a enviar y recibir datos de la bomba, debes configurar correctamente el puerto de comunicación. Estos son los pasos que debes seguir:
- Conecta el cable mini-USB/USB o el conector DB9 al puerto serie situado en la parte trasera de la bomba y al puerto correspondiente del ordenador.
- Enciende la bomba.
- Identifica el nombre del puerto serie asignado a la conexión en tu ordenador (por ejemplo, COM4 en Windows o /dev/ttyUSB0 en Linux). Normalmente, puedes encontrar esta información en el Administrador de dispositivos o mediante comandos de terminal.
- Asegúrate de que la configuración del puerto serie se ajuste a las especificaciones de tu bomba de jeringa:
- 1 bit de inicio,
- 8 bits de datos,
- Paridad: ninguna,
- 1 bit de parada,
- una velocidad de transmisión de 9.600 bits/s.
- El modo remoto que aparece 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 de comandos en serie ICC de Reglo
El protocolo de comandos Reglo ICC ofrece una amplia gama de comandos para contrôle externe, clasificados en distintos tipos para permitir una manipulación precisa. Entre ellos se incluyen la gestión de la comunicación, los modos de funcionamiento y los ajustes, las directivas de control, las configuraciones de los ajustes, la calibración y mucho más.
Hay dos tipos de mensajes: los mensajes de respuesta, que se envían desde la bomba al ordenador, y los mensajes de solicitud, que se envían desde el ordenador a la bomba. Todos los mensajes están compuestos por una cadena de caracteres ASCII imprimibles. Cada mensaje termina con un retorno de carro o con un retorno de carro y un salto de línea.
A continuación se resume el protocolo de comandos Reglo ICC utilizado para controlar la bomba peristáltica Reglo ICC. Para obtener más información, consulte el manual de usuario de la bomba.
Formatos de los tipos de datos
| Tipo de datos | Ancho | Unidad | Gama | Formato |
|---|---|---|---|---|
| Dirección | 1 | - | - | J = en el sentido de las agujas del reloj K = en sentido contrario a las agujas del reloj |
| Tipo discreto 1 | Del 1 al 4 | - | De 0 a 9999 | De 1 a 4 caracteres en base 10. Los dígitos no utilizados no se devuelven. |
| Tipo discreto 2 | 4 | - | De 0 a 9999 | 4 caracteres en base 10. Valor alineado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo discreto 3 | 6 | - | De 0 a 999 999 | 6 caracteres en base 10. Valor alineado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo discreto 4 | 10 | - | De 0 a 4294967295 | 10 caracteres en base 10. Valor alineado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo discreto 5 | 3 | - | De 0 a 999 | 3 caracteres en base 10. Valor alineado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo discreto 6 | 5 | - | De 0 a 99 999 | 5 caracteres en base 10. Valor alineado a la derecha. Los dígitos no utilizados a la izquierda son ceros. |
| Tipo 1 fraccional | Variable | - | - | XXXX.DD Ancho variable de la parte entera (XXXX). Siempre se incluyen el punto decimal y dos dígitos a la derecha (.DD). |
| Tipo de volumen 1 | 7 | mL | - | mmmmEse ⇒ m.mmm × 10^se: mmmm — mantisa de 4 caracteres El punto decimal se deduce tras el primer carácter. E — carácter «E» s — signo del exponente: + o - e — exponente de un solo dígito |
| Tipo de hora 1 | Del 1 al 8 | 0.1s | De 0 a 35 964 000 (de 0 a 999 horas) | De 1 a 8 caracteres que representan la hora. Los dígitos no utilizados no se devuelven. |
| Tipo de hora 2 | 8 | 0.1s | De 0 a 35 964 000 (de 0 a 999 horas) | 8 caracteres que representan la hora. Valor alineado 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 ordenador en respuesta a un mensaje de solicitud enviado por el ordenador. 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 correctamente o no. En la tabla siguiente se muestran los distintos caracteres ASCII que indican el estado de ejecución del comando solicitado.
| Carácter ASCII | Definición | En Hex | En base 10 |
|---|---|---|---|
| * | El comando se ha ejecutado correctamente | 0x2a | 42 |
| # | El comando no se ha ejecutado correctamente | 0x23 | 35 |
| + | respuesta afirmativa que se utiliza para algunos comandos | 0x2b | 43 |
| - | respuesta negativa utilizada para algunos comandos | 0x2d | 45 |
La bomba envía una respuesta de datos cuando el ordenador solicita los valores de los parámetros. Dicha respuesta está compuesta por uno o varios valores de parámetros de datos delimitados por espacios. Cada parámetro de datos del mensaje de respuesta es un valor de datos 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 mensajes enviados desde el ordenador a la bomba. La bomba debe responder a ellos con un mensaje de respuesta.
Un comando de control del dispositivo (como se muestra a continuación) está compuesto por una cadena de caracteres ASCII imprimibles y termina con un retorno de carro [CR] o con un retorno de carro [CR] y un salto de línea [LF]. Se dirige a una bomba o canal concreto para obtener o establecer determinados parámetros.
| 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», la dirección va del 1 al 8 (número máximo de bombas controladas a la vez). En el caso de que solo se controle una bomba, la dirección va del 1 al 4, en función del número de canales que se controlen de forma independiente, tal y como se muestra en el comando de control anterior.
La cadena de comando suele constar de uno o dos caracteres que indican el tipo de comando. Los parámetros de datos son valores opcionales que pueden proporcionarse al establecer el valor de un parámetro. Por último, el carácter de barra vertical delimita los parámetros de datos.
Se pueden enviar a la bomba diferentes comandos relacionados con la gestión de las comunicaciones, el e drive o de la bomba, los modos de funcionamiento y los ajustes, la calibración y mucho más. En la tabla siguiente se enumeran algunos de estos comandos de dirección directa. En el manual de instrucciones se pueden consultar y consultar con más detalle otros comandos.
| Comando | Función | Establecer/Obtener | Respuesta de la bomba |
|---|---|---|---|
| H | Poner en marcha la bomba | Conjunto | * - : la configuración del canal no es correcta |
| I | Detener la bomba | Conjunto | * |
| xI | Pausar el bombeo (STOP en el modo de revoluciones por minuto o de caudal) | Conjunto | * |
| J | Establecer la dirección de rotación en sentido horario | Conjunto | * |
| K | Establecer la dirección de rotación en sentido antihorario | Conjunto | * |
| xD | Obtener la dirección de rotación | Consigue | J: en el sentido de las agujas del reloj K: en sentido contrario a las agujas del reloj |
| xM | Obtener el modo de corriente de la bomba/canal | Consigue | L: RPM M: Caudal O: Volumen a un caudal determinado G: Volumen en función del tiempo Q: Volumen + Pausa N: Tiempo P: Tiempo + Pausa |
| L | Configurar la bomba/el canal en modo RPM | Conjunto | * |
| M | Configurar la bomba/el canal en el modo «Caudal» | Conjunto | * |
| O | Configurar la bomba/el canal en el modo «Volumen a velocidad» | Conjunto | * |
| G | Configurar la bomba/el canal en el modo «Volumen en función del tiempo» | Conjunto | * - : la configuración del canal no es correcta |
| S | Ajuste del caudal en modo RPM (0,01 RPM). Tipo discreto 3. | Conjunto | * |
| S | Obtener el valor actual de la velocidad en RPM | Consigue | Tipo 1 fraccional |
| f | Ajusta el caudal en RPM en modo volumen/tiempo (mL/min). Tipo de volumen 2 (similar al tipo 1, pero sin el carácter «E»). | Conjunto | Tipo de volumen 1 |
| f | Obtener el caudal volumétrico actual (mL/min) | Consigue | Tipo de volumen 1 |
| xP | Tiempo de pausa de bombeo | Consigue | Tipo de hora 1 |
| xY | Iniciar la calibración en un canal | Conjunto | * |
| xZ | Cancelar la calibración | Conjunto | * |
En los mensajes de solicitud definidos se utilizan distintos símbolos para representar los caracteres ASCII. Algunos de ellos se muestran en la tabla siguiente.
| Símbolo | Definición | En Hex | 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 |
| @ | El carácter «@» | 0x40 | 64 |
Ejemplos de comandos
Para comunicarse con la bomba, es necesario conocer los distintos comandos que admite y preparar las cadenas de comandos necesarias para el ordenador de control.
En la tabla siguiente se presentan y explican algunos ejemplos de comandos dirigidos directamente.
| Comando | Definición | Respuesta de la bomba | Definición |
|---|---|---|---|
| 1H[CR] | Iniciar el canal 1 | * | El comando se ha ejecutado correctamente |
| 4I[CR] | Deja de ver el canal 4 | * | El comando se ha ejecutado correctamente |
| 2xD[CR] | Averigua la dirección del canal 2 | K[CR][LF] | El sentido de giro es en sentido antihorario. |
| 3J[CR] | Establece el sentido de giro del canal 3 en sentido horario | * | El comando se ha ejecutado correctamente |
| 1xM[CR] | Obtener el modo de funcionamiento del canal 1 | L[CR][LF] | El modo actual es RPM |
| 3G[CR] | Configura el modo de funcionamiento del canal 3 en «volumen en función del tiempo» | * | El comando se ha ejecutado correctamente |
| 1S[CR] | Consulta la velocidad del canal 1 en drive | 22,50[CR][LF] | Respuesta de tipo «fraccional tipo 1». La velocidad del motor « drive » es de 22,5 RPM. |
| 1S004500[CR] | Ajusta la velocidad de la drive a del canal 1 a 45 RPM. El ajuste de velocidad tiene una resolución de 0,01 RPM (45 se asigna como 4500) en formato de «tipo discreto 3», con una anchura de 6 caracteres, en el que los dígitos no utilizados a la izquierda se sustituyen por ceros (=> 004500). | * | El comando se ha ejecutado correctamente |
| 3f[CR] | Obtén la frecuencia de bombeo del canal 3 | 1275E+1[CR][LF] | Respuesta en forma de «tipo de volumen 1» (mmmmEse => m.mmmx10se):
|
| 3f1500-3[CR] | Ajusta la velocidad de bombeo del canal 3 a 1,5 μL/min. El ajuste de la velocidad de bombeo se realiza mediante el «tipo de volumen 2» (mmmmse => m.mmmx10se). 1,5 µL/min = 1,500 × 10-3 ml/min, por lo tanto:
| 1500E-3[CR][LF] | Respuesta del tipo «volumen tipo 1». |
¿Cómo se controla la bomba ICC de Reglo con IsmaTerm?
IsmaTerm es un programa que permite controlar la bomba Reglo ICC. Se trata de un programa de emulación de terminal que se comunica con la bomba a través de un puerto seri RS-232 . IsmaTerm se puede utilizar para poner en marcha y detener la bomba, configurar y consultar sus parámetros, así como para programar su funcionamiento. Es compatible con los sistemas operativos Windows y se puede descargar a través de este enlace.
Para comunicarte con la bomba, inicia el software IsmaTerm, selecciona el puerto COM correspondiente a la bomba e introduce los parámetros del puerto para modificar sus características (tal y como se muestra en la siguiente figura). La velocidad de transmisión 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 ver 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 que se muestra a continuación presenta algunos mensajes enviados a la bomba y recibidos de ella, lo que permite poner en marcha o detener la bomba, así como configurar u obtener sus parámetros. En este ejemplo, solo se controla el canal 3. Cada comando enviado a la bomba recibe una respuesta de la misma (mensajes correspondientes en la figura siguiente).
Los comandos que acabamos de ver en la ventana de IsmaTerm se explican brevemente en la tabla siguiente.
| Comando | Definición | Respuesta de la bomba | Definición |
|---|---|---|---|
| 3H | Iniciar el canal 3 | * | El comando se ha ejecutado correctamente |
| 3xD | Consulta cómo llegar | K{13}{10} | El sentido de rotación es en sentido antihorario {13} — retorno de carro [CR] {10} — salto de línea [LF] |
| 3J | Establece la dirección de rotación del canal en sentido horario | * | El comando se ha ejecutado correctamente |
| 3xM | Obtener el modo de funcionamiento del canal 3 | L{13}{10} | El modo actual es RPM |
| 3S | Obtén la velocidad de ajuste en RPM | 10,00{13}{10} | Tipo fraccional 1. Velocidad de rotación de 10 RPM. |
| 3S002400 | Ajusta la velocidad a 24 RPM | * | El comando se ha ejecutado correctamente |
| 3I | Deja de ver el canal 3 | * | El comando se ha ejecutado correctamente |
En ocasiones, la orden de control que se transmite a la bomba se obtiene tras realizar algunos cálculos y conversiones. Por lo tanto, es importante preparar todas las órdenes necesarias antes de iniciar el « contrôle externe » de la bomba.
Además, resulta más sencillo escribir estos comandos de control y transmitirlos a la bomba mediante un conjunto de códigos (ya preparados), utilizando plataformas de programación como Python y Matlab, que escribir y enviar un comando de vez en cuando a la bomba a través de un programa de terminal. Estas plataformas no solo facilitan la comunicación con la bomba, sino que también simplifican la comunicación externa con un grupo de bombas y permiten escribir un programa de bombeo con bucles, pausas, etc.
A continuación se proporcionan y explican fragmentos de código de inicio rápido para la comunicación en serie mediante Python y MATLAB, que 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 ICC de Reglo con Python?
La bomba Reglo ICC se puede controlar de forma remota mediante Python, lo que ofrece una mayor flexibilidad y comodidad a la hora de ejecutar programas de bombeo complejos con bucles, pausas y velocidades o caudales variables. Este enfoque resulta especialmente útil a la hora de integrar varios dispositivos, ya que permite automatizar secuencias en las que intervienen todos los equipos conectados.
En esta sección, mostraremos en primer lugar cómo abrir el puerto serie y enviar comandos sencillos a la bomba utilizando Python. A continuación, se presentará una biblioteca de Python personalizada y específica que utiliza el protocolo de comandos de la Reglo ICC, lo que permite abrir el puerto serie y enviar cadenas de comandos de control a la bomba Reglo ICC. Veremos ejemplos que muestran cómo poner en marcha y detener la bomba, ajustar la velocidad, configurar el caudal, etc., lo que constituirá una guía práctica para utilizar 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 biblioteca personalizada de Python que utiliza el protocolo de comandos Reglo ICC. Esta biblioteca permite crear programas de bombeo complejos, que incluyen funciones como pausas, bucles, lógica condicional y otras, lo que facilita el control de un conjunto 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 se controla la bomba ICC de Reglo con 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 de adaptador de inicio rápido diseñada específicamente para gestionar los comandos Reglo ICC.
Repasaremos fragmentos de código que muestran cómo realizar tareas habituales, como poner en marcha o detener la bomba, ajustar la velocidad, obtener el sentido de giro, 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 del blog, hemos presentado la bomba peristáltica Reglo ICC (Independent Channel Control) y hemos analizado los aspectos básicos de su programación ( contrôle externe ) a través de dos plataformas de programación, Python y Matlab, utilizando el conjunto de comandos de comunicación de la Reglo ICC. Esperamos que esta entrada sirva de guía útil para los investigadores e ingenieros que deseen utilizar la bomba peristáltica Reglo ICC en sus investigaciones y experimentos sobre microfluídica.
No te pierdas más análisis, tutoriales y aplicaciones prácticas en nuestras próximas publicaciones. Hasta entonces, ¡feliz bombeo y programación 💻!
📧 Si tienes alguna pregunta o comentario, no dudes en ponerte en contacto con nosotros en support@darwin-microfluidics.com.


