De Reglo ICC (Independent Channel Control) peristaltische pomp van Masterflex Ismatec is een hoge-precisie-instrument dat is ontworpen om ongeëvenaarde controle en nauwkeurigheid te leveren bij het doseren en verplaatsen van vloeistoffen. Het onderscheidt zich door de mogelijkheid om de richting en snelheid van maximaal vier kanalen onafhankelijk van elkaar te regelen, elk met unieke programma's voor starten, stoppen, kalibreren en meer.
Met een werkend debietbereik van 0,001 tot 35 mL/min per kanaal en aanpasbare pulsatieweekkeuzen, biedt deze pomp de flexibiliteit die nodig is voor uiteenlopende toepassingen. De intuïtieve digitale interface en rs-232 computerconnectiviteit maken het mogelijk om complexe pompseries te creëren en meerdere pompen tegelijkertijd te sturen.
In dit blogartikel onderzoeken we hoe u de Reglo ICC peristaltische pomp kunt aansturen met het seriële communicatieprotocol van de Reglo ICC via twee programmeerplatformen: Python en Matlab.
INHOUDSOPGAVE
Waarom kiezen voor de Reglo ICC peristaltische pomp?
De Reglo ICC peristaltische pomp is veelzijdig en gebruiksvriendelijk, en onderscheidt zich als een uitstekende keuze voor vloeistofbehandeling in zowel laboratoria als industriële omgevingen. Hier zijn enkele belangrijke voordelen:
- Onafhankelijke kanaalsturing van maximaal vier kanalen, elk met een eigen programma, debiet en draairichting tegelijkertijd.
- Hoge nauwkeurigheid en reproduceerbaarheid die zorgen voor een precieze en consistente vloeistofdosering door verschillen tussen tube en tube tot een minimum te beperken.
- Instelbare pulsatiefrequentie en debietbereik met 6, 8 of 12 rollers om de pulsaties en het debiet aan te passen (meer rollers resulteren in minder pulsaties en lagere debieten).
- Veelzijdige aansturingsopties via de digitale interface of rs-232 verbinding (tot acht gekoppelde pompen in een daisy-chain configuratie).
- Uitgebreide bedieningsmodi waaronder continu doseren tegen een ingestelde snelheid, het doseren van een volume over een specifieke periode, het kalibreren van elk kanaal, en meer.
Wat heeft u nodig om te communiceren met de Reglo ICC pomp?
Om te communiceren met de Reglo ICC peristaltische pomp heeft u een aantal essentiële componenten nodig:
- Een Reglo ICC pomp met een pompkop en een tube naar keuze,
- Een mini-usb/usb-kabel of een DB9-connector (aangesloten op een rs-232 regelmodule) voor seriële communicatie en gegevensoverdracht tussen de spuitpomp en de computer,
- Een programmeerplatform (in dit geval Python en Matlab) of een terminalemulator,
- Een basisbegrip van het seriële commando-protocol van de Reglo ICC, dat hieronder 👇 wordt uitgelegd en wordt gedetailleerd in de gebruikershandleiding van de pomp.
Hoe configureert u de communicatiepoort?
Voordat u data kunt verzenden en ontvangen van de pomp, moet u de communicatiepoort correct instellen. Volg hiervoor de volgende stappen:
- Sluit de mini-usb/usb-kabel of DB9-connector aan op de seriële poort aan de achterkant van de pomp en de bijbehorende poort op de computer.
- Schakel de pomp in.
- Identificeer de naam van de seriële poort die aan de verbinding op uw computer is toegewezen (bijv. COM4 voor Windows of /dev/ttyUSB0 voor Linux). Deze informatie vindt u meestal in apparaatbeheer of door terminalcommando's te gebruiken.
- Zorg ervoor dat de instellingen van de seriële poort overeenkomen met de specificaties van uw spuitpomp:
- 1 startbit,
- 8 databits,
- Pariteit: geen,
- 1 stopbit,
- een baudrate van 9600 bit/s.
- De modus 'Remote' op het scherm van de pomp bevestigt een succesvolle verbinding, wat aangeeft dat de pomp op afstand wordt aangestuurd door een computer via een usb 2.0, Mini-B of rs-232 verbinding.
Het seriële commando-protocol van de Reglo ICC
Het commando-protocol van de Reglo ICC biedt een reeks commando's voor contrôle externe, onderverdeeld in verschillende typen voor nauwkeurige manipulatie. Deze omvatten communicatiebeheer, operationele modi en instellingen, sturingsinstructies, configuratie-instellingen, kalibratie en meer.
Er zijn twee soorten berichten. Antwoordberichten die door de pomp naar de pc worden verzonden en verzoekberichten die door de pc naar de pomp worden verzonden. Alle berichten bestaan uit een reeks afdrukbare ASCII-tekens. Elk bericht wordt afgesloten met een regeleinde of een regeleinde en een regelterugloop.
Het commando-protocol van de Reglo ICC dat wordt gebruikt om de Reglo ICC peristaltische pomp aan te sturen, wordt hieronder samengevat. Meer details zijn te vinden in de handleiding van de pomp.
Gegevenstype-formaten
| Gegevenstype | Breedte | Eenheid | Bereik | Formaat |
|---|---|---|---|---|
| Richting | 1 | - | - | J = met de klok mee K = tegen de klok in |
| Discreet type 1 | 1 tot 4 | - | 0 tot 9999 | 1 tot 4 tekens in grondtal 10. Ongebruikte cijfers worden niet geretourneerd. |
| Discreet type 2 | 4 | - | 0 tot 9999 | 4 tekens in grondtal 10. Rechts uitgelijnde waarde. Ongebruikte cijfers aan de linkerkant zijn nullen. |
| Discreet type 3 | 6 | - | 0 tot 999999 | 6 tekens in grondtal 10. Rechts uitgelijnde waarde. Ongebruikte cijfers aan de linkerkant zijn nullen. |
| Discreet type 4 | 10 | - | 0 tot 4294967295 | 10 tekens in grondtal 10. Rechts uitgelijnde waarde. Ongebruikte cijfers aan de linkerkant zijn nullen. |
| Discreet type 5 | 3 | - | 0 tot 999 | 3 tekens in grondtal 10. Rechts uitgelijnde waarde. Ongebruikte cijfers aan de linkerkant zijn nullen. |
| Discreet type 6 | 5 | - | 0 tot 99999 | 5 tekens in grondtal 10. Rechts uitgelijnde waarde. Ongebruikte cijfers aan de linkerkant zijn nullen. |
| Breuktype 1 | Variabel | - | - | XXXX.DD Variabele breedte van het gehele getal (XXXX). Decimale punt en twee cijfers rechts (.DD) worden altijd meegeleverd. |
| Volumetype 1 | 7 | mL | - | mmmmEse ⇒ m,mmm × 10^se: mmmm — mantisse van 4 tekens Decimale punt wordt afgeleid na het eerste teken. E — 'E'-teken s — teken voor de exponent: + of - e — exponent van één cijfer |
| Tijdtype 1 | 1 tot 8 | 0.1s | 0 tot 35964000 (0 tot 999 uur) | 1 tot 8 tekens die de tijd weergeven. Ongebruikte cijfers worden niet geretourneerd. |
| Tijdtype 2 | 8 | 0.1s | 0 tot 35964000 (0 tot 999 uur) | 8 tekens die de tijd weergeven. Rechts uitgelijnde waarde. Ongebruikte cijfers aan de linkerkant zijn nullen. |
Antwoordberichten
Een antwoordbericht is een bericht dat door de pomp naar de pc wordt verzonden als reactie op een verzoekbericht van de pc. Dit kan de vorm hebben van een status- of gegevensantwoord.
Een statusantwoordbericht is één ASCII-teken dat aangeeft of het commando al dan niet met succes is uitgevoerd. De verschillende ASCII-tekens die de uitvoeringsstatus van het aangevraagde commando aangeven, staan in onderstaande tabel weergegeven.
| ASCII-teken | Definitie | In hex | In decimaal |
|---|---|---|---|
| * | commando succesvol uitgevoerd | 0x2a | 42 |
| # | commando niet succesvol uitgevoerd | 0x23 | 35 |
| + | positief antwoord gebruikt voor bepaalde commando's | 0x2b | 43 |
| - | negatief antwoord gebruikt voor bepaalde commando's | 0x2d | 45 |
Een gegevensantwoord wordt ontvangen van de pc wanneer parametewaarden worden opgevraagd door de pc. Het bestaat uit een of meer gegevensparametewaarden gescheiden door spaties. Elke gegevensparameter in het antwoordbericht is een datawaarde die door de pomp wordt geretourneerd in een indeling die is gedefinieerd door het verzoekbericht.
| Gegevensparameter 1 | [SP] | Gegevensparameter 2 | [SP] | … | Gegevensparameter n | [CR] | [LF] |
Verzoekberichten
De verzoekberichten zijn berichten die vanaf de pc naar de pomp worden verzonden. Deze dienen te worden beantwoord met een antwoordbericht van de pomp.
Een apparaatbesturingscommando (zoals hieronder weergegeven) bestaat uit een reeks afdrukbare ASCII-tekens en wordt afgesloten met een carriage return [CR] of een carriage return [CR] en een line feed [LF]. Het is gericht aan een individuele pomp/kanaal om specifieke parameters op te vragen of in te stellen.
| Adres (1-4) | Commandocode | Gegevensparameter 1 | [VB] | Gegevensparameter 2 | [VB] | … | Gegevensparameter n | [CR] | [LF] |
In het geval van een bus met pompen die in "daisy-chain" zijn geschakeld, loopt het adres van 1 tot 8 (het maximale aantal pompen dat tegelijkertijd wordt bestuurd). In het geval dat slechts één pomp wordt bestuurd, loopt het adres van 1 tot 4, overeenkomend met het aantal kanalen dat onafhankelijk wordt bestuurd, zoals weergegeven in het besturingscommando hierboven.
De commandoreeks bestaat typisch uit één of twee tekens die het commandotype aangeven. De gegevensparameters zijn optionele waarden die kunnen worden opgegeven bij het instellen van een parameterwaarde. Tot slot scheidt het verticale streepje de gegevensparameters.
Er kunnen verschillende commando's naar de pomp worden gestuurd met betrekking tot communicatiebeheer, pump drive, operationele modi en instellingen, kalibratie en meer. Enkele van deze direct geadresseerde commando's staan vermeld in onderstaande tabel. Meer commando's zijn te vinden en worden gedetailleerd in de handleiding.
| Commando | Functie | Instellen/Opvragen | Pomprespons |
|---|---|---|---|
| H | Pomp starten | Instellen | * - : kanaalinstelling niet juist |
| I | Pomp stoppen | Instellen | * |
| xI | Pompen pauzeren (STOP in toerental- of debietmodus) | Instellen | * |
| J | Rotatierichting instellen op met de klok mee | Instellen | * |
| K | Rotatierichting instellen op tegen de klok in | Instellen | * |
| xD | Rotatierichting opvragen | Opvragen | J : met de klok mee K : tegen de klok in |
| xM | Huidige modus van pomp/kanaal opvragen | Opvragen | L : RPM M : Debiet O : Volume bij debiet G : Volume in de tijd Q : Volume+Pauze N : Tijd P : Tijd+Pauze |
| L | Stel pomp/kanaal in op RPM-modus | Instellen | * |
| M | Stel pomp/kanaal in op debietmodus | Instellen | * |
| O | Stel pomp/kanaal in op modus voor volume bij debiet | Instellen | * |
| G | Stel pomp/kanaal in op modus voor volume in de tijd | Instellen | * - : kanaalinstelling niet juist |
| S | Instelling debiet in RPM-modus (0,01 RPM). Discreet type 3. | Instellen | * |
| S | Huidige snelheidsinstelling in RPM opvragen | Opvragen | Breuktype 1 |
| f | Stel debiet in RPM in voor volume/tijd-modus (ml/min). Volumetype 2 (Vergelijkbaar met type 1 zonder het teken 'E'). | Instellen | Volumetype 1 |
| f | Huidig volume/tijd-debiet (ml/min) opvragen | Opvragen | Volumetype 1 |
| xP | Pompauzetijd opvragen | Opvragen | Tijdtype 1 |
| xY | Start kalibratie van een kanaal | Instellen | * |
| xZ | Kalibratie annuleren | Instellen | * |
Er worden verschillende symbolen gebruikt om ASCII-tekens weer te geven in de gedefinieerde verzoekberichten. Enkele hiervan worden weergegeven in onderstaande tabel.
| Symbool | Definitie | In hex | In decimaal |
|---|---|---|---|
| [CR] | carriage return | 0x0d | 13 |
| [LF] | line feed | 0x0a | 10 |
| [SP] | spatie | 0x20 | 32 |
| [VB] | verticale streep | 0x7c | 124 |
| @ | '@'-teken | 0x40 | 64 |
Voorbeelden van commando's
Om met de pomp te communiceren, dient men de verschillende commando's van de pomp te begrijpen en de benodigde computercommando's voor de besturing samen te stellen.
In onderstaande tabel worden enkele voorbeelden van direct geadresseerde commando's gepresenteerd en toegelicht.
| Commando | Definitie | Pomprespons | Definitie |
|---|---|---|---|
| 1H[CR] | Start kanaal 1 | * | Commando succesvol uitgevoerd |
| 4I[CR] | Stop kanaal 4 | * | Commando succesvol uitgevoerd |
| 2xD[CR] | Vraag de richting van kanaal 2 op | K[CR][LF] | De rotatierichting is linksom |
| 3J[CR] | Stel de rotatierichting van kanaal 3 in op rechtsom | * | Commando succesvol uitgevoerd |
| 1xM[CR] | Vraag de bedrijfsmodus van kanaal 1 op | L[CR][LF] | De huidige modus is RPM |
| 3G[CR] | Stel de operationele modus van kanaal 3 in op volume in de tijd | * | Commando succesvol uitgevoerd |
| 1S[CR] | Haal de drivesnelheid van kanaal 1 op | 22.50[CR][LF] | Reactie in de vorm van "fractional type 1". De drivesnelheid is 22.5 RPM |
| 1S004500[CR] | Stel de drivesnelheid van kanaal 1 in op 45 RPM. De snelheidsinstelling heeft een resolutie van 0,01 RPM (45 toegewezen als 4500) in de vorm van een "discrete type 3" met een breedte van 6 tekens, waarbij ongebruikte cijfers aan de linkerkant nullen zijn (=> 004500). | * | Commando succesvol uitgevoerd |
| 3f[CR] | Vraag het pompdebiet van kanaal 3 op | 1275E+1[CR][LF] | Respons in de vorm van een "volume type 1" (mmmmEse => m.mmm x10se):
|
| 3f1500-3[CR] | Stel het pomptempo van kanaal 3 in op 1,5 µL/min. Instelling van het pomptempo in de vorm van "volumetype 2" (mmmmse => m.mmm x10se). 1,5 µL/min = 1,500x10-3 mL/min, derhalve:
| 1500E-3[CR][LF] | Respons in de vorm van "volume type 1". |
Hoe bedien je de Reglo ICC pomp met behulp van IsmaTerm?
IsmaTerm is software waarmee men de Reglo ICC pomp kan aansturen. Het is een terminal-emulatieprogramma dat via een RS-232 seriële poort met de pomp communicatie onderhoudt. IsmaTerm kan worden gebruikt om de pomp te starten en stoppen, pompparameters in te stellen en op te vragen, en de werking van de pomp te programmeren. Het is compatibel met Windows besturingssystemen en kan via deze link worden gedownload.
Om te communiceren met de pomp start u de IsmaTerm software, selecteert u de COM-poort die overeenkomt met de pomp en voert u de poortinstellingen in om de kenmerken ervan te wijzigen (zoals te zien is in onderstaande figuur). De standaard baudrate is 9600 bits/s, met 8 databits, 1 stopbit en geen pariteit.
In het IsmaTerm-venster kunnen commando's worden ingevoerd om de pomp aan te sturen en de respons te bekijken. Deze commando's zijn hoofdlettergevoelig en moeten worden afgesloten met een carriage return (Enter-toets).
Het hieronder getoonde IsmaTerm-venster toont enkele berichten die naar de pomp zijn verzonden en ervan zijn ontvangen, waarmee de pomp kan worden gestart/gestopt en pompparameters kunnen worden ingesteld/opgehaald. In dit voorbeeld wordt alleen kanaal 3 aangestuurd. Elk commando dat naar de pomp wordt gestzonden, ontvangt een reactie van de pomp (bedoelde berichten in de onderstaande afbeelding).
De zojuist in het IsmaTerm-venster gepresenteerde commando's worden kort toegelicht in onderstaande tabel.
| Commando | Definitie | Pomprespons | Definitie |
|---|---|---|---|
| 3H | Start kanaal 3 | * | Commando succesvol uitgevoerd |
| 3xD | De richting opvragen | K{13}{10} | De draairichting is tegen de klok in {13} — carriage return [CR] {10} — line feed [LF] |
| 3J | Stel de draairichting van het kanaal in op met de klok mee | * | Commando succesvol uitgevoerd |
| 3xM | Vraag de operationele modus van kanaal 3 op | L{13}{10} | De huidige modus is RPM |
| 3S | Vraag het ingestelde toerental in RPM op | 10.00{13}{10} | Fractioneel type 1. Rotatiesnelheid van 10 RPM. |
| 3S002400 | Stel de snelheid in op 24 RPM | * | Commando succesvol uitgevoerd |
| 3I | Stop kanaal 3 | * | Commando succesvol uitgevoerd |
Een naar de pomp gecommuniceerd regelcommando wordt soms verkregen na enige berekeningen en conversies. Het is daarom belangrijk om alle benodigde commando's voor te bereiden voordat u begint met de contrôle externe van de pomp.
Bovendien is het eenvoudiger om deze regelcommando's te schrijven en naar de pomp te communiceren via een reeks (reeds voorbereide) codes in programmeerplatformen zoals Python en Matlab, dan om af en toe een commando te schrijven en naar de pomp te sturen via een terminalprogramma. Deze platformen maken niet alleen een eenvoudigere communicatie met de pomp mogelijk, maar ook een eenvoudigere externe communicatie met een bus van pompen, en maken het mogelijk om een pompeerprogramma met lussen, pauzes, enz. te schrijven.
Hieronder worden seriële communicatiecodefragmenten voor een snelle start met Python en Matlab gepresenteerd en toegelicht. Deze dienen als een korte introductie in het communiceren met de Reglo ICC-pomp via deze twee programmeerplatformen.
Hoe bestuurt u de Reglo ICC-pomp met Python?
De Reglo ICC-pomp kan op afstand worden bestuurd met Python, wat meer flexibiliteit en gemak biedt voor het uitvoeren van complexe pompeerprogramma's met lussen, pauzes en variërende snelheden/debietwaarden. Deze benadering is met name nuttig bij het integreren van meerdere apparaten, omdat het de automatisering mogelijk maakt van sequenties waarbij al de aangesloten apparatuur betrokken is.
In dit gedeelte tonen we eerst hoe u de seriële poort opent en eenvoudige commando's naar de pomp stuurt met Python. Vervolgens wordt een specifieke aangepaste Python-bibliotheek geïntroduceerd die gebruikmaakt van het Reglo ICC-commandoprotocol, waarmee u de seriële poort kunt openen en regels met regelcommando's naar de Reglo ICC-pomp kunt sturen. We behandelen voorbeelden die laten zien hoe u de pomp start en stopt, de snelheid instelt, het debiet instelt, enz. Dit biedt een praktische handleiding voor het gebruik van Python om de Reglo ICC-pomp te besturen.
'''
------------------------------------------------
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
Hieronder wordt de aangepaste Python-bibliotheek gepresenteerd die gebruikmaakt van het Reglo ICC-commandoprotocol. Deze bibliotheek maakt het creëren van complexe pompeerprogramma's mogelijk, inclusief functies zoals pauzes, lussen, voorwaardelijke logica en meer, en zorgt voor een eenvoudigere contrôle externe van een bus van pompen.
'''
------------------------------------------
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
Hoe bestuurt u de Reglo ICC-pomp met Matlab?
In dit gedeelte worden Matlab-codefragmenten gepresenteerd die laten zien hoe u de seriële poort opent en reeksen regelcommando's naar de pomp schrijft en verzendt. Vervolgens wordt een adapterklasse voor een snelle start gedefinieerd, specifiek voor het afhandelen van Reglo ICC-commando's.
We doorlopen coderegels die aantonen hoe u veelvoorkomende taken uitvoert, zoals het starten/stoppen van de pomp, het instellen van de snelheid, het opvragen van de rotatierichting, enz.
%-------------------------------------------------
% 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)
Conclusie
In deze blogpost hebben we de Reglo ICC (Independent Channel Control) peristaltische pomp geïntroduceerd en de basisbeginselen van de contrôle externe ervan onderzocht via twee programmeerplatformen, Python en Matlab, met behulp van de Reglo ICC-communicatiecommandoset. We hopen dat dit bericht dient als een waardevolle gids voor onderzoekers en ingenieurs die de Reglo ICC peristaltische pomp willen inzetten in hun microfluïdica-onderzoek en -experimenten.
Blijf op de hoogte voor meer inzichten, tutorials en praktijktoepassingen in onze toekomstige berichten. Veel succes met pompen en programmeren 💻!
📧 Als u vragen of opmerkingen heeft, neem dan gerust contact met ons op via support@darwin-microfluidics.com.


