La serie de bombas LabV de Innofluid (anteriormente conocida como Shenchen Baoding) es una gama avanzada de bombas peristálticas de medición de caudal equipada con una pantalla táctil a color de 4.3 pulgadas para un control intuitivo. Muestra datos de caudal, parámetros de configuración e información del sistema de manera simultánea, con animaciones que indican el estado operativo. Equipada con calibración inteligente, microajuste en línea y tres modos de medición —volumen fijo, tiempo y volumen fijos, y temporizador de inicio/parada—, ofrece una gran versatilidad. Compatible con diversos cabezales de bomba y con múltiples opciones de contrôle externe, la serie LabV resulta ideal para aplicaciones de laboratorio, integración de equipos y producción industrial.
En esta entrada del blog, exploraremos cómo controlar las bombas LabV utilizando el protocolo MODBUS RTU a través de una plataforma de programación común: Python.
Cabe destacar que, aunque puedan existir ligeras diferencias en la configuración de los registros y en los comandos entre las distintas series de bombas Lab (como LabF, LabN, LabK, etc.), todas comparten el mismo protocolo de comunicación MODBUS RTU. Por lo tanto, los conocimientos aportados en este artículo son pertinentes y aplicables a los usuarios de cualquier serie de bombas Lab de Innofluid.
¿Por qué elegir una bomba peristáltica de la serie LabV?
La bomba peristáltica LabV destaca como una opción preferente para las necesidades de manipulación de fluidos tanto en entornos de laboratorio como industriales. Al incorporar un nuevo servomotor para una mayor precisión y durabilidad, junto con una interfaz táctil LCD de 4.3", esta bomba proporciona un control intuitivo para una dispensación precisa y modos de volumen fijo. Fabricada en ABS de grado de laboratorio, garantiza tanto la facilidad de uso como un rendimiento robusto.
Con caudales que van desde 0.0053 µL/min hasta 775 mL/min, y la flexibilidad de albergar hasta 8 canales, se adapta a una amplia gama de aplicaciones. Asimismo, su diseño de grado industrial, su pantalla dinámica y su funcionalidad de calibración inteligente la convierten en un recurso fiable para diversas tareas de transferencia de fluidos.
Ya sea para investigación, soporte de equipos o producción industrial, la serie de bombas peristálticas LabV se consolida como una solución óptima para los retos de manipulación de fluidos.
¿Qué se necesita para comunicarse con una bomba LabV?
Para establecer comunicación con una bomba LabV mediante el protocolo MODBUS RTU, necesitará lo siguiente:
- Una bomba LabV (en este caso se utilizará una bomba peristáltica de caudal inteligente LabV1-III) con un cabezal de bomba y un tube de su elección
- Un cable serial que se conecte a su ordenador o dispositivo
- Un cableado RS485 o RS232 conectado al puerto de contrôle externe situado en la parte posterior de la bomba
- Una plataforma de programación (Python en este caso)
- Una comprensión básica del protocolo de comunicación MODBUS RTU detallado más abajo 👇.
¿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 de comunicación RS232 o RS485 al puerto de contrôle externe ubicado en la parte posterior de la bomba
- Encienda la bomba
- En la interfaz de configuración de comunicación de la pantalla de la bomba, seleccione RS232 o RS485 como interfaz de comunicación (los detalles del cableado RS232 y RS485 se presentan en las tablas siguientes)
- Independientemente de que elija RS232 o RS485, el protocolo de comunicación es el estándar MODBUS RTU.
- Configure la velocidad de baudios (baud rate).
- Haga clic en el botón Slave No. para configurar la dirección de la bomba peristáltica (rango: 1-32).
- Seleccione la habilitación de comunicación ON.
- Regrese a la interfaz principal, ya que la bomba solo recibe el control de comunicación cuando se encuentra en ella; el control de comunicación no es válido en las demás interfaces de configuración.
| Detalles de cableado RS232 | |
|---|---|
| Terminal | Descripción |
| GND | Terminal de tierra de comunicación. |
| TXD | Terminal de envío del maestro y recepción de señal de la bomba peristáltica. |
| RXD | Terminal de envío de la bomba peristáltica y recepción de señal del maestro. |
| Detalles de cableado RS485 | |
|---|---|
| Terminal | Descripción |
| GD1 | Tierra de señal RS485. |
| A+ | Conecte a la terminal A+ de RS485. |
| B- | Conecte a la terminal B- de RS485. |
El protocolo de comunicación MODBUS RTU de la serie LabV
La serie de bombas peristálticas LabV ofrece un conjunto completo de comandos para el control y la supervisión precisos mediante el protocolo MODBUS RTU. Este conjunto abarca diversas directrices categorizadas para facilitar la manipulación de las funciones de la bomba, incluyendo ajustes de velocidad del motor, configuraciones de caudal, selección de cabezales de bomba y rutinas de calibración. Cada comando, identificado por parámetros únicos, garantiza un control preciso sobre el funcionamiento de la bomba.
A continuación se ofrecerán explicaciones detalladas e información adicional sobre el protocolo MODBUS RTU para el control de las bombas LabV, las cuales también se pueden consultar en la documentación del protocolo de comunicación.
Formato de comunicación estándar MODBUS RTU
El formato del mensaje es el descrito en la siguiente tabla.
| Campo | Tamaño | Descripción |
|---|---|---|
| Dirección del esclavo | 1 Byte | Dirección de la bomba. El rango de números es de 1 a 32 y el 0 se utiliza para difusión (broadcast). |
| Código de función | 1 Byte | Instrucción para el dispositivo esclavo. 03H: Leer registros de retención 06H: Escribir un solo registro 10H: Escribir múltiples registros 02H: Leer entradas discretas (Leer bits de datos) 05H: Escribir un solo bit en el registro |
| Área de datos | 0 – 252 Bytes | Datos a transmitir (longitud variable) |
| Comprobación CRC | 2 Bytes | Comprobación de redundancia cíclica para la detección de errores CRC bajo (1 Byte): Byte inferior del CRC CRC alto (1 Byte): Byte superior del CRC |
Comprobación CRC con CRC-16 en Python
El CRC (Comprobación de redundancia cíclica) es una técnica fundamental para detectar errores en la transmisión de datos. A continuación, mostraremos cómo implementar CRC-16, el utilizado en el sistema síncrono binario americano, utilizando Python. En CRC-16, el algoritmo de detección de errores emplea un polinomio G(X) = X16 + X15 + X2 + 1 para generar la suma de comprobación. Este polinomio define las operaciones matemáticas realizadas en los bits del mensaje durante el proceso de cálculo del CRC. A continuación se detalla una descripción general del algoritmo:
- Inicialice un registro de 16 bits con el valor hexadecimal FFFF (todos en uno), denominado registro CRC.
- Realice una operación XOR entre los primeros 8 bytes del mensaje y el byte bajo del registro CRC. Almacene el resultado nuevamente en el registro CRC.
- Desplace el registro CRC un bit hacia la derecha, con el bit más significativo (MSB) establecido en cero.
- Compruebe el bit menos significativo (LSB) del registro CRC:
- Si el LSB es 0, repita el paso 3 (operación de desplazamiento).
- Si el LSB es 1, realice una operación XOR entre el registro CRC y el valor polinómico 0xA001 (1010 0000 0000 0001).
- Repita los pasos 3 a 4, para un total de 8 desplazamientos, para procesar cada byte.
- Repita los pasos 2 a 5 para cada byte del mensaje hasta que se hayan procesado todos los bytes.
- El contenido final del registro CRC es el valor CRC.
Configuración de comunicación
Cada byte de datos presenta una estructura compuesta por 1 bit de inicio, 8 bits de datos, 1 bit de paridad y 1 bit de parada. Los bits se transmiten en orden desde el bit menos significativo (LSB) hasta el bit más significativo (MSB). Las velocidades de baudios de comunicación disponibles incluyen 1200, 2400, 4800 y 9600 bits/s.
Para los enteros (2 bytes), los datos se organizan colocando primero el segundo byte seguido del primer byte. Por ejemplo, el valor hexadecimal 2378H se transmite como 23H 78H. Para los enteros largos y los números de punto flotante (4 bytes), los datos se organizan colocando primero el cuarto byte, seguido del tercero, el segundo y el primer byte.
Formato de trama RTU del mensaje MODBUS
El formato de trama RTU del mensaje MODBUS es el descrito en la siguiente tabla.
| Campo | Tamaño | Descripción |
|---|---|---|
| Inicio | ≥ 3.5 caracteres | Indica el inicio de la transmisión |
| Dirección | 8 bits | Dirección del dispositivo esclavo |
| Código de función | 8 bits | Instrucción para el dispositivo esclavo |
| Datos | N x 8 bits | Datos que se van a transmitir (longitud variable, N bytes) |
| Código de verificación CRC | 16 bits | Comprobación de redundancia cíclica para la detección de errores |
| Fin | ≥ 3.5 caracteres | Indica el final de la transmisión |
🚨 Asegúrese de que la trama de mensajes se transmita de forma continua, sin espacios de inactividad entre caracteres superiores a 1.5 tiempos de carácter. Las tramas de mensajes incompletas, indicadas por un espacio de inactividad excesivo, deben ser descartadas por el nodo receptor.
Reacción anómala
Cuando un maestro envía una solicitud de datos y el esclavo recibe datos anómalos, este debe activar una reacción anómala. Si el código de dirección enviado por el maestro es incorrecto, es decir, no corresponde a ningún código de dirección entre los esclavos, o si los datos recibidos por el esclavo no superan la comprobación CRC, no se devuelve ningún código de anomalía. En tales casos, el maestro debe iniciar un proceso de reacción superior.
En el área del código de función, el código de función de reacción anormal se define como el código de función de reacción normal más 80H.
En el área de datos, el código anormal que se devolverá se define como en la tabla siguiente.
| Código | Nombre | Significado |
|---|---|---|
| 01H | Código de función no válido | El código de función recibido por la bomba peristáltica no está permitido, a excepción de 03H, 06H o 10H. |
| 02H | Dirección de datos no válida | La dirección de registro recibida por la bomba peristáltica no está permitida. |
| 03H | Valor de datos no válido | Los datos escritos no cumplen con el rango operativo esperado por la bomba peristáltica. |
| 06H | Esclavo (bomba peristáltica) ocupado | La bomba peristáltica se encuentra actualmente ocupada y no puede completar el comando debido a un conflicto de estado. |
🚨La bomba peristáltica solo acepta comandos MODBUS a través de la Interfaz Principal; las demás interfaces no reciben mensajes.
Dirección y contenido del registro de retención
A continuación se muestran las tablas que detallan la configuración de los parámetros básicos y de calibración, respectivamente.
Configuración de parámetros básicos
| Dirección (Decimal) | Nombre | Rango | Tipo de datos |
|---|---|---|---|
| 1000 | Cabezal de bomba | En relación con el Gráfico 1 | entero corto sin signo (2 bytes) |
| 1001 | Tamaño del tube | En relación con el Gráfico 1 | entero corto sin signo (2 bytes) |
| 1002 | Velocidad del motor | 0,1-600 rpm | coma flotante (4 bytes) |
| 1004 | Caudal | 0,1-99999 mL | coma flotante (4 bytes) |
| 1007 | Ángulo de succión inversa | 0-360° | entero corto sin signo (2 bytes) |
| 1008 | Control de inicio/parada | 1: Inicio, 0: Parada | entero corto sin signo (2 bytes) |
| 1009 | Control de dirección | 1: Sentido horario, 0: Sentido antihorario | entero corto sin signo (2 bytes) |
| 1010 | Funcionamiento a velocidad máxima | 1: Iniciar velocidad máxima, 0: Detener velocidad máxima | entero corto sin signo (2 bytes) |
| 1015 | Establecer volumen de flujo | 0-99999 mL | coma flotante (4 bytes) |
| 1018 | Tiempo de trabajo | 0,1-9999 s | coma flotante (4 bytes) |
| 1020 | Modo de trabajo | 0: Transferencia, 1: Medición de volumen fijo, 2: Tiempo y volumen fijos | entero corto sin signo (2 bytes) |
| 1021 | Tiempo de pausa | 0,1-9999 s | coma flotante (4 bytes) |
| 1023 | Número de ciclos | 0-9999 veces, 0 significa infinito | entero corto sin signo (2 bytes) |
💡 Notas importantes:
- Los registros 1015 y 1018 no son válidos cuando el modo de trabajo está configurado en transferencia.
- El registro 1018 no es válido cuando el modo de trabajo está configurado en medición de volumen fijo.
- Los registros 1002 y 1004 no son válidos cuando el modo de trabajo está configurado en tiempo y volumen fijos.
- Asegúrese de que los datos del registro estén configurados según la tabla proporcionada y evite enviar múltiples configuraciones de registro en una sola orden.
Configuración de los parámetros de calibración
| Dirección (Decimal) | Nombre | Rango | Tipo de datos |
|---|---|---|---|
| 2001 | Tiempo de prueba | 0.5-9999 s | entero corto sin signo (2 bytes) |
| 2002 | Iniciar/Detener prueba | 1: Inicio, 0: Parada | entero corto sin signo (2 bytes) |
| 2003 | Volumen real | 0-9999 mL | coma flotante (4 bytes) |
| 2005 | Restaurar valores predeterminados | 1: Restaurar calibración | entero corto sin signo (2 bytes) |
| 2006 | Microajuste | 1: Aumentar, 0: Disminuir | entero corto sin signo (2 bytes) |
Tabla de cabezales de bomba y número de tube
| Nombre del cabezal de bomba | Tipo de cabezal de bomba | Tamaño del tube | Especificación del tube |
|---|---|---|---|
| EasyPumpI | 0 | 13 | 13# |
| 14 | 14# | ||
| 19 | 19# | ||
| 16 | 16# | ||
| 25 | 25# | ||
| 17 | 17# | ||
| 18 | 18# | ||
| EasyPumpII | 1 | 15 | 15# |
| 24 | 24# | ||
| 35 | 35# | ||
| 36 | 36# | ||
| EasyPumpIII | 2 | 13 | 13# |
| 14 | 14# | ||
| 19 | 19# | ||
| 16 | 16# | ||
| 25 | 25# | ||
| 17 | 17# | ||
| 18 | 18# | ||
| EasyPumpIV | 3 | 15 | 15# |
| 24 | 24# | ||
| 35 | 35# | ||
| 36 | 36# | ||
| EasyPumpV | 4 | 13 | 13# |
| 14 | 14# | ||
| 19 | 19# | ||
| 16 | 16# | ||
| 25 | 25# | ||
| EasyPumpVI | 5 | 13 | 13# |
| 14 | 14# | ||
| 19 | 19# | ||
| 16 | 16# | ||
| 25 | 25# | ||
| 2*EasyPumpI | 6 | 13 | 13# |
| 14 | 14# | ||
| 19 | 19# | ||
| 16 | 16# | ||
| 25 | 25# | ||
| 17 | 17# | ||
| 18 | 18# | ||
| 2*EasyPumpII | 7 | 15 | 15# |
| 24 | 24# | ||
| 35 | 35# | ||
| 36 | 36# | ||
| 2*EasyPumpIII | 8 | 13 | 13# |
| 14 | 14# | ||
| 19 | 19# | ||
| 16 | 16# | ||
| 25 | 25# | ||
| 17 | 17# | ||
| 18 | 18# | ||
| YZ1515x | 12 | 13 | 13# |
| 14 | 14# | ||
| 19 | 19# | ||
| 16 | 16# | ||
| 25 | 25# | ||
| 17 | 17# | ||
| 18 | 18# | ||
| YZ2515x | 13 | 15 | 15# |
| 24 | 24# | ||
| DZ25-3L | 18 | 15 | 15# |
| 24 | 24# | ||
| 35 | 35# | ||
| 36 | 36# | ||
| UC15 | 20 | 19 | 19# |
| 16 | 16# | ||
| 25 | 25# | ||
| 17 | 17# | ||
| 18 | 18# | ||
| UC25 | 21 | 24 | 24# |
| 35 | 35# | ||
| 36 | 36# | ||
| SN15 | 22 | 14 | 14# |
| 16 | 16# | ||
| SN25 | 23 | 24 | 24# |
💡 Nota importante:
- La tabla anterior no es exhaustiva e incluye únicamente un subconjunto de cabezales de bomba y tamaños de tube. Para ver la lista completa, consulte la documentación.
Ejemplos de cadenas de comandos
Ejemplo 1: Poner en marcha la bomba
- Dirección: 01, indica la dirección del dispositivo al que se envía el comando.
- Código de función: 06, utilizado para escribir un único valor en un registro.
- Dirección de registro: 03F0, dirección de registro correspondiente al registro de control para poner en marcha la bomba (1008 en hexadecimal).
- Dato: 0001, escrito en el registro para iniciar la bomba (1: Iniciar, 0: Detener).
- CRC: 487D, valor utilizado para garantizar la integridad de los datos.
Por lo tanto, la cadena de comandos correspondiente para iniciar la bomba es: 01 06 03 F0 00 01 48 7D.
Ejemplo 2: Establecer la velocidad de la bomba en 20 rpm
- Dirección: 01, indica la dirección del dispositivo al que se envía el comando.
- Código de función: 10, utilizado para escribir valores en múltiples registros.
- Dirección de registro: 03EA, dirección de registro correspondiente al registro de ajuste de velocidad (1002 en hexadecimal).
- Número de registros: 0002, se escribirán dos registros.
- Recuento de bytes: 04, número de bytes de datos que se van a escribir.
- Dato: 41A00007, representa el ajuste de velocidad en formato de coma flotante correspondiente a 20 RPM.
- CRC: D76E, valor utilizado para garantizar la integridad de los datos.
Por lo tanto, la cadena de comandos correspondiente para establecer la velocidad de la bomba en 20 rpm es: 01 10 03 EA 00 02 04 41 A0 00 07 D7 6E.
Estos 2 ejemplos y otros ejemplos de cadenas de comandos se presentan en la siguiente tabla.
| Tarea | Cadena de comandos |
|---|---|
| Iniciar bomba | 01 06 03 F0 00 01 48 7D |
| Establecer dirección en antihorario (CCW) | 01 06 03 F1 00 00 D8 7D |
| Establecer dirección en horario (CW) | 01 06 03 F1 00 01 19 BD |
| Establecer velocidad en 20 RPM | 01 10 03 EA 00 02 04 41 A0 00 07 D7 6E |
| Establecer caudal en 50.0 mL/min | 01 10 03 EC 00 02 04 42 48 00 00 7D 2C |
| Detener bomba | 01 06 03 F0 00 00 89 BD |
| Iniciar funcionamiento a máxima velocidad | 01 06 03 F2 00 01 E9 BD |
¿Cómo controlar las bombas LabV mediante Python?
La serie de bombas LabV se puede controlar de forma remota utilizando el protocolo MODBUS RTU a través de Python, lo que ofrece una mayor flexibilidad y comodidad para ejecutar programas de bombeo complejos con bucles, pausas y diferentes velocidades o caudales. Este enfoque es especialmente útil al integrar múltiples dispositivos, ya que permite automatizar secuencias que involucran a todo el equipo conectado.
En esta sección se presentará una biblioteca de Python personalizada y específica que utiliza el protocolo MODBUS RTU, lo que permite abrir el puerto serie y enviar cadenas de comandos de control a la bomba LabV. Abordaremos ejemplos que muestran cómo configurar la velocidad, iniciar y detener la bomba, configurar el cabezal de la bomba y el tamaño del tubo, etc., proporcionando una guía práctica para utilizar Python en el control de una bomba LabV.
🚨🚨🚨 Nota importante
- When viewing this code, please be aware that <, >, and & symbols might not display correctly due to formatting issues. These should appear as standard Python code syntax, so make sure to interpret < as <, > as >, and & as &.
'''
-----------------------------------------------------------
LABV Peristaltic Pump Control Library Using Modbus Protocol
-----------------------------------------------------------
'''
import serial
import struct
#------------------------------------------------------#
# LIBRARY MANAGING THE COMMUNICATION WITH THE PUMP #
#------------------------------------------------------#
class LABV:
# Initialize the object and establish a serial connection with the corresponding data format
def __init__(self, port, address=1, baudrate=9600, parity='E', bytesize=8, stopbits=1, timeout=1):
self.ser = serial.Serial(port=port, baudrate=baudrate, parity=parity,
bytesize=bytesize, stopbits=stopbits, timeout=timeout)
self.address = address
# Connect the pump
def connect(self):
if not self.ser.is_open:
self.ser.open()
# Close the serial connection
def disconnect(self):
if self.ser.is_open:
self.ser.close()
# Calculate the CRC (Cyclic Redundancy Check) for data integrity as
# explained in "The MODBUS RTU Communication Protocol" section
def _calculate_crc(self, data):
crc = 0xFFFF
for byte in data:
crc ^= byte
for _ in range(8):
if crc & 0x0001:
crc >>= 1
crc ^= 0xA001
else:
crc >>= 1
return crc.to_bytes(2, byteorder='little')
# Convert data into bytes for communication
def _prepare_data(self, data, data_type):
if data_type == 'float':
return struct.pack('>f', data)
elif data_type == 'int':
return data.to_bytes(2, byteorder='big')
else:
raise ValueError("Data type not supported.")
# Construct, send commands to the pump and verify the response
def _send_command(self, function_code, register_address, data, data_type):
data_bytes = self._prepare_data(data, data_type)
payload = bytearray([self.address, function_code])
payload.extend(register_address.to_bytes(2, byteorder='big'))
if function_code == 0x10: # Write multiple registers
number_of_registers = len(data_bytes) // 2
payload.extend(number_of_registers.to_bytes(2, byteorder='big'))
payload.append(len(data_bytes))
payload.extend(data_bytes)
else:
payload.extend(data_bytes)
crc = self._calculate_crc(payload)
payload.extend(crc)
print(f"Sending payload: {payload.hex()}") # Debug: Print the payload
self.ser.write(payload)
response = self.ser.read(8) # Adjust as per the device response length
if len(response) != 8:
raise ValueError("Invalid response length")
if self._calculate_crc(response[:-2]) != response[-2:]:
raise ValueError("Invalid CRC")
return response
#------------------------------#
# BASIC PARAMETERS SETTING #
#------------------------------#
# Start the pump
def start_pump(self):
print("Starting pump...")
response = self._send_command(0x06, 0x03F0, 0x0001, 'int')
print(f"Start pump response: {response.hex()}")
# Stop the pump
def stop_pump(self):
print("Stopping pump...")
response = self._send_command(0x06, 0x03F0, 0x0000, 'int')
print(f"Stop pump response: {response.hex()}")
# Set the pump head
def set_pump_head(self, pump_head):
print(f"Setting pump head to {pump_head}...")
response = self._send_command(0x06, 0x03E8, pump_head, 'int')
print(f"Set pump head response: {response.hex()}")
# Set the tube size
def set_tube_size(self, tube_size):
print(f"Setting tube size to {tube_size}...")
response = self._send_command(0x06, 0x03E9, tube_size, 'int')
print(f"Set tube size response: {response.hex()}")
# Set the direction of rotation
def set_direction(self, direction):
print(f"Setting direction to {direction}...")
data = 0x0001 if direction.upper() == "CW" else 0x0000
response = self._send_command(0x06, 0x03F1, data, 'int')
print(f"Set direction response: {response.hex()}")
# Set the speed of the pump in RPM
def set_speed(self, speed):
print(f"Setting speed to {speed} RPM...")
response = self._send_command(0x10, 0x03EA, speed, 'float')
print(f"Set speed response: {response.hex()}")
# Set the flow rate in mL/min
def set_flow_rate(self, flow_rate):
print(f"Setting flow rate to {flow_rate} mL/min...")
response = self._send_command(0x10, 0x03EC, flow_rate, 'float')
print(f"Set flow rate response: {response.hex()}")
# Set the flow volume in mL
def set_flow_volume(self, volume):
print(f"Setting flow volume to {volume} mL...")
response = self._send_command(0x10, 0x03F3, volume, 'float')
print(f"Set flow volume response: {response.hex()}")
# Set the working time in seconds
def set_working_time(self, time):
print(f"Setting working time to {time} seconds...")
response = self._send_command(0x10, 0x03FA, time, 'float')
print(f"Set working time response: {response.hex()}")
# Set the working mode
def set_working_mode(self, mode):
"""
Working modes:
0: Transferring
1: Fixed volume measurement
2: Fixed time and volume
"""
if mode not in [0, 1, 2]:
raise ValueError("Invalid working mode. Must be 0, 1, or 2.")
print(f"Setting working mode to {mode}...")
response = self._send_command(0x06, 0x03FC, mode, 'int')
print(f"Set working mode response: {response.hex()}")
# Set the pause time in seconds
def set_pause_time(self, time):
print(f"Setting pause time to {time} seconds...")
response = self._send_command(0x10, 0x03FD, time, 'float')
print(f"Set pause time response: {response.hex()}")
# Set the number of copies
def set_copy_numbers(self, numbers):
print(f"Setting copy numbers to {numbers}...")
response = self._send_command(0x06, 0x03FF, numbers, 'int')
print(f"Set copy numbers response: {response.hex()}")
# Set the back suction angle in degrees
def set_back_suction_angle(self, angle):
print(f"Setting back suction angle to {angle} degrees...")
response = self._send_command(0x06, 0x03EF, angle, 'int')
print(f"Set back suction angle response: {response.hex()}")
# Start or stop full speed running
def set_full_speed_running(self, start):
state = "Start" if start else "Stop"
print(f"{state} full speed running...")
data = 0x0001 if start else 0x0000
response = self._send_command(0x06, 0x03F2, data, 'int')
print(f"{state} full speed running response: {response.hex()}")
#---------------------------------------#
# CALIBRATION PARAMETERS SETTING UP #
#---------------------------------------#
# Set the testing time in seconds
def set_testing_time(self, time):
print(f"Setting testing time to {time} seconds...")
response = self._send_command(0x06, 0x07D1, time, 'int')
print(f"Set testing time response: {response.hex()}")
# Start the calibration test
def start_test(self):
print("Starting test...")
response = self._send_command(0x06, 0x07D2, 0x0001, 'int')
print(f"Start test response: {response.hex()}")
# Stop the calibration test
def stop_test(self):
print("Stopping test...")
response = self._send_command(0x06, 0x07D2, 0x0000, 'int')
print(f"Stop test response: {response.hex()}")
# Set the actual volume in mL
def set_actual_volume(self, volume):
print(f"Setting actual volume to {volume} mL...")
response = self._send_command(0x10, 0x07D3, volume, 'float')
print(f"Set actual volume response: {response.hex()}")
# Restore calibration defaults
def restore_defaults(self):
print("Restoring defaults...")
response = self._send_command(0x06, 0x07D5, 0x0001, 'int')
print(f"Restore defaults response: {response.hex()}")
# Perform micro adjustment (increase or decrease)
def micro_adjustment(self, increase=True):
action = "Increase" if increase else "Decrease"
print(f"{action} micro adjustment...")
data = 0x0001 if increase else 0x0000
response = self._send_command(0x06, 0x07D6, data, 'int')
print(f"{action} micro adjustment response: {response.hex()}")
#-----------------------------------------------------------------------#
# EXAMPLES ON HOW TO USE THE DEFINED CLASS TO CONTROL THE LABV PUMP #
#-----------------------------------------------------------------------#
if __name__ == "__main__":
pump = LABV(port='COM6', address=1) # Change port and address according to your setup
pump.connect()
try:
pump.set_pump_head(5)
pump.set_tube_size(16)
pump.set_direction("CW")
pump.set_speed(50)
pump.set_flow_rate(50.0)
pump.set_back_suction_angle(0)
pump.set_full_speed_running(True)
pump.start_pump()
except Exception as e:
print(f"An error occurred: {e}")
finally:
pump.stop_pump()
pump.disconnect()
Esta biblioteca de Python para controlar la serie de bombas LabV mediante el protocolo MODBUS RTU permite un control preciso y automatizado de varios parámetros de la bomba, como la velocidad, la dirección, el cabezal de la bomba y el tamaño del tubo. Los usuarios de una bomba LabV ahora pueden integrar fácilmente su bomba en flujos de trabajo complejos que involucren múltiples dispositivos, mejorando la eficiencia operativa y la flexibilidad.
Conclusión
En esta publicación del blog, hemos presentado la serie de bombas peristálticas LabV y explorado los fundamentos de su contrôle externe en Python utilizando el protocolo de comunicación MODBUS RTU. Esperamos que esta publicación sirva como una guía valiosa para investigadores e ingenieros que busquen emplear una bomba peristáltica LabV en sus investigaciones y experimentos de microfluídica.
🚨 Aunque existen variaciones entre las diferentes series de bombas Innofluid Lab, destacamos que el protocolo de comunicación permanece casi inalterado. Ya sea que utilice la serie LabF, la serie LabN o cualquier otra, confiamos en que este contenido también le será útil para sus futuros proyectos.
¡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.


