De LabV pompserie van Innofluid (voorheen bekend als Shenchen Baoding) is een geavanceerde serie peristaltische pompen voor stroommeting met een 4,3-inch kleurentouchscreen voor intuïtieve contrôle externe. Het geeft stromingsgegevens, instellingen en systeeminformatie tegelijkertijd weer, met animaties om de werkstatus te tonen. Uitgerust met intelligente kalibratie, online micro-afstelling en drie meetmodi—vast volume, vaste tijd en volume, en timer start/stop—is het uiterst veelzijdig. Compatibel met verschillende pompkoppen en met meerdere opties voor contrôle externe, is de LabV-serie ideaal voor laboratoriumgebruik, apparatuurintegratie en industriële productie.
In dit blogbericht onderzoeken we hoe u de LabV-pompen kunt aansturen met behulp van het MODBUS RTU-protocol via een gebruikelijk programmeerplatform: Python.
Het is vermeldenswaard dat hoewel er kleine verschillen kunnen zijn in registers en commando's tussen verschillende Lab pump-series (zoals LabF, LabN, LabK, etc.), ze allemaal dezelfde MODBUS RTU-communicatieprotocol gebruiken. Daarom zijn de inzichten in dit artikel relevant en toepasbaar voor gebruikers van elke Innofluid Lab pump-serie.
Waarom kiezen voor een LabV-serie peristaltische pomp?
De LabV peristaltische pomp onderscheidt zich als een uitstekende keuze voor vloeistofbehandeling in zowel laboratoria als industriële omgevingen. Met een nieuwe servomotor voor verbeterde nauwkeurigheid en duurzaamheid, gecombineerd met een 4,3" LCD-touchscreeninterface, biedt deze pomp intuïtieve contrôle externe voor nauwkeurige dosering en modi met een vast volume. Gemaakt van laboratorium-grade ABS, garandeert hij zowel gebruiksgemak als robuuste prestaties.
Met debieten van 0,0053 µL/min tot 775 mL/min en de flexibiliteit om tot 8 kanalen te ondersteunen, is hij geschikt voor een breed scala aan toepassingen. Bovendien maken zijn industriële constructie, dynamische display en intelligente kalibratiefunctionaliteit hem tot een betrouwbare aanwinst voor diverse vloeistoftranstaken.
Of het nu gaat om onderzoek, ondersteuning van apparatuur of industriële productie, de LabV-serie peristaltische pompen vormt een zeer goede oplossing voor uitdagingen op het gebied van vloeistofbehandeling.
Wat heb je nodig om te communiceren met een LabV-pomp?
Om te communiceren met een LabV-pomp via het MODBUS RTU-protocol, heb je het volgende nodig:
- Een LabV-pomp (hier wordt een LabV1-III Intelligent Flow Rate Peristaltic Pump voor gebruikt) met een pump head en een tube naar keuze
- Een serial cable die kan worden aangesloten op je computer of apparaat
- Een RS485- of RS232-bedrading op de contrôle externe-poort aan de achterkant van de pomp
- Een programmeerplatform (in dit geval Python)
- Een basisbegrip van het MODBUS RTU-communicatieprotocol dat hieronder 👇 wordt beschreven.
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 kabel aan voor de RS232- of RS485-communicatie op de contrôle externe-poort aan de achterkant van de pomp
- Schakel de pomp in
- Kies in de communication setting interface op het pompscherm RS232 of RS485 als uw communicatie-interface (details van de RS232- en RS485-bedrading worden weergegeven in de tabellen hieronder)
- Ongeacht of je kiest voor RS232 of RS485, het communicatieprotocol is standaard MODBUS RTU
- Stel de baudrate in
- Klik op de knop Slave No. om het adres van de peristaltische pomp in te stellen (bereik: 1-32)
- Selecteer communicatie inschakelen ON
- Keer terug naar de hoofdinterface aangezien de pomp alleen communicatiecontrôle externe ontvangt wanneer deze zich in de hoofdinterface bevindt; contrôle externe in andere instellingsinterfaces is ongeldig.
| RS232-bedradingsdetails | |
|---|---|
| Aansluiting | Beschrijving |
| GND | Communicatie-aardeaansluiting. |
| TXD | Hoofdzender, signaalontvangstaansluiting van de peristaltische pomp. |
| RXD | Peristaltische pomp verzendt, master ontvangt signaalterminal. |
| RS485 Bedradingsdetails | |
|---|---|
| Aansluiting | Beschrijving |
| GD1 | RS485 signaalmassa. |
| A+ | Verbind met de RS485 A+-terminal. |
| B- | Verbind met de RS485 B--terminal. |
Het MODBUS RTU-communicatieprotocol voor de LabV-serie
De LabV-serie peristaltische pompen biedt een uitgebreide opdrachtset voor nauwkeurige besturing en monitoring via het MODBUS RTU-protocol. Deze opdrachtset omvat diverse gecategoriseerde instructies om de functionaliteiten van de pomp te manipuleren, zoals het instellen van de motorsnelheid, het configureren van het debiet, het selecteren van de pompkop en het uitvoeren van kaloratieroutines. Elke opdracht, geïdentificeerd door unieke parameters, zorgt voor een nauwkeurige controle over de werking van de pomp.
Gedetailleerde uitleg en verdere informatie met betrekking tot het MODBUS RTU-protocol voor de aansturing van de LabV-pompen worden hieronder vermeld en zijn tevens te vinden in de documentatie van het communicatieprotocol.
Standaard MODBUS RTU-communicatieformaat
De berichtstructuur komt overeen met het formaat dat in onderstaande tabel is weergegeven.
| Veld | Grootte | Beschrijving |
|---|---|---|
| Slave-adres | 1 byte | Adres van de pomp. Het bereik is 1-32 en 0 wordt gebruikt voor broadcast. |
| Functiecode | 1 byte | Instructie voor het slave-apparaat. 03H: Houdregisters lezen 06H: Enkel register schrijven 10H: Meerdere registers schrijven 02H: Discrete ingangen lezen (datakits lezen) 05H: Enkele bit naar register schrijven |
| Datagebied | 0 – 252 bytes | Te verzenden data (variabele lengte) |
| CRC-controle | 2 bytes | Cyclic Redundancy Check voor foutdetectie CRC laag (1 Byte): Lagere byte van de CRC CRC hoog (1 Byte): Hogere byte van de CRC |
CRC-controle met CRC-16 in Python
CRC (Cyclic Redundancy Check) is een essentiële techniek voor het detecteren van fouten in datatransmissie. Hieronder demonstreren we hoe u CRC-16, zoals gebruikt in het Amerikaanse binaire synchrone systeem, kunt implementeren in Python. Bij CRC-16 maakt het foutdetectie-algoritme gebruik van een polynoom G(X) = X16 + X15 + X2 + 1 om de checksum te genereren. Dit polynoom definieert de wiskundige bewerkingen die worden uitgevoerd op de bits van het bericht tijdens het berekeningsproces van de CRC. Hieronder volgt een overzicht van het algoritme:
- Initialiseer een 16-bits register met de hexadecimale waarde FFFF (allemaal enen), aangeduid als het CRC-register.
- Voer een XOR-bewerking uit op de eerste 8 bytes van het bericht met de lage byte van het CRC-register. Sla het resultaat op in het CRC-register.
- Schuif het CRC-register één bit naar rechts, waarbij de meest significante bit (MSB) op nul wordt gezet.
- Controleer de minst significante bit (LSB) van het CRC-register:
- Als de LSB 0 is, herhaal stap 3 (schuifoperatie).
- Als de LSB 1 is, voer dan een XOR-bewerking uit op het CRC-register met de polynoomwaarde 0xA001 (1010 0000 0000 0001).
- Herhaal stap 3-4, in totaal 8 verschuivingen, om elke byte te verwerken.
- Herhaal stap 2-5 voor elke byte in het bericht totdat alle bytes zijn verwerkt.
- De uiteindelijke inhoud van het CRC-register is de CRC-waarde.
Communicatie-instellingen
Elke databyte heeft een structuur bestaande uit 1 startbit, 8 databits, 1 pariteitsbit en 1 stopbit. Bits worden verzonden in volgorde van de minst significante bit (LSB) naar de meest significante bit (MSB). De mogelijke communicatiebaudrates zijn onder andere 1200, 2400, 4800 en 9600 bits/s.
Voor integers (2 bytes) worden de gegevens zo gerangschikt dat de tweede byte eerst komt, gevolgd door de eerste byte. De hexadecimale waarde 2378H wordt bijvoorbeeld verzonden als 23H 78H. Voor long integers en floats (4 bytes) worden de gegevens gerangschikt met de vierde byte als eerste, gevolgd door de derde, tweede en eerste byte.
MODBUS-bericht RTU-frame-indeling
De RTU-frame-indeling van het MODBUS-bericht is zoals beschreven in de onderstaande tabel.
| Veld | Grootte | Beschrijving |
|---|---|---|
| Start | ≥ 3,5 tekens | Geeft het begin van de transmissie aan |
| Adres | 8 Bits | Adres van het slave-apparaat |
| Functiecode | 8 Bits | Instructie voor het slave-apparaat |
| Data | N x 8 bits | Te verzenden data (variabele lengte, N bytes) |
| CRC-controlecode | 16 bits | Cyclic Redundancy Check voor foutdetectie |
| Einde | ≥ 3,5 tekens | Geeft het einde van de transmissie aan |
🚨 Zorg ervoor dat het berichtframe continu wordt verzonden zonder inactieve tussenpozen tussen karakters die groter zijn dan 1,5 karaktertijd. Onvolledige berichtframes, aangegeven door een te lange inactieve tussenpoze, moeten door het ontvangende knooppunt worden genegeerd.
Abnormale reactie
Wanneer een host een gegevensaanvraag verzendt en de slave abnormale data ontvangt, dient dit een abnormale reactie te activeren. Als de adrescode verzonden door de host onjuist is, wat betekent dat deze niet overeenkomt met een adrescode van de slaves, of als de door de slave ontvangen data niet door de CRC-controle komt, wordt er geen foutcode geretourneerd. In dergelijke gevallen dient de host een hoger niveau reactieproces te starten.
In het functiecodegebied wordt de functiecode voor de abnormale reactie gedefinieerd als de normale functiecode vermeerderd met 80H.
In het datagebied wordt de te retourneren foutcode gedefinieerd zoals weergegeven in onderstaande tabel.
| Code | Naam | Betekenis |
|---|---|---|
| 01H | Ongeldige functiecode | De door de peristaltische pomp ontvangen functiecode is niet toegestaan, met uitzondering van 03H, 06H of 10H. |
| 02H | Ongeldig data-adres | Het door de peristaltische pomp ontvangen registeradres is niet toegestaan. |
| 03H | Ongeldige datawaarde | De geschreven data voldoet niet aan het bereik dat door de peristaltische pomp wordt verwacht. |
| 06H | Slave (peristaltische pomp) bezet | De peristaltische pomp is momenteel bezet en kan de opdracht niet voltooien vanwege een conflicterende status. |
🚨De peristaltische pomp accepteert alleen MODBUS-commando's via de Main Interface; andere interfaces ontvangen geen berichten.
Adres en inhoud van Holding Register
Hieronder staan de tabellen met de instellingen voor respectievelijk de basisparameters en de kalibratieparameters.
Instelling van basisparameters
| Adres (Decimaal) | Naam | Bereik | Gegevenstype |
|---|---|---|---|
| 1000 | Pompkop | Met betrekking tot Grafiek 1 | unsigned short int (2 Bytes) |
| 1001 | Tube-maat | Met betrekking tot Grafiek 1 | unsigned short int (2 Bytes) |
| 1002 | Motorsnelheid | 0,1-600 rpm | float (4 Bytes) |
| 1004 | Debiet | 0,1-99999 mL | float (4 Bytes) |
| 1007 | Terugzuighoek | 0-360° | unsigned short int (2 Bytes) |
| 1008 | Start-/stopbesturing | 1: Start, 0: Stop | unsigned short int (2 Bytes) |
| 1009 | Richtingsturing | 1: Met de klok mee, 0: Tegen de klok in | unsigned short int (2 Bytes) |
| 1010 | Volledige snelheid | 1: Start volledige snelheid, 0: Stop volledige snelheid | unsigned short int (2 Bytes) |
| 1015 | Stel debiet in | 0-99999 mL | float (4 Bytes) |
| 1018 | Werktijd | 0,1-9999 s | float (4 Bytes) |
| 1020 | Werkmodus | 0: Overdragen, 1: Vaste volume-meting, 2: Vaste tijd en volume | unsigned short int (2 Bytes) |
| 1021 | Pauzetijd | 0,1-9999 s | float (4 Bytes) |
| 1023 | Aantal herhalingen | 0-9999 keer, 0 betekent oneindig | unsigned short int (2 Bytes) |
💡 Belangrijke opmerkingen:
- Registers 1015 en 1018 zijn ongeldig wanneer de werkmodus is ingesteld op overdragen.
- Register 1018 is ongeldig wanneer de werkmodus is ingesteld op vaste volume-meting.
- Registers 1002 en 1004 zijn ongeldig wanneer de werkmodus is ingesteld op vaste tijd en volume.
- Zorg ervoor dat de registergegevens worden ingesteld volgens de meegeleverde tabel en vermijd het verzenden van meerdere registerinstellingen in één enkele opdracht.
Instelling van kalibratieparameters
| Adres (Decimaal) | Naam | Bereik | Gegevenstype |
|---|---|---|---|
| 2001 | Testtijd | 0,5-9999 s | unsigned short int (2 Bytes) |
| 2002 | Start/Stop test | 1: Start, 0: Stop | unsigned short int (2 Bytes) |
| 2003 | Actueel volume | 0-9999 mL | float (4 Bytes) |
| 2005 | Standaardwaarden herstellen | 1: Kalibratie herstellen | unsigned short int (2 Bytes) |
| 2006 | Fijnafstelling | 1: Verhogen, 0: Verlagen | unsigned short int (2 Bytes) |
Overzichtstabel pompkop en tube
| Naam pompkop | Type pompkop | Tube-maat | Specifieke 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# |
💡 Belangrijke opmerking:
- De bovenstaande tabel is niet volledig en bevat slechts een selectie van pompkoppen en tubematen. Raadpleeg de documentatie voor de volledige lijst.
Voorbeelden van opdrachtreeksen
Voorbeeld 1: Start de pomp
- Adres: 01, geeft het apparaatadres aan waarnaar de opdracht wordt verzonden.
- Functiecode: 06, wordt gebruikt om een enkele waarde naar een register te schrijven.
- Registeradres: 03F0, registeradres dat overeenkomt met het stuurregister voor het starten van de pomp (1008 in hexadecimaal).
- Data: 0001, geschreven naar het register om de pomp te starten (1: Start, 0: Stop).
- CRC: 487D, waarde die wordt gebruikt om de integriteit van de data te waarborgen.
De bijbehorende opdrachtreeks om de pomp te starten is daarom: 01 06 03 F0 00 01 48 7D.
Voorbeeld 2: De pompsnelheid instellen op 20 rpm
- Adres: 01, geeft het apparaatadres aan waarnaar de opdracht wordt verzonden.
- Functiecode: 10, wordt gebruikt om waarden naar meerdere registers te schrijven.
- Registeradres: 03EA, registeradres dat overeenkomt met het snelheidsinstellingsregister (1002 in hexadecimaal).
- Aantal registers: 0002, er wordt naar twee registers geschreven.
- Aantal bytes: 04, het aantal te schrijven databytes.
- Data: 41A00007, vertegenwoordigt de snelheidsinstelling in float-formaat die overeenkomt met 20 RPM.
- CRC: D76E, waarde die wordt gebruikt om de integriteit van de data te waarborgen.
De bijbehorende opdrachtreeks om de pompsnelheid in te stellen op 20 rpm is daarom: 01 10 03 EA 00 02 04 41 A0 00 07 D7 6E.
Deze 2 voorbeelden en andere voorbeelden van opdrachtreeksen worden weergegeven in onderstaande tabel.
| Taak | Opdrachtreeks |
|---|---|
| Pomp starten | 01 06 03 F0 00 01 48 7D |
| Richting instellen op CCW | 01 06 03 F1 00 00 D8 7D |
| Richting instellen op CW | 01 06 03 F1 00 01 19 BD |
| Snelheid instellen op 20 RPM | 01 10 03 EA 00 02 04 41 A0 00 07 D7 6E |
| Debiet instellen op 50,0 mL/min | 01 10 03 EC 00 02 04 42 48 00 00 7D 2C |
| Pomp stoppen | 01 06 03 F0 00 00 89 BD |
| Start volheid toeren | 01 06 03 F2 00 01 E9 BD |
Hoe stuur je de LabV pompen aan met Python?
De LabV pompserie kan op afstand worden aangestuurd met behulp van het MODBUS RTU-protocol via Python, wat grotere flexibiliteit en gemak biedt voor het uitvoeren van complexe pompprogramma's met lussen, pauzes en variërende snelheden/debieten. 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 wordt een toegewijde aangepaste Python-bibliotheek geïntroduceerd die gebruikmaakt van het MODBUS RTU-protocol, waarmee men de seriële poort kan openen en besturingscommando's kan verzenden naar de LabV pomp. We behandelen voorbeelden die laten zien hoe u de snelheid instelt, de pomp start en stopt, pompkop en slangmaat configureert, enz., waarmee we een praktische gids bieden voor het gebruik van Python bij de contrôle externe van een LabV pomp.
🚨🚨🚨 Belangrijke opmerking
- 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()
Deze Python-bibliotheek voor de contrôle externe van de LabV pompserie via het MODBUS RTU-protocol zorgt voor een nauwkeurige en geautomatiseerde aansturing van verschillende pompparameters zoals snelheid, richting, pompkop en slangmaat. Gebruikers van een LabV pomp kunnen hun pomp nu eenvoudig integreren in complexe workflows met meerdere apparaten, wat de operationele efficiëntie en flexibiliteit vergroot.
Conclusie
In deze blogpost hebben we de LabV peristaltische pompserie geïntroduceerd en de grondbeginselen verkend van de contrôle externe via Python met behulp van het MODBUS RTU-communicatieprotocol. We hopen dat dit artikel dient als een waardevolle gids voor onderzoekers en ingenieurs die een LabV peristaltische pomp willen inzetten in hun microfluïdica-onderzoek en -experimenten.
🚨 Hoewel er variaties bestaan tussen de verschillende series van Innofluid Lab pompen, benadrukken we dat het communicatieprotocol nagenoeg ongewijzigd blijft. Of u nu de LabF-serie, LabN-serie of een andere gebruikt, we vertrouwen erop dat deze inhoud eveneens nuttig zal zijn voor uw toekomstige projecten.
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.


