Con una portata di esercizio compresa tra 0,001 e 35 mL/min per canale e livelli di pulsazione personalizzabili, questa pompa offre la flessibilità necessaria per una vasta gamma di applicazioni. L'intuitiva interfaccia digitale e la connettività per computer RS-232 consentono di creare sequenze di pompaggio complesse e di controllare più pompe contemporaneamente.
In questo articolo del blog, analizzeremo come controllare la pompa peristaltica Reglo ICC utilizzando il protocollo di comando seriale Reglo ICC tramite due piattaforme di programmazione: Python e Matlab.
SOMMARIO
Perché scegliere la pompa peristaltica Reglo ICC?
La pompa peristaltica Reglo ICC è versatile e intuitiva, e si distingue come la scelta ideale per la gestione dei fluidi sia in laboratorio che in ambienti industriali. Di seguito sono elencati alcuni dei principali vantaggi:
- Controllo indipendente dei canali fino a un massimo di quattro canali, ciascuno con il proprio programma, portate e direzioni simultanee.
- Elevata precisione e riproducibilità per garantire un'erogazione dei fluidi precisa e costante, riducendo al minimo le differenze tra i tube.
- Pulsazione e intervallo di portata regolabili con 6, 8 o 12 rulli utilizzati per regolare la pulsazione e l'intervallo di portata (un numero maggiore di rulli comporta una minore pulsatilità e portate inferiori).
- Opzioni di controllo versatili tramite l'interfaccia digitale o la connessione RS-232 (fino a otto pompe collegate in modalità daisy-chain).
- Modalità operative complete tra cui erogazione continua a una velocità impostata, erogazione di un volume in un periodo specificato, calibrazione di ciascun canale e altro ancora.
Di cosa hai bisogno per comunicare con la pompa Reglo ICC?
Per comunicare con la pompa peristaltica Reglo ICC sono necessari alcuni componenti chiave:
- Una pompa Reglo ICC con una testa della pompa e dei tube a tua scelta,
- Un cavo mini-USB/usb o un connettore DB9 (collegato a un modulo di contrôle externe) che consenta la comunicazione seriale e il trasferimento dei dati tra la pompa a siringa e il computer,
- Una piattaforma di programmazione (Python e Matlab nel caso in questione) o un emulatore di terminale,
- Una comprensione di base del protocollo seriale dei comandi Reglo ICC spiegato qui sotto 👇 e dettagliato nella guida per l'utente della pompa.
Come configurare la porta di comunicazione?
Prima di poter iniziare a inviare e ricevere dati dalla pompa, è necessario configurare correttamente la porta di comunicazione. Ecco i passaggi da seguire:
- Collegare il cavo mini-usb/usb o il connettore DB9 alla porta seriale sul retro della pompa e alla porta corrispondente sul computer.
- Accendere la pompa.
- Identifica il nome della porta seriale assegnata alla connessione sul tuo computer (ad esempio, COM4 per Windows o /dev/ttyUSB0 per Linux). In genere è possibile trovare queste informazioni in Gestione dispositivi o utilizzando i comandi del terminale.
- Assicurarsi che le impostazioni della porta seriale corrispondano alle specifiche della siringa pompa:
- 1 bit di avvio,
- 8 bit di dati,
- Parità: nessuna,
- 1 bit di stop,
- una velocità di trasmissione (baud rate) di 9600 bit/s.
- La modalità remota sullo schermo della pompa conferma la riuscita della connessione, indicando che la pompa è controllata a distanza da un computer tramite una connessione USB 2.0, Mini-B o RS-232.
Il protocollo di comando seriale Reglo ICC
Il protocollo di comando Reglo ICC offre una serie di comandi per il contrôle externe, suddivisi in categorie distinte per una manipolazione precisa. Questi includono la gestione della comunicazione, le modalità e le impostazioni operative, le direttive di controllo, la configurazione delle impostazioni, la calibrazione e altro ancora.
Esistono due tipi di messaggi: i messaggi di risposta inviati dalla pompa al PC e i messaggi di richiesta inviati dal PC alla pompa. Tutti i messaggi sono costituiti da una stringa di caratteri ASCII stampabili. Ciascun messaggio termina con un ritorno a capo o con un ritorno a capo e un avanzamento riga.
Il protocollo di comando Reglo ICC utilizzato per controllare la pompa peristaltica Reglo ICC è riassunto di seguito. Ulteriori dettagli sono disponibili nel manuale utente della pompa.
Formati dei tipi di dati
| Tipo di dato | Larghezza | Unità | Intervallo | Formato |
|---|---|---|---|---|
| Direzione | 1 | - | - | J = in senso orario K = in senso antiorario |
| Tipo discreto 1 | Da 1 a 4 | - | Da 0 a 9999 | Da 1 a 4 caratteri in base 10. Le cifre non utilizzate non vengono restituite. |
| Tipo discreto 2 | 4 | - | Da 0 a 9999 | 4 caratteri in base 10. Valore allineato a destra. Le cifre non utilizzate a sinistra sono zeri. |
| Tipo discreto 3 | 6 | - | Da 0 a 999999 | 6 caratteri in base 10. Valore allineato a destra. Le cifre non utilizzate a sinistra sono zeri. |
| Tipo discreto 4 | 10 | - | Da 0 a 4294967295 | 10 caratteri in base 10. Valore allineato a destra. Le cifre non utilizzate a sinistra sono zeri. |
| Tipo discreto 5 | 3 | - | Da 0 a 999 | 3 caratteri in base 10. Valore allineato a destra. Le cifre non utilizzate a sinistra sono zeri. |
| Tipo discreto 6 | 5 | - | Da 0 a 99999 | 5 caratteri in base 10. Valore allineato a destra. Le cifre non utilizzate a sinistra sono zeri. |
| Tipo frazionario 1 | Variabile | - | - | XXXX.DD Larghezza variabile della parte intera (XXXX). Viene sempre fornito il punto decimale seguito da due cifre (.DD). |
| Tipo di volume 1 | 7 | mL | - | mmmmEse ⇒ m.mmm × 10^se: mmmm — mantissa a 4 caratteri Punto decimale implicito dopo il primo carattere. E — carattere 'E' s — segno per l'esponente: + o - e — esponente a una sola cifra |
| Tipo di tempo 1 | Da 1 a 8 | 0.1s | Da 0 a 35964000 (da 0 a 999 ore) | Da 1 a 8 caratteri che rappresentano il tempo. Le cifre non utilizzate non vengono restituite. |
| Tipo di tempo 2 | 8 | 0.1s | Da 0 a 35964000 (da 0 a 999 ore) | 8 caratteri che rappresentano il tempo. Valore allineato a destra. Le cifre non utilizzate a sinistra sono zeri. |
Messaggi di risposta
Un messaggio di risposta è un messaggio inviato dalla pompa al PC in risposta a un messaggio di richiesta inviato dal PC. Può essere sotto forma di risposta di stato o di dati.
Un messaggio di risposta di stato è un singolo carattere ASCII che indica se il comando è stato eseguito con successo o meno. I diversi caratteri ASCII che indicano lo stato di esecuzione del comando richiesto sono rappresentati nella tabella sottostante.
| Carattere ASCII | Definizione | In esadecimale | In base 10 |
|---|---|---|---|
| * | comando eseguito con successo | 0x2a | 42 |
| # | comando non eseguito con successo | 0x23 | 35 |
| + | risposta positiva utilizzata per alcuni comandi | 0x2b | 43 |
| - | risposta negativa utilizzata per alcuni comandi | 0x2d | 45 |
Una data response viene ricevuta dalla pompa quando il PC richiede i valori dei parametri. È composta da uno o più valori di parametri di dati delimitati da spazi. Ciascun parametro di dati nel messaggio di risposta è un valore restituito dalla pompa in un formato definito dal messaggio di richiesta.
| Parametro di dati 1 | [SP] | Parametro di dati 2 | [SP] | … | Parametro di dati n | [CR] | [LF] |
Messaggi di richiesta
I messaggi di richiesta sono inviati dal PC alla pompa. A questi dovrebbe corrispondere un messaggio di risposta da parte della pompa.
Un comando di controllo del dispositivo (come mostrato di seguito) è composto da una stringa di caratteri ASCII stampabili e terminato con un ritorno a capo [CR] o un ritorno a capo [CR] e un'avanzamento riga [LF]. Viene indirizzato a una singola pompa o canale per ottenere o impostare determinati parametri.
| Indirizzo (1-4) | Codice comando | Parametro di dati 1 | [VB] | Parametro di dati 2 | [VB] | … | Parametro di dati n | [CR] | [LF] |
Nel caso di un bus di pompe collegate in "daisy-chain", l'indirizzo va da 1 a 8 (numero massimo di pompe controllate contemporaneamente). Nel caso in cui venga controllata una sola pompa, l'indirizzo va da 1 a 4 corrispondente al numero di canali controllati indipendentemente, come illustrato nel comando di controllo precedente.
La stringa di comando è tipicamente costituita da uno o due caratteri che indicano il tipo di comando. I parametri di dati sono valori opzionali che possono essere forniti durante l'impostazione di un parametro. Infine, il carattere della barra verticale delimita i parametri di dati.
Alla pompa possono essere inviati diversi comandi relativi alla gestione delle comunicazioni, al pump drive, alle modalità operative e alle impostazioni, alla calibrazione e altro ancora. Alcuni di questi comandi con indirizzamento diretto sono elencati nella tabella sottostante. Ulteriori comandi sono reperibili e descritti in dettaglio nel manuale operativo.
| Comando | Funzione | Imposta/Ottieni | Risposta della pompa |
|---|---|---|---|
| H | Avvia pompa | Imposta | * - : impostazione del canale non corretta |
| I | Arresta la pompa | Imposta | * |
| xI | Interrompi il pompaggio (STOP in modalità RPM o portata) | Imposta | * |
| J | Imposta la direzione di rotazione in senso orario | Imposta | * |
| K | Imposta la direzione di rotazione in senso antiorario | Imposta | * |
| xD | Ottieni la direzione di rotazione | Ottieni | J : orario K : antiorario |
| xM | Ottieni la modalità corrente della pompa/canale | Ottieni | L : RPM M : Portata O : Volume a portata specifica G : Volume nel tempo Q : Volume+Pausa N : Tempo P : Tempo+Pausa |
| L | Imposta la pompa/canale in modalità RPM | Imposta | * |
| M | Imposta la pompa/canale in modalità Portata | Imposta | * |
| O | Imposta la pompa/canale in modalità Volume a portata specifica | Imposta | * |
| G | Imposta la pompa/canale in modalità Volume nel tempo | Imposta | * - : impostazione del canale non corretta |
| S | Impostazione della portata in modalità RPM (0,01 RPM). Tipo discreto 3. | Imposta | * |
| S | Ottieni l'impostazione della velocità corrente in RPM | Ottieni | Tipo frazionario 1 |
| f | Imposta la portata RPM in modalità volume/tempo (mL/min). Tipo di volume 2 (Simile al tipo 1 senza il carattere 'E'). | Imposta | Tipo di volume 1 |
| f | Ottieni la portata volume/tempo corrente (mL/min) | Ottieni | Tipo di volume 1 |
| xP | Ottieni il tempo di pausa del pompaggio | Ottieni | Tipo di tempo 1 |
| xY | Avvia la calibrazione su un canale | Imposta | * |
| xZ | Annulla la calibrazione | Imposta | * |
Nei messaggi di richiesta definiti vengono impiegati diversi simboli per rappresentare i caratteri ASCII. Alcuni di essi sono illustrati nella tabella sottostante.
| Simbolo | Definizione | In esadecimale | In base 10 |
|---|---|---|---|
| [CR] | ritorno a capo | 0x0d | 13 |
| [LF] | avanzamento riga | 0x0a | 10 |
| [SP] | spazio | 0x20 | 32 |
| [VB] | barra verticale | 0x7c | 124 |
| @ | carattere '@' | 0x40 | 64 |
Esempi di comandi
Per comunicare con la pompa, è necessario comprendere i diversi comandi supportati e preparare le stringhe di comando di controllo del computer richieste.
Nella tabella sottostante vengono presentati e spiegati alcuni esempi di comandi con indirizzamento diretto.
| Comando | Definizione | Risposta della pompa | Definizione |
|---|---|---|---|
| 1H[CR] | Avvia il canale 1 | * | Comando eseguito con successo |
| 4I[CR] | Arresta il canale 4 | * | Comando eseguito con successo |
| 2xD[CR] | Ottieni la direzione del canale 2 | K[CR][LF] | La direzione di rotazione è antioraria |
| 3J[CR] | Imposta la direzione di rotazione del canale 3 in senso orario | * | Comando eseguito con successo |
| 1xM[CR] | Ottieni la modalità operativa del canale 1 | L[CR][LF] | La modalità corrente è RPM |
| 3G[CR] | Imposta la modalità operativa del canale 3 su volume nel tempo | * | Comando eseguito con successo |
| 1S[CR] | Ottieni la drive speed del canale 1 | 22.50[CR][LF] | Risposta in formato "fractional type 1". La drive speed è 22,5 RPM |
| 1S004500[CR] | Imposta la drive speed del canale 1 a 45 RPM. L'impostazione della velocità ha una risoluzione di 0,01 RPM (45 assegnato come 4500) sotto forma di "discrete type 3" con una larghezza di 6 caratteri e le cifre inutilizzate a sinistra riempite con zeri (=> 004500). | * | Comando eseguito con successo |
| 3f[CR] | Ottieni la portata di pompaggio del canale 3 | 1275E+1[CR][LF] | Risposta in formato "volume type 1" (mmmmEse => m.mmm x10se):
|
| 3f1500-3[CR] | Imposta la portata di pompaggio del canale 3 a 1,5 µL/min. Impostazione della portata di pompaggio in formato "volume type 2" (mmmmse => m.mmm x10se). 1,5 µL/min = 1,500x10-3 mL/min, pertanto:
| 1500E-3[CR][LF] | Risposta nel formato "volume type 1". |
Come controllare la pompa Reglo ICC tramite IsmaTerm?
IsmaTerm è un software che consente di controllare la pompa Reglo ICC. Si tratta di un software di emulazione di terminale che comunica con la pompa tramite la porta seriale rs-232. IsmaTerm può essere utilizzato per avviare e arrestare la pompa, impostare e recuperare i parametri della pompa e programmarne il funzionamento. È compatibile con i sistemi operativi Windows e può essere scaricato tramite questo link.
Per comunicare con la pompa, avviare il software IsmaTerm, selezionare la porta COM corrispondente alla pompa e inserire le impostazioni della porta per modificarne le caratteristiche (come illustrato nella figura sottostante). La velocità di trasmissione predefinita è 9600 baud/s, con 8 bit di dati, 1 bit di stop e nessuna parità.
Nella finestra di IsmaTerm, è possibile digitare i comandi per controllare la pompa e visualizzare le relative risposte. Tali comandi fanno distinzione tra maiuscole e minuscole (case sensitive) e devono essere seguiti da un ritorno a capo (tasto Invio).
La finestra di IsmaTerm presentata di seguito mostra alcuni messaggi inviati alla pompa e da essa ricevuti, consentendo di avviare/arrestare la pompa e di impostare/recuperare i parametri della stessa. In questo esempio viene controllato esclusivamente il canale 3. Ogni comando inviato alla pompa riceve una risposta da quest'ultima (messaggi evidenziati nella figura sottostante).
I comandi appena presentati nella finestra di IsmaTerm sono brevemente illustrati nella tabella sottostante.
| Comando | Definizione | Risposta della pompa | Definizione |
|---|---|---|---|
| 3H | Avvia il canale 3 | * | Comando eseguito con successo |
| 3xD | Ottieni la direzione | K{13}{10} | La direzione di rotazione è antioraria {13} — ritorno a capo [CR] {10} — avanzamento riga [LF] |
| 3J | Imposta la direzione di rotazione del canale in senso orario | * | Comando eseguito con successo |
| 3xM | Ottieni la modalità operativa del canale 3 | L{13}{10} | La modalità corrente è RPM |
| 3S | Ottieni la velocità impostata in RPM | 10,00{13}{10} | Tipo frazionario 1. Velocità di rotazione di 10 RPM. |
| 3S002400 | Impostare la velocità a 24 RPM | * | Comando eseguito con successo |
| 3I | Arresta il canale 3 | * | Comando eseguito con successo |
Un comando di controllo trasmesso alla pompa viene spesso ottenuto a seguito di calcoli e conversioni. È pertanto importante preparare tutti i comandi necessari prima di avviare il contrôle externe della pompa.
Inoltre, risulta più agevole scrivere e trasmettere questi comandi di controllo alla pompa tramite una serie di codici (già predisposti), avvalendosi di piattaforme di programmazione come Python e Matlab, piuttosto che inviare manualmente un comando sporadico alla pompa tramite un programma terminale. Tali piattaforme non solo facilitano la comunicazione con la pompa, ma consentono anche una gestione più agevole del contrôle externe con un bus di pompe, permettendo di sviluppare programmi di pompaggio dotati di cicli, pause e così via.
Di seguito vengono forniti e illustrati alcuni snippet di codice per l'avvio rapido della comunicazione seriale in Python e Matlab, concepiti come una breve introduzione alle modalità di comunicazione con la pompa Reglo ICC tramite queste due piattaforme di programmazione.
Come controllare la pompa Reglo ICC tramite Python?
La pompa Reglo ICC può essere controllata da remoto mediante Python, offrendo maggiore flessibilità e praticità nell'esecuzione di programmi di pompaggio complessi con cicli, pause e velocità o portate variabili. Questo approccio risulta particolarmente utile nell'integrazione di più dispositivi, poiché consente l'automazione di sequenze che coinvolgono tutte le apparecchiature collegate.
In questa sezione illustreremo dapprima come aprire la porta seriale e inviare semplici comandi alla pompa utilizzando Python. Verrà quindi introdotta una libreria Python personalizzata e dedicata, basata sul protocollo di comando della Reglo ICC, che consente di aprire la porta seriale e inviare stringhe di comando di controllo alla pompa Reglo ICC. Tratteremo esempi pratici che mostrano come avviare e arrestare la pompa, impostare la velocità, definire la portata e così via, fornendo una guida operativa per l'uso di Python nel controllo della pompa 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
Qui di seguito viene presentata la libreria Python personalizzata basata sul protocollo di comando della Reglo ICC. Questa libreria permette di creare programmi di pompaggio complessi, integrando funzionalità quali pause, cicli, logica condizionale e altro ancora, facilitando il contrôle externe di un bus di pompe.
'''
------------------------------------------
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
Come controllare la pompa Reglo ICC tramite Matlab?
In questa sezione verranno presentati degli snippet di codice Matlab che mostrano come aprire la porta seriale, scrivere e inviare stringhe di comando di controllo alla pompa. Successivamente, verrà definita una classe adattatore di avvio rapido specificamente concepita per la gestione dei comandi della Reglo ICC.
Esamineremo righe di codice che dimostrano l'esecuzione di operazioni comuni, quali l'avvio e l'arresto della pompa, l'impostazione della velocità, la lettura della direzione di rotazione e così via.
%-------------------------------------------------
% 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)
Conclusione
In questo articolo del blog abbiamo presentato la pompa peristaltica Reglo ICC (Independent Channel Control) ed esaminato i principi fondamentali del suo contrôle externe tramite due piattaforme di programmazione, Python e Matlab, avvalendoci del set di comandi di comunicazione della Reglo ICC. Ci auguriamo che questo articolo costituisca una guida preziosa per ricercatori e ingegneri che intendano impiegare la pompa peristaltica Reglo ICC nelle loro ricerche ed esperimenti di microfluidica.
Rimanete sintonizzati per ulteriori approfondimenti, tutorial e applicazioni pratiche nei nostri prossimi articoli. Fino ad allora, buon lavoro con il pompaggio e la programmazione 💻!
📧 In caso di domande o commenti, non esitate a contattarci all'indirizzo support@darwin-microfluidics.com.


