Dans un monde d'automatisation de laboratoire où la précision et le contrôle sont primordiaux, les pousse-seringues constituent d'excellents outils pour délivrer des volumes précis de liquide avec exactitude et reproductibilité. Parmi ces pompes, le pousse-seringue NE-1000 se distingue par ses performances robustes et sa polyvalence.
Dans cet article de blog, nous détaillons le contrôle de communication rs-232 du pousse-seringue NE-1000, explorons ses capacités et fournissons des informations sur la configuration de la communication et l'interfaçage avec Python avec des instructions étape par étape pour simplifier le processus. Que vous soyez un chercheur chevronné ou un débutant en matière de contrôle de pompe, cet article de blog vous dote des connaissances et des outils nécessaires pour prendre le contrôle de votre pompe NE-1000.
TABLE DES MATIÈRES
Pourquoi choisir le pousse-seringue NE-1000 ?
Le pousse-seringue NE-1000 de New Era Pump Systems est prisé pour sa fiabilité et sa flexibilité. Il offre une large gamme de débits (de 0,73 µL/h avec une seringue de 1 mL à 2120 mL/h avec une seringue de 60 mL) et une distribution de volume précise, ce qui le rend idéal pour diverses applications telles que le dosage de médicaments et les injections calibrées. Avec sa conception compacte et son interface user-friendly, le NE-1000 simplifie les installations expérimentales tout en garantissant des résultats cohérents et précis.
Il est entièrement programmable de manière autonome ou via n'importe quel ordinateur ou appareil doté d'un port de communication rs-232. Il dispose d'un gestionnaire de réseau de pompes intégré avec un réseau de pompes pouvant prendre en charge jusqu'à 100 pompes et autres appareils. Il se caractérise également par sa mémoire non volatile de tous les paramètres de fonctionnement et du programme de pompage, permettant des applications de pompage complexes et des interactions avec des appareils externes.
Qu'est-ce qu'un programme de pompage ?
Un programme de pompage dicte la séquence d'actions effectuées par la pompe, y compris la définition des débits de pompage, des volumes, des directions, et l'exécution de pauses ou d'instructions conditionnelles. Cette séquence de fonctions prédéfinie assure un fonctionnement précis et automatique de la pompe, avec ou sans intervention de l'utilisateur.
Un programme de pompage peut être saisi directement depuis le clavier de la pompe, ou téléchargé depuis un ordinateur à l'aide de logiciels dédiés : PumpTerm, un émulateur de terminal de pompe qui facilite la communication avec toute pompe équipée d'une interface PC en téléchargeant des programmes et des commandes à partir d'un fichier ou SyringePumpPro qui sert de logiciel de contrôle pour les pompes et permet la surveillance automatique de tous les paramètres de la pompe.
De plus, un tableur générateur de programmes de pompage est disponible pour aider à développer des programmes de pompage et à créer et organiser des séquences de pompage, qui peuvent être stockées dans un fichier texte et téléchargées vers la pompe pour exécution 📄.
Bien que PumpTerm et SyringePumpPro soient des outils précieux pour contrôler les pousse-seringues, ce ne sont pas les seules options disponibles. On peut utiliser des plateformes de programmation comme Python qui disposent de bibliothèques robustes pour la communication série permettant un contrôle précis et l'automatisation de la pompe NE-1000.
Avant d'explorer comment Python peut être utilisé pour un contrôle précis du pousse-seringue NE-1000 en fournissant des exemples et des informations sur son application, nous détaillerons brièvement l'ensemble des commandes rs-232 utilisé pour communiquer avec le NE-1000. Si vous êtes déjà familiarisé avec le protocole de communication rs-232, n'hésitez pas à passer directement aux extraits de code Python.
De quoi avez-vous besoin pour communiquer avec la pompe NE-1000 ?
Pour communiquer avec le pousse-seringue NE-1000 à l'aide de python, vous aurez besoin de quelques composants clés :
- Un pousse-seringue NE-1000 avec une seringue de votre choix,
- Un câble RS-232 permettant la communication série et autorisant le transfert de données entre le pousse-seringue et l'ordinateur,
- Un port série : L'ordinateur doit disposer d'un port série disponible ou d'un adaptateur USB-vers-série pour se connecter au câble RS-232,
- Un environnement Python avec le package PySerial qui encapsule l'accès au port série,
- Une compréhension de base du jeu de commandes RS-232 détaillé dans le manuel utilisateur de la pompe.
Comment configurer le port de communication ?
Avant de pouvoir commencer à envoyer des commandes au pousse-seringue NE-1000 via Python, il est essentiel de configurer le port de communication. Suivez ces étapes pour établir une connexion 🔧:
- Connectez le câble RS-232 au port série situé à l'arrière du pousse-seringue NE-1000 et au port correspondant sur l'ordinateur.
- Allumez la pompe.
- Assurez-vous que les paramètres du port série correspondent aux spécifications de votre pousse-seringue :
- 1 bit de début
- 8 bits de données
- Parité : aucune
- 1 bit d'arrêt
- un débit en bauds de 19200 bits/s
- Identifiez le nom du port série attribué à la connexion sur votre ordinateur (par exemple, COM4 pour Windows ou /dev/ttyUSB0 pour Linux). Vous pouvez généralement trouver cette information dans le gestionnaire de périphériques ou en utilisant des commandes de terminal.
- Une icône en forme de triangle (en haut à gauche de l'écran de la pompe) indique une communication réussie, persistant jusqu'à la mise hors tension ou l'entrée dans la 'Configuration des réglages'.
- Testez la connexion en envoyant une commande simple, telle que l'interrogation de l'état de la pompe.
Qu'est-ce que le jeu de commandes RS-232 ?
Le pousse-seringue NE-1000 communique via RS-232 en stockant les modifications de données dans une mémoire non volatile, à l'exception des ajustements de débit pendant le fonctionnement. Chaque phase du programme englobe le débit, le volume à distribuer et la direction de pompage sélectionnables à l'aide de la commande « PHN ».
Le jeu de commandes RS-232 utilisé pour contrôler le pousse-seringue NE-1000 est résumé dans le tableau ci-dessous. Les commandes sans paramètres servent de requêtes renvoyant les données demandées. Les réponses reflètent généralement les paramètres de commande. Les commandes de paramétrage réussies génèrent une réponse d'état tandis que les échecs génèrent un message d'erreur.
| Commande | Définition |
|---|---|
| DIA [float] | Diamètre intérieur de la seringue |
| PHN [données de phase] | Numéro de phase du programme |
| FUN [fonction de phase] | Fonction de phase du programme |
| RAT | Fonction 'RATE' de pompage |
| RAT [flottant | unités de débit] | Débit de pompage |
| VOL [flottant | unités de volume] | Volume à dispenser |
| DIR [INF \ WDR] | Sens de pompage |
| INC | Fonction de taux d'incrément, 'INCR' |
| DEC | Fonction de taux de décrément, 'DECR' |
| JMP [données de phase] | Sauter à la fonction de phase du programme, 'JP:nn' |
| LPS | Démarrer la boucle, 'LP:ST' |
| LOP [données de comptage] | Boucler vers le début de la boucle précédente 'nn' fois, 'LP:nn' |
| LPE | Fin de boucle, 'LP:EN' |
| PAS [données numériques] | Mettre en pause le pompage pendant 'nn' secondes, 'PS:nn' |
| BEP | Bip court, 'BEEP' |
| CLD [INF \ WDR] | Volume net délivré |
| RÉINITIALISER | Réinitialiser la pompe et effacer la mémoire du programme |
| EXÉCUTER | Démarrer le programme de pompage |
| STP | Arrêter la pompe, 'STOP' |
Les unités de débit sont « UM » pour µL/min, « MM » pour mL/min, « UH » pour µL/h et « MH » pour mL/h. Les unités de volume sont « UL » pour µL et « ML » pour mL. Celles-ci sont définies en fonction du réglage actuel du diamètre de la seringue.
Lors de l'envoi de la commande « RUN » à la pompe, le Programme de Pompage reprend au point où il a été arrêté, dans le cas où il était en pause. Sinon, le Programme de Pompage démarre à partir de la Phase 1. Lors de l'exécution de la commande « RUN # », le programme démarre à partir de la phase spécifiée (# étant le numéro de la phase « PHN »).
Lorsque la commande « STP » est envoyée au pousse-seringue, si le programme de pompage est en cours d'exécution, ce dernier sera mis en pause et le pousse-seringue sera arrêté. Si le programme de pompage est déjà en pause, la commande « STP » annulera la pause et réinitialisera le programme de pompage à la phase 1. Pour plus de détails sur le jeu de commandes RS-232, veuillez consulter la documentation du pousse-seringue NE-1000.
Une fois le port de communication configuré et doté d'une compréhension de base du jeu de commandes RS-232, vous êtes prêt à commencer à développer des scripts Python pour contrôler le pousse-seringue NE-1000 🕹️.
💡 Fonctionnalités upgrade du firmware standard NE-1000 :
- L'upgrade des fonctionnalités avancées du micrologiciel X avec une rampe linéaire/de gradient pour des gradients fluides et des fonctions de programmation supplémentaires.
- L'upgrade des fonctionnalités avancées et de la mémoire du micrologiciel X2 incluant toutes les fonctionnalités de la version du micrologiciel X avec une augmentation de la mémoire du programme de pompage de 41 à 340 phases.
Programmation du pousse-seringue NE-1000 à l'aide de Python ?
Des extraits de code Python montrant comment ouvrir le port série, écrire et envoyer des chaînes de commandes de contrôle au pousse-seringue et écrire un programme de pompage pour le NE-1000 seront présentés ci-dessous.
Nous passerons en revue des extraits de code qui démontrent comment effectuer des tâches courantes telles que l'infusion de liquides, le réglage des débits et l'exécution de séquences de pompage complexes. Ces exemples fourniront une compréhension pratique du contrôle basé sur Python du pousse-seringue NE-1000.
Réplication des fonctionnalités de SyringePumpPro et PumpTerm
Dans cette première partie, nous utiliserons Python pour reproduire la fonctionnalité offerte par SyringePumpPro et PumpTerm : le téléchargement d'un programme de pompage depuis un ordinateur (ou son écriture directe sur le pousse-seringue). Cette sous-section élucidera la manière dont un script Python émule efficacement les capacités de ces outils logiciels, permettant le contrôle et l'automatisation du pousse-seringue NE-1000.
Nous utiliserons la bibliothèque Python « serial » pour établir la communication avec le pousse-seringue NE-1000 via une connexion par port série. Tout d'abord, nous importons le module « serial », qui fournit des outils pour la communication série. La fonction « serial.Serial » est ensuite employée pour initialiser la connexion au port série, en spécifiant des paramètres tels que le nom du port (« COM2 »), le débit en bauds (19200) et les paramètres de communication tels que la parité, la taille des octets et les bits d'arrêt.
Les extraits de code Python sont présentés et détaillés ci-dessous👇.
Téléchargement d'un fichier PPL d'un ordinateur vers la pompe
'''
------------------------------------------------
Uploading a PPL File from a Computer to the Pump
------------------------------------------------
'''
import serial # serial library to establish communication with the pump
import time
# Open the serial port
ser = serial.Serial('COM2', 19200, parity=serial.PARITY_NONE, bytesize=8, stopbits=1, timeout=None, xonxoff=0, rtscts=0) # make sure to modify the port name 'COM2' with the corresponding port on your computer
# Define a function to send commands (with an option to read responses from the pump)
def send_command(command):
ser.write((command + '\r\n').encode()) # send commands as encoded strings
time.sleep(0.1) # brief delay allowing time for the pump to process the command
# Define a function to read the content of a PPL file
def read_ppl_file(file_path):
with open(file_path, 'r') as file:
return file.read()
# PPL file path; make sure you modify it by writing your file path
ppl_file_path = 'C:/Users/DarwinMicrofluidics/Desktop/NE1000/Test.ppl'
# Read the content of the PPL file
ppl_content = read_ppl_file(ppl_file_path)
# Reset pump
send_command("RESET")
# Split PPL content into lines and send each line as a command
for line in ppl_content.split('\n'):
line = line.strip() # remove leading/trailing whitespaces
if line: # skip empty lines
send_command(line) # send the command line to the pump
# Run the pumping program
send_command("RUN")
# Once the program executed, close the serial port (optional)
ser.close()
La fonction « send_command » est définie pour simplifier le processus d'envoi de commandes à la pompe (avec une option pour lire également sa réponse). Au sein de cette fonction, les commandes sont envoyées à la pompe sous forme de chaînes encodées, suivies d'un court délai via « time.sleep() » afin de laisser le temps à la pompe de traiter la commande.
De plus, une fonction “read_ppl_file” est incluse pour lire le contenu d'un fichier PPL (Pump Programming Language), qui contient des séquences de commandes à exécuter par la pompe. Le chemin d'accès au fichier PPL est spécifié, et son contenu est lu à l'aide de la fonction "read_ppl_file".
La pompe est réinitialisée à l'aide de la commande “RESET”, assurant un démarrage propre avant d'exécuter la séquence de commandes contenues dans le fichier PPL. Le contenu du PPL est divisé en lignes, et chaque ligne est envoyée comme une commande à la pompe en utilisant la fonction “send_command”. Enfin, la commande “RUN” est envoyée pour initier le processus de pompage.
Une fois toutes les commandes exécutées, la connexion au port série peut être fermée à l'aide de « ser.close() », garantissant un nettoyage approprié des ressources.
Écriture d'un programme de pompage dans la pompe
Le code précédent démontre une approche rationalisée pour contrôler le pousse-seringue NE-1000 à l'aide de Python. Cependant, on peut ne pas avoir accès au tableur générateur de programmes de pompage ou simplement préférer écrire le programme de pompage directement dans le script python pour effectuer des modifications directes et visuelles sur le programme avant de l'envoyer au pousse-seringue. Cette approche offre une plus grande flexibilité et immédiateté dans la programmation des actions du pousse-seringue. L'extrait de code suivant illustre cette méthode, permettant aux utilisateurs de définir le programme de pompage directement dans le script Python, ce qui permet des ajustements en temps réel des paramètres et des séquences.
'''
-------------------------------------
Writing a Pumping Program to the Pump
-------------------------------------
'''
import serial # serial library to establish communication with the pump
import time
# Open the serial port
ser = serial.Serial('COM2', 19200, parity=serial.PARITY_NONE, bytesize=8, stopbits=1, timeout=None, xonxoff=0, rtscts=0) # make sure to modify the port name 'COM2' with the corresponding port on your computer
# Define a function to send commands (with an option to read responses from the pump)
def send_command(command):
ser.write((command + '\r\n').encode()) # send commands as encoded strings
time.sleep(0.1) # brief delay allowing time for the pump to process the command
# Define your pumping program
Pumping_Program = """
DIA 26.59
PHN 1
FUN RAT
RAT 500 MH
VOL 2.0
DIR INF
PHN 2
FUN PAS 10
PHN 3
FUN RAT
RAT 200 MH
VOL 1.0
DIR WDR
PHN 4
FUN STP
"""
# Reset pump
send_command("RESET")
# Split the content of the program into lines and send each line as a command
for line in Pumping_Program.split('\n'):
line = line.strip() # remove leading/trailing whitespaces
if line: # skip empty lines
send_command(line) # send the command line to the pump
# Run the pumping program
send_command("RUN")
# Once the program executed, close the serial port (optional)
ser.close()
Ici, nous définissons un Pumping_Program directement au sein du script Python. Le programme (détaillé dans les Exemples de programmes de pompage ci-dessous 👇) contient une séquence de commandes, organisées en lignes individuelles. Chaque ligne est envoyée comme une commande à la pompe en utilisant la fonction “send_command”.
Après avoir envoyé l'intégralité du programme de pompage à la pompe, la commande “RUN” est émise pour initier le processus de pompage.
Exemples de programmes de pompage
Vous trouverez ci-dessous trois exemples de programmes de pompage conçus pour le pousse-seringue NE-1000, chacun étant adapté à des exigences expérimentales spécifiques.
Exemple 1 : Infusion et retrait de liquides
Dans cet exemple, le pousse-seringue NE-1000 perfuse un liquide à un débit et un volume spécifiés, fait une pause de 10 secondes, retire un volume différent à un débit différent puis s'arrête. Les différentes phases du programme de pompage sont résumées dans le tableau ci-dessous et le programme correspondant est présenté dans l'extrait de code.
| Phase | Fonction | Valeur | Débit | Volume | Direction |
|---|---|---|---|---|---|
| 1 | RAT | - | 500 mL/h | 2.0 mL | Infuser |
| 2 | PAS | 10 | - | - | - |
| 3 | RAT | - | 200 mL/hr | 1.0 mL | Retrait |
| 4 | STP | - | - | - | - |
Example1 = """
DIA 26.59
PHN 1
FUN RAT
RAT 500 MH
VOL 2.0
DIR INF
PHN 2
FUN PAS 10
PHN 3
FUN RAT
RAT 200 MH
VOL 1.0
DIR WDR
PHN 4
FUN STP
"""
# start by setting the syringe diameter
# no need to set the volume units when setting the volume in a RATE function
Exemple 2 : Distributions répétées avec aspiration inverse
Ce programme de pompage distribue 2,0 mL d'un liquide avec un intervalle de pause de 20 secondes entre chaque distribution (un total de 4 distributions). Après chaque distribution, un petit volume de 0,25 mL est retiré pour éviter les égouttements. De plus, un signal sonore est émis 3 secondes avant la fin de chaque pause pour signaler la distribution à venir. À partir de la deuxième distribution, 0,25 mL est ajouté au volume distribué pour compenser le volume aspiré lors de la distribution précédente.
Les différentes phases du programme de pompage sont résumées dans le tableau ci-dessous et le programme correspondant est présenté dans l'extrait de code.
| Phase | Fonction | Valeur | Débit | Volume | Direction |
|---|---|---|---|---|---|
| 1 | RAT | - | 500 mL/h | 2.0 mL | Infuser |
| 2 | RAT | - | 500 mL/h | 0.25 mL | Retrait |
| 3 | LPS | - | - | - | - |
| 4 | PAS | 17 | - | - | - |
| 5 | BEP | - | - | - | - |
| 6 | PAS | 3 | - | - | - |
| 7 | RAT | - | 500 mL/h | 2.25 mL | Infuser |
| 8 | RAT | - | 500 mL/h | 0.25 mL | Retrait |
| 9 | LOP | 3 | - | - | - |
Example2 = """
DIA 26.59
PHN 1
FUN RAT
RAT 500 MH
VOL 2.0
DIR INF
PHN 2
FUN RAT
RAT 500 MH
VOL 0.25
DIR WDR
PHN 3
FUN LPS
PHN 4
FUN PAS 17
PHN 5
FUN BEP
PHN 6
FUN PAS 3
PHN 7
FUN RAT
RAT 500 MH
VOL 2.25
DIR INF
PHN 8
FUN RAT
RAT 500 MH
VOL 0.25
DIR WDR
PHN 9
FUN LOP 3
"""
# an initial dispense of 2 mL followed by 3 dispenses of 2.25 mL
# send_command("STP") at any moment to pause/stop the pumping program
Exemple 3 : Rampe de débit
Ce programme de pompage fait varier continuellement le débit de pompage à la hausse et à la baisse, en l'incrémentant d'une valeur initiale de 300 mL/h à 400 mL/h par paliers de 20 mL/h, à chaque fois après avoir distribué un volume de 0,5 mL. Après avoir atteint le débit maximal, le débit de pompage diminue par paliers similaires, après chaque distribution de 0,5 mL, jusqu'à atteindre 200 mL/h. Enfin, le débit est réincrémenté à sa valeur initiale, et le cycle se répète.
Les différentes phases du programme de pompage sont résumées dans le tableau ci-dessous et le programme correspondant est présenté dans l'extrait de code.
| Phase | Fonction | Valeur | Débit | Volume | Direction |
|---|---|---|---|---|---|
| 1 | RAT | - | 300 mL/h | 0.5 mL | Infuser |
| 2 | LPS | - | - | - | - |
| 3 | INC | - | 20 mL/hr | 0.5 mL | Infuser |
| 4 | LOP | 5 | - | - | - |
| 5 | LPS | - | - | - | - |
| 6 | DEC | - | 20 mL/hr | 0.5 mL | Infuser |
| 7 | LOP | 10 | - | - | - |
| 8 | LPS | - | - | - | - |
| 9 | INC | - | 20 mL/hr | 0.5 mL | Infuser |
| 10 | LOP | 5 | - | - | - |
| 11 | JMP | 2 | - | - | - |
Example3 = """
DIA 26.59
PHN 1
FUN RAT
RAT 300 MH
VOL 0.5
DIR INF
PHN 2
FUN LPS
PHN 3
FUN INC
RAT 20
VOL 0.5
DIR INF
PHN 4
FUN LOP 5
PHN 5
FUN LPS
PHN 6
FUN DEC
RAT 20
VOL 0.5
DIR INF
PHN 7
FUN LOP 10
PHN 8
FUN LPS
PHN 9
FUN INC
RAT 20
VOL 0.5
DIR INF
PHN 10
FUN LOP 5
PHN 11
FUN JMP 2
"""
# send_command("STP") at any moment to pause/stop the pumping program
# no need to set the rate units when setting the rate step in a INC and DEC functions
Bibliothèque Python personnalisée pour le contrôle du pousse-seringue NE
Dans cette seconde partie, une autre méthode efficace pour piloter le pousse-seringue NE-1000 à l'aide de Python est présentée. Une bibliothèque Python personnalisée a été développée, proposant des fonctions intuitives pour configurer les paramètres, exécuter des actions et gérer la communication.
Nous présentons ci-dessous la bibliothèque personnalisée utilisée pour piloter le pousse-seringue NE-1000, ainsi que ses limites. Nous examinerons trois exemples de programmes de perfusion (les exemples 1, 2 et 3 présentés ci-dessus) afin de démontrer l'utilisation de ces fonctions pour exécuter des séquences de perfusion précises.
'''
-----------------------------------------------------------------------
NE-1000 Syringe Pump Control Library Using RS232 Communication Protocol
-----------------------------------------------------------------------
'''
class NewEraSyringePump:
# Open the serial port
def __init__(self, port):
self.ser = serial.Serial(port, 19200, parity=serial.PARITY_NONE, bytesize=8, stopbits=1, timeout=None, xonxoff=0, rtscts=0) # data format corresponding to the NE-1000
time.sleep(0.075) # time for the pump to initialize
# Write a command to the syringe pump
def send_command(self, command):
self.ser.write(command.encode() + b'\r\n') # convert the command string into bytes, append a carriage return and line feed, and send the resulting byte sequence to the serial port
time.sleep(0.075) # a brief delay to ensure that the pump has enough time to process the command before proceeding to the next operation
# Start the pump
def start_pump(self):
self.send_command("RUN") # RUN to run the pump
# Stop the pump
def stop_pump(self):
self.send_command("STP") # STP to stop the pump
# Set the syringe diameter
def set_diameter(self, diameter):
command = f"DIA {diameter}" # DIA for syringe inside diameter (float)
self.send_command(command) # set the syringe diameter using the "send_command" function
#-----------------------------------------------------------------------------------------#
# The three functions below (set_rate, set_volume and set_direction) are only defined to be used within the run_RATE_function defined afterwards
#-----------------------------------------------------------------------------------------#
# Set the pumping rate
def set_rate(self, rate, r_units):
command = f"RAT {rate} {r_units}" # RAT for pumping rate
# Rate units: 'MH' for mL/hr - 'MM' for mL/min - 'UH' for µL/hr - 'UM' for µL/min
self.send_command(command)
# Set the volume
def set_volume(self, volume, units):
command = f"VOL {volume} {units}" # VOL for volume
# Volume units: 'ML' for mL - 'UL' for µL
self.send_command(command)
# Set the pumping direction
def set_direction(self, direction):
if direction == 0:
command = "DIR INF" # DIR for pumping direction - INF for infuse
elif direction == 1:
command = "DIR WDR" # WDR for withdraw
elif direction == 2:
command = "DIR REV" # REV for reverse direction
self.send_command(command)
#-----------------------------------------------------------------------------------------#
# Define the "RATE" Function
def run_RATE_function(self, rate, rate_units, volume, units, direction):
self.set_rate(rate, rate_units) # Set the pumping rate
self.set_volume(volume, units) # Set the pumping volume
self.set_direction(direction) # Set the pumping direction
self.start_pump() # Start the pumping rate function
# Calculate pumping duration based on rate and volume units:
if rate_units == "MH" and units == "ML":
pumping_duration = volume * 3600 / rate # mL/hr and mL
elif rate_units == "UH" and units == "UL":
pumping_duration = volume * 3600 / rate # µL/hr and µL
elif rate_units == "MH" and units == "UL":
pumping_duration = volume * 3.6 / rate # mL/hr and µL
elif rate_units == "UH" and units == "ML":
pumping_duration = volume * 3.6 * 10**6 / rate # µL/hr and mL
elif rate_units == "MM" and units == "ML":
pumping_duration = volume * 60 / rate # mL/min and mL
elif rate_units == "UM" and units == "UL":
pumping_duration = volume * 60 / rate # µL/min and µL
elif rate_units == "MM" and units == "UL":
pumping_duration = volume * 0.06 / rate # mL/min and µL
elif rate_units == "UM" and units == "ML":
pumping_duration = volume * 6 * 10**4 / rate # µL/min and mL
else:
raise ValueError("Unsupported units combination: rate_units={}, units={}".format(rate_units, units))
time.sleep(pumping_duration) # Delay to ensure the pump dispenses the required volume at the given pumping rate
self.stop_pump() # Stop the pump
# Reset the pump
def reset_pump(self):
self.send_command("RESET") # RESET to reset the pump
# Pump beep
def beep(self):
self.send_command("BEP") # BEP for the pump beep
# Delete the pump
def __del__(self):
self.ser.close() # close the serial communication port
##### BELOW are the commands that should be executed #####
Cette bibliothèque personnalisée permet de piloter le pousse-seringue NE-1000. Elle établit la communication avec le pousse-seringue via un port série et permet aux utilisateurs de définir des paramètres tels que le diamètre de la seringue, le débit, le volume et le sens. Les utilisateurs peuvent déclencher des actions telles que le démarrage, l'arrêt et la réinitialisation du pousse-seringue. De plus, une fonction « RATE » est définie à l'aide d'un ensemble de fonctions préexistantes. Grâce à cette bibliothèque, les utilisateurs peuvent créer des séquences de perfusion précises directement depuis leur environnement Python, comme l'illustrent les trois exemples ci-dessous.
Exemple 1 : Infusion et retrait de liquides
Dans cet exemple, le pousse-seringue NE-1000 perfuse un fluide à un débit et un volume déterminés, marque une pause de 10 secondes, retire un volume différent à un autre débit, puis s'arrête. OUI, vous avez bien lu ! Cet exemple a été présenté juste avant, illustrant la capacité de la bibliothèque à exécuter la même séquence de perfusion que celle décrite précédemment.
#--------------------------------------------------------------------------------------------#
# Example 1: Infuse 4.0 mL at 500 mL/hr, pause the pumping for 10s and then withdraw 2.0 mL at 200 mL/hr. Finally, stop the pump.
#--------------------------------------------------------------------------------------------#
# Initialize the pump with the specified COM port
pump = NewEraSyringePump('COM2') # Replace 'COM2' with the actual COM port used for your connection
# Reset pump
pump.reset_pump() # Reset the pump parameters
# Set syringe diameter
pump.set_diameter(26.59) # Change this value according to the syringe you're using
### BEGIN PUMPING SEQUENCE ###
# First RATE function
pump.run_RATE_function(500, "MH", 4, "ML", 0) # Infuse 4.0 mL at 500 mL/hr
# Pause pumping
pause_time = 10
time.sleep(float(pause_time)) # Pause the pumping for 10 seconds
# Second RATE function
pump.run_RATE_function(200, "MH", 2, "ML", 1) # Withdraw 2.0 mL at 200 mL/hr
### END PUMPING SEQUENCE ###
# Delete pump and close the serial communication port
del pump
Cet extrait de code Python illustre l'utilisation de la bibliothèque personnalisée pour piloter le pousse-seringue NE-1000 dans le cadre d'une séquence de perfusion spécifique. Le pousse-seringue est d'abord initialisé via le port COM spécifié, puis réinitialisé pour rétablir ses paramètres par défaut. Le diamètre de la seringue est configuré en conséquence.
La séquence de perfusion comprend trois étapes principales :
- La pompe infuse 4,0 mL de liquide à un débit de 500 mL/h.
- Après une pause de 10 secondes, la pompe aspire 2,0 mL de liquide à un débit de 200 mL/h.
- Enfin, la pompe est arrêtée.
Chaque étape de la séquence est exécutée à l'aide de la méthode "run_RATE_function" de la classe "NewEraSyringePump"; en y spécifiant le débit, le volume, les unités et le sens. Une fois la séquence de perfusion terminée, l'instance du pousse-seringue est supprimée et le port de communication série est fermé.
Ce code constitue un exemple simple illustrant l'utilisation de la bibliothèque personnalisée pour piloter le pousse-seringue NE-1000 et exécuter des séquences de perfusion précises. Deux autres exemples sont présentés ci-dessous.
Exemple 2 : Distributions répétées avec aspiration inverse
Ce programme de pompage distribue 2,0 mL d'un liquide avec un intervalle de pause de 20 secondes entre chaque distribution (un total de 4 distributions). Après chaque distribution, un petit volume de 0,25 mL est retiré pour éviter les égouttements. De plus, un signal sonore est émis 3 secondes avant la fin de chaque pause pour signaler la distribution à venir. À partir de la deuxième distribution, 0,25 mL est ajouté au volume distribué pour compenser le volume aspiré lors de la distribution précédente. Le programme correspondant est présenté dans l'extrait de code ci-dessous.
#--------------------------------------------------------------------------------------------#
# Example 2: Dispense 2.0 mL at 500 mL/hr with a pause of 20 seconds between dispenses. In addition, after each dispense, a volume of 0.25 mL is sucked back at the same flow rate to prevent dripping. 3 seconds before the end of the pause interval, a beep is sounded to alert the operator to prepare for the next dispense. Starting with the second dispense, 0.25 mL is added to the volume dispensed to compensate for the sucked back volume of the previous dispense. 3 dispenses are executed after the initial dispense.
#--------------------------------------------------------------------------------------------#
# Initialize the pump with the specified COM port
pump = NewEraSyringePump('COM2') # Replace 'COM2' with the actual COM port used for the connection
# Reset pump
pump.reset_pump() # Reset the pump parameters
# Set syringe diameter
pump.set_diameter(26.59) # Change this value according to the syringe you're using
### BEGIN PUMPING PROGRAM ###
dispensed_volume = 2.0 # Initial dispensed volume
nb_dispenses = 3 # Number of dispenses executed after the initial dispense
suck_back_volume = 0.25 # Volume sucked back after each dispense
pause_time = 20 # Pause time of 20 seconds
# Initial dispense and suck back
pump.run_RATE_function(500, "MH", dispense_volume, "ML", 0) # RATE function to dispense, 0 to infuse
pump.run_RATE_function(500, "MH", suck_back_volume, "ML", 1) # RATE function to suck back, 1 to withdraw
# Execute 3 more dispenses after the initial dispense
for dispense_count in range(nb_dispenses):
# Wait for the specified pause time
time.sleep(pause_time - 3) # Wait for 20s - 3s
# Beep to alert the operator 3 seconds before the end of the pause
pump.beep() # Pump beep
time.sleep(3) # Wait for the remaining 3 seconds
# Run the RATE function for dispensing while adding 0.25 mL to the volume dispensed to compensate for the sucked back volume of the previous dispense
pump.run_RATE_function(500, "MH", dispense_volume + suck_back_volume, "ML", 0)
# Run the pumping rate function for suck back
pump.run_RATE_function(500, "MH", suck_back_volume, "ML", 1)
### END PUMPING PROGRAM ###
# Delete pump
del pump
Exemple 3 : Rampe de débit
Ce programme de pompage fait varier continuellement le débit de pompage à la hausse et à la baisse, en l'incrémentant d'une valeur initiale de 300 mL/h à 400 mL/h par paliers de 20 mL/h, à chaque fois après avoir distribué un volume de 0,5 mL. Après avoir atteint le débit maximal, le débit de pompage diminue par paliers similaires, après chaque distribution de 0,5 mL, jusqu'à atteindre 200 mL/h. Enfin, le débit est réincrémenté à sa valeur initiale, et le cycle se répète. Le programme correspondant est présenté dans l'extrait de code ci-dessous.
#--------------------------------------------------------------------------------------------#
# Example 3: Continuously ramp up and down the pumping rate.
# Starting at 300 mL/hr, the pumping rate will increment to 400 mL/hr in 20 mL/hr steps after every 0.5 mL has been dispensed.
# Then the pumping rate will decrement to 200 mL/hr in 20 mL/hr steps after every 0.5 mL has been dispensed.
# Finally, the pumping rate is incremented back to 300 mL/hr in 20 mL/hr steps after every 0.5 mL has been dispensed, then the process is repeated.
#--------------------------------------------------------------------------------------------#
# Initialize the pump with the specified COM port
pump = NewEraSyringePump('COM2') # Replace 'COM2' with the actual COM port used for the connection
# Reset pump
pump.reset_pump() # Reset the pump parameters
# Set syringe diameter
pump.set_diameter(26.59) # Change this value according to the syringe you're using
### BEGIN PUMPING PROGRAM ###
# Define initial variables
current_rate = 300 # Initial flow rate
increment = 20 # 20 mL/hr steps
dispensed_volume = 0.5 # volume to be dispensed before each rate ramp change
# Define the boundaries
lower_boundary = 200 # the minimum flow rate
upper_boundary = 400 # the maximum flow rate
# Continuously ramp up and down the pumping rate
while True:
# Ramp up the pumping rate
while current_rate upper_boundary:
current_rate = upper_boundary
# Ramp down the pumping rate
while current_rate > lower_boundary:
# Run pumping rate function for the defined volume and rate
pump.run_RATE_function(current_rate, "MH", dispense_volume, "ML", 0)
# Decrement the pumping rate
current_rate -= increment
# Check if the rate is below the lower boundary
if current_rate
Bien que la bibliothèque Python personnalisée constitue un outil précieux pour piloter le pousse-seringue NE-1000, il est primordial de prendre en compte la limite inhérente liée au temps de latence de la communication rs-232. Ce décalage observé provient du traitement des commandes par le pousse-seringue, entraînant un très court délai entre deux commandes consécutives.
Ce délai, bien que minime, peut induire de légers écarts sur les volumes délivrés. Cela se remarque particulièrement lorsque le programme de perfusion requiert des changements de débit rapides : en effet, comme le stipule la documentation du pousse-seringue, celui-ci doit être arrêté pour transmettre un nouveau débit. Elle précise que la nouvelle valeur de débit n'est enregistrée dans la mémoire non volatile que si le programme de perfusion n'est pas en cours d'exécution 🚧. Dans certains cas, cela peut perturber l'écoulement du fluide et altérer la précision de l'expérience.
Malgré les tentatives d'atténuer ce problème par un séquençage stratégique des commandes et des délais, le défi persiste, influençant la capacité de la pompe à maintenir des opérations de pompage continues et précises, en particulier dans les expériences microfluidiques sensibles au temps. À l'avenir, la résolution de ce problème de délai reste une priorité pour garantir des performances optimales de la pompe et des résultats expérimentaux précis.
Conclusion
Dans cet article de blog, nous avons exploré les fondamentaux du contrôle par communication rs-232 du pousse-seringue NE-1000 avec Python, abordant tous les aspects, de la configuration du port de communication à la programmation de séquences de perfusion sur mesure. Nous espérons que cet article constituera un guide précieux pour les chercheurs et ingénieurs désireux d'utiliser Python pour contrôler à distance leurs pousse-seringues New Era via le jeu de commandes rs-232.
Restez à l'écoute pour plus d'informations, de tutoriels et d'applications pratiques dans nos futurs articles. D'ici là, bon pompage et bon codage 💻!
📧 Si vous avez des questions ou des commentaires, n'hésitez pas à nous contacter à l'adresse support@darwin-microfluidics.com.


