Les pousse-seringues constituent des outils indispensables pour la délivrance précise de volumes de liquide. Parmi ceux-ci, le LSPone se distingue dans le monde de l'automatisation de laboratoire par ses performances exceptionnelles et sa polyvalence.
Dans cet article de blog, nous explorerons comment contrôler le pousse-seringue LSPone en utilisant Python et Matlab. De la compréhension de ses capacités à la fourniture d'instructions simples, étape par étape, pour la configuration des interfaces de communication et le contrôle de la pompe, cet article vise à autonomiser les chercheurs de tous niveaux. Que vous travailliez sur le contrôle de pompe pour la toute première fois ou que vous recherchiez des techniques avancées, ce guide vous permettra de maîtriser votre pousse-seringue LSPone.
TABLE DES MATIÈRES
Pourquoi choisir le pousse-seringue de laboratoire LSPone ?
Le pousse-seringue de laboratoire LSPone d'Advanced Microfluidics SA est une solution innovante pour le dosage de haute précision en recherche microfluidique, combinant un pompage de haute précision avec une valve rotative à faible volume. Couplé au logiciel LSPoneQuick, il peut aspirer ou distribuer des liquides, contrôler le débit et automatiser la manipulation des fluides.
Le LSPone se distingue par sa précision de dosage exceptionnelle et son débit quasi sans pulsation, répondant à divers besoins de manipulation de liquides, des millilitres aux nanolitres. Sa valve de sélection à volume mort nul facilite la gestion efficace de multiples fluides avec un report minimal, tandis que son interface user-friendly assure un fonctionnement sans effort, faisant du LSPone un choix parfait pour les expériences de laboratoire.
Les avantages clés du LSPone incluent ses volumes morts, internes et de report exceptionnels qui soulignent davantage sa supériorité. Sans volume mort, avec un volume de report limité à 1,5 µL et un volume interne de seulement 4 µL, réduit par le faible diamètre du canal de 0,5 mm, ce pousse-seringue offre une précision et un contrôle inégalés, permettant des changements rapides de fluide.
De plus, les chemins d'écoulement optimisés du LSPone, qui non seulement limitent la contamination mais maximisent également la nettoyabilité, garantissent une compatibilité biochimique impeccable. Son rapport de dilution élevé, facilité par un volume de report minimal, assure une dilution maximale avec le diluant, tandis que sa conception de valve unique expulse immédiatement l'air de la seringue et de la valve, permettant un amorçage sans bulles.
De quoi avez-vous besoin pour communiquer avec le LSPone ?
Pour communiquer avec la pousse-seringue de laboratoire LSPone, vous aurez besoin de quelques composants clés :
- Un pousse-seringue de laboratoire LSPone avec une seringue de votre choix,
- Un câble mini-USB/USB ou un connecteur DB9 (RS-232 ou RS-485 peuvent y être implémentés) permettant une communication série et 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 connecter le câble
- Le logiciel LSPoneQuick ou une plateforme de programmation (environnement Matlab ou Python avec le package PySerial qui encapsule l'accès au port série),
- Une compréhension de base du jeu de commandes LSPone détaillé dans le manuel d'utilisation de la pompe.
Comment configurer le port de communication ?
Avant de pouvoir commencer à contrôler votre pompe LSPone, il est essentiel de configurer le port de communication. Suivez ces étapes pour établir une connexion 🔧:
- Connecter le câble mini-usb/usb ou le connecteur DB9 au port série à l'arrière de la pompe et au port correspondant sur l'ordinateur.
- Allumez la pompe.
- 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.
- 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 9600 bits/s.
- Testez la connexion en envoyant une commande simple, telle que l'interrogation de l'état de la pompe.
Le jeu de commandes du LSPone
Le LSPone offre un éventail de commandes pour le contrôle externe, catégorisées en types distincts pour une manipulation précise. Celles-ci incluent des directives de contrôle, des invites d'initialisation, des réglages de valve, des mouvements de piston, des configurations de réglage et des fonctionnalités de rapport complètes. Chaque commande, à l'exception des requêtes et des directives spéciales commençant par "?" ou "!", nécessite l'ajout du marqueur [R] pour son exécution.
Il convient de noter qu'une fois une commande initiée, le système n'accepte pas de nouvelles commandes, à l'exception des interruptions ou des demandes de rapport. De plus, le système répond rapidement aux entrées de commande et signale les erreurs en cas d'entrées invalides au sein de la séquence de commande.
Le jeu de commandes du LSPone utilisé pour contrôler le pousse-seringue LSPone est résumé dans le tableau ci-dessous. Davantage de commandes sont détaillées dans le manuel d'utilisation de la pompe.
| Commande | Opérande | Description de l'opérande | Description de la commande |
|---|---|---|---|
| R | N/A | Exécuter la chaîne de commande | |
| X | N/A | Sans [R] de fin | Réexécuter la dernière chaîne de commande exécutée |
| G<n> | 0-60000 | 0 = Boucler indéfiniment | Répétez la séquence de commandes |
| g | N/A | Profondeur maximale de boucle = 10 | Marquer le début d'une séquence répétée |
| M<n> | 0-86400000 | Millisecondes | Retarder l'exécution de la commande |
| H | N/A | Sans [R] de fin | Commande d'arrêt |
| @POWEROFF | N/A | Arrêter la pompe | |
| Z<n> or Y<n> | (vide) ou 0-3 | (vide) ou 0 = force élevée, 1 = force normale, 2 = force moyenne, 3 = faible force | Initialiser le drive du piston et ramener la vanne à sa position d'origine |
| O<n> | 1-nombre max de positions de vanne (4, 6, 8, 10 ou 12) | Mouvement antihoraire du bouchon (vanne vue d'en haut) | Déplacer vers le port de la vanne |
| I<n> | 1-nombre max de positions de vanne (4, 6, 8, 10 ou 12) | Mouvement du bouchon dans le sens horaire (vanne vue de dessus) | Déplacer vers le port de la vanne |
| B<n> | 1-nombre max de positions de vanne (4, 6, 8, 10 ou 12) | Mouvement de bouchon le plus court (direction horaire préférée) | Déplacer vers le port de la vanne |
| A<n> | 0-3000 avec N=0 0-24000 avec N=1 | Position absolue | |
| P<n> | 0-3000 avec N=0 0-24000 avec N=1 | Prélèvement relatif | |
| D<n> | 0-3000 avec N=0 0-24000 avec N=1 | Distribution relative | |
| V<n> | 1-1600 | Vitesse de pointe (impulsions/sec) | Régler la vitesse de pointe |
| N<n> | 0-1 | <0> = microstep of 0.01 mm resolution <1> = microstep of 0.00125 mm resolution | Mise à l'échelle de la distribution/du prélèvement. Moteur toujours piloté en mode micropas |
Certaines commandes de rapport sont présentées dans le tableau ci-dessous tandis que l'ensemble détaillé des commandes de rapport peut être trouvé dans le manuel d'utilisation de la pompe. Ces commandes n'ont pas besoin d'un caractère [R] final.
| Commande | Description |
|---|---|
| Q | Statut actuel |
| ? | Position absolue du piston |
| ?2 | Vitesse maximale |
| ?4 | Position actuelle du piston |
| ?6 | Position de la valve |
| ?26 | Adresse de la pompe |
Exemples de commandes
- /1Z2R<CR>: Initialize the plunger drive with medium force and home the valve.
- /1V250R<CR>: Set the peak speed to 250 pulses/sec.
- /1I4P500M2000I8D500R<CR>: Move clockwise to valve port 4, trigger a pick-up move of 500 steps, delay the next command execution by 2 seconds, move clockwise to valve port 8 and execute a 500-step dispense.
- /1I2P1000B9gM1000D200G5R<CR>: Move clockwise to valve port 2, trigger a pick-up move of 1000 steps, move to valve port 9 with the shortest path then repeat the following 5 times: delay the command execution by 1 second before executing a 200-step dispense.
Comment contrôler la pompe LSPone en utilisant le logiciel LSPoneQuick ?
Le logiciel LSPoneQuick présente une interface graphique user-friendly conçue pour une navigation facile et efficace. Grâce à sa fonctionnalité d'enregistrement de macros, les utilisateurs peuvent créer des séquences automatisées personnalisées étape par étape, les revoir et les modifier facilement selon les besoins. La conception simple du logiciel permet un accès rapide aux fonctionnalités du LSPone, ce qui simplifie la gestion des tâches de la pompe.
Pour connecter la pompe au logiciel, suivez les instructions du mode "Auto" sur l'écran d'accueil ou passez en mode "Manuel" et sélectionnez un port série spécifique. Une fois connectée, la pompe est automatiquement initialisée et l'onglet d'accueil du logiciel s'affiche.
Le logiciel dispose de trois onglets distincts comme on peut le voir dans la capture d'écran ci-dessous : l'onglet d'accueil, l'onglet d'enregistrement de macro et l'onglet de paramètres.
Depuis l'onglet d'accueil, vous pouvez réinitialiser la pompe, l'arrêter, choisir la résolution de votre déplacement, choisir le volume que vous souhaitez prélever ou distribuer, régler la vitesse de la seringue, sélectionner le port de la valve, etc.
Dans l'onglet enregistrement de macro, vous pouvez voir la liste des commandes où toutes les actions effectuées dans l'onglet d'accueil sont automatiquement enregistrées, ce qui permet de contrôler le programme de pompage, de le répéter et de le sauvegarder pour de futures applications.
Depuis l'onglet des paramètres, vous pouvez saisir le port de communication, le module de valve et le volume de la seringue.
Plus de détails sur le logiciel LSPoneQuick peuvent être trouvés dans le guide de l'utilisateur du logiciel.
Comment contrôler la pompe LSPone en utilisant Python ?
Le LSPone peut également être contrôlé à distance via des plateformes de programmation telles que Python ou Matlab, ce qui offre une plus grande flexibilité et commodité, surtout si vous souhaitez exécuter en continu des programmes de pompage complexes avec des boucles, des pauses et des débits variables. Les plateformes de programmation présentent également un intérêt particulier lorsque différents appareils sont utilisés simultanément, car elles permettent l'automatisation de séquences impliquant tous les appareils.
Dans cette section, des extraits de code Python montrant comment ouvrir le port série, écrire et envoyer des chaînes de commande de contrôle à la pompe et écrire un programme de pompage pour le LSPone seront présentés. Nous examinerons des extraits de code qui démontrent comment effectuer des tâches courantes telles que le déplacement vers un port de valve spécifié, le prélèvement et la distribution de liquides, etc. Ces exemples fourniront une compréhension pratique du contrôle basé sur Python du pousse-seringue LSPone.
Tout d'abord, nous utiliserons la bibliothèque Python AMF Tools, conçue spécifiquement pour contrôler les produits AMF tels que le LSPone. De plus, nous démontrerons comment créer une bibliothèque Python personnalisée dédiée aux commandes du LSPone.
Bibliothèque Python AMF Tools
Advanced Microfluidics (AMF) a introduit une bibliothèque Python dédiée au contrôle de leurs instruments, y compris le RVM, le SPM et le LSPone. Pour installer et utiliser le package AMFTools, on peut exécuter la commande suivante dans la console Python :
pip install AMFTools
La bibliothèque fournit un ensemble structuré de commandes utilisées pour interagir avec les dispositifs AMF. Ces commandes englobent des opérations essentielles allant de l'établissement de connexions à l'exécution de mouvements et d'ajustements précis. Elles sont regroupées comme suit :
- Méthodes Générales : telles que l'établissement et la terminaison des connexions, l'envoi de commandes et la réception de réponses de l'appareil.
- Fonctions de réglage : fonctions dédiées à la configuration de divers paramètres du dispositif AMF, y compris l'adresse, la taille de la seringue, le mode de réponse, le numéro de port, la vitesse, l'accélération, et plus encore.
- Fonctions de récupération : fonctions qui facilitent la récupération d'informations sur l'état de l'appareil, sa configuration, la version du firmware, la position de la vanne, la position du piston et d'autres paramètres pertinents.
- Fonctions d'Action Globales : incluant des actions telles que la vérification de l'état de la vanne et de la pompe, le déplacement de la vanne vers le port cible, la réinitialisation de l'appareil et son extinction.
- Fonctions d'action de la pompe : Ciblant spécifiquement les opérations liées à la pompe, cette catégorie comprend des fonctions de positionnement absolu et relatif, de contrôle du volume, de prélèvement et de distribution.
Pour plus de détails concernant la liste complète des fonctions, ainsi que leurs explications respectives, veuillez vous référer à la page AMF Tools sur le Python Package Index.
Vous trouverez ci-dessous un exemple de fragment de code pratique démontrant comment utiliser la bibliothèque Python AMF Tools pour construire un programme de pompage qui reproduit les actions présentées dans la vidéo (pousse-seringue de laboratoire LSPone de la page YouTube d'Advanced Microfluidics SA) : initialisation (amorçage/purge d'air) d'un pousse-seringue LSPone avec une valve de distribution intégrée comportant 6 ports, chacun utilisable en entrée ou en sortie.
'''
----------------------------------------------------------------------------
Initialisation (priming/air purge) of an LSPone syringe pump with an integrated distribution valve with 6 ports each usable as input or output
----------------------------------------------------------------------------
'''
# Import the required module or class
from amfTools import AMF
#--------------------------------------#
# Establish a connection with the pump #
#--------------------------------------#
# Specify the serial port, the baud rate and the number of valve ports
serial_port = 'COM4' # change this according to your COM port
baud_rate = 9600
valve_ports = 6 # adjust the number of valve ports to the number you have
# Initialize the LSPone, create an instance of the AMFDevice class
LSPone = AMF(serial_port, baud_rate, valve_ports)
# Connect to the device
connected = LSPone.connect()
# Check if the connection is successful and print the appropriate message
if connected:
print("Connection successful!")
else:
print("Failed to connect.")
# Home the device, ensuring it is in a known state
LSPone.home()
#-----------------------------#
# Start the priming procedure #
#-----------------------------#
# Liquid picked-up from port 2 then expelled in port 6 used as an output. Pickup and dispense repeated a second time. Air totally removed after first priming. Same procedure applied for inputs 3, 4 and 5 for a bubble-free priming.
# Define the ports to be used as inputs in this pumping program
ports = [2, 3, 4, 5]
# Iterate through each port in the list
for port in ports:
# Perform pumping action twice for each port
for _ in range(2):
# Move to the specified input port with the shortest path
LSPone.valveShortestPath(port)
# Pickup 100 µL of the liquid knowing that the syringe size is 500 µL
LSPone.pumpPickupVolume(100,500)
# Move to port 6 with the shortest path
LSPone.valveShortestPath(6)
# Dispense the previously picked-up volume
LSPone.pumpDispenseVolume(100,500)
Comment communiquer avec le LSPone en utilisant la bibliothèque Pyserial ?
Dans cette partie, nous explorons comment communiquer avec la pompe LSPone, en utilisant la librairie PySerial utilisée pour accéder et contrôler les ports séries, fournissant une interface pratique pour envoyer et recevoir des données vers et depuis des appareils séries.
L'extrait de code fourni démontre comment envoyer des commandes à la pompe LSPone, avec plusieurs exemples (ceux présentés juste ci-dessus) incluant l'initialisation de la pompe, la définition de paramètres tels que la vitesse de pointe, et l'exécution de séquences d'actions complexes. Chaque commande est envoyée en utilisant la fonction de méthode `send_command`.
'''
--------------------------------------------------
Writing/Reading Single Commands to/from the LSPone
--------------------------------------------------
'''
import serial
import time
class AMF:
# Initializing the object and establishing a serial connection with the corresponding data format
def __init__(self, COM):
self.COM = COM
self.ser = serial.Serial(COM, baudrate=9600, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS)
# Send a command to the device
def send_command(self, command, with_trailing_R=True):
# Wait for any previous response to clear
time.sleep(0.05)
self.ser.read_all()
command_str = f'/1{command}'
# Append 'R' to the command if specified
if with_trailing_R:
command_str += 'R'
# Append '\r' (carriage return) to the command
command_str += '\r'
# Write the command to the serial port
self.ser.write(command_str.encode())
time.sleep(0.05)
#------------------------------------------------#
# To execute a command with a trailing 'R': #
# send_command("command") #
# #
# To execute a command without a trailing 'R': #
# send_command("command", with_trailing_R=False) #
#------------------------------------------------#
# Get a response from the device
def get_response(self):
response = self.ser.readline().decode().strip()
return response
#----------------------------------------------#
# Examples on how to send commands to the pump #
#----------------------------------------------#
# Initialize the pump (12 port valve) with the specified COM port
LSPone = AMF('COM4')
# Initialize the plunger drive with medium force and home the valve
LSPone.send_command('Z2')
# Set the peak speed to 250 pulses/sec
LSPone.send_command('V250')
# Move clockwise to valve port 4, trigger a pick-up move of 500 steps, delay the next command execution by 2 seconds, move clockwise to valve port 8 and execute the 500-step dispense
LSPone.send_command('I4P500M2000I8D500')
# Move clockwise to valve port 2, trigger a pick-up move of 1000 steps, move to valve port 9 with the shortest path then repeat the following 5 times: delay the command execution by 1 second before executing a 200-step dispense
LSPone.send_command('I2P1000B9gM1000D200G5')
# Verify the valve port position
LSPone.send_command('?6', with_trailing_R=False)
LSPone.get_response()
Comment contrôler la pompe LSPone en utilisant Matlab ?
Dans cette section, un extrait de code Matlab sera présenté, montrant comment ouvrir le port série, écrire et envoyer des chaînes de commande de contrôle à la pompe. Pour cela, une classe d'adaptateur de démarrage rapide est définie, dédiée aux commandes du LSPone.
Nous allons parcourir des lignes de code qui démontrent comment effectuer des tâches courantes telles que le déplacement vers un port de valve spécifié, le prélèvement et la distribution de liquides, etc.
classdef LSPone
properties
COM
ser
end
methods
% Initializing the object and establishing a serial connection
function obj = LSPone(COM)
obj.COM = COM;
obj.ser = serialport(obj.COM, 9600, 'Parity', 'none', 'StopBits', 1, 'DataBits', 8);
end
% Closing the serial connection and deleting the object
function delete(obj)
delete(obj.ser);
obj.ser = [];
end
% Sending a command to the device
function send_command(obj, command, with_trailing_R)
% make with_trailing_R true by default
if nargin 1600
error('Speed must be a positive integer smaller than 1600.');
end
obj.send_command(['V', num2str(speed)]);
end
% Get the valve position
function valve_position = get_valve_position(obj)
obj.send_command('?6',false);
valve_position = obj.get_response();
end
end
end
%----------------------------------------------------------------%
% Examples on how to use the defined class to control the LSPone %
%----------------------------------------------------------------%
% Connect the pump
% pump = LSPone('COM4');
% Initialize the plunger drive with medium force and home the valve
% pump.initialize_plunger(2);
% Move to port 4 with shortest path
% pump.move_shortest(4);
% Trigger a pick-up move of 1000 steps
% pump.relative_pickup(1000);
% Verify the valve port position
% pump.get_valve_position();
% Execute a 400-step dispense
% pump.relative_dispense(400);
% Move clockwise to valve port 2, trigger a pick-up move of 1000 steps, move to valve port 9 with the shortest path then repeat the following 5 times: delay the command execution by 1 second before executing a 200-step dispense
% pump.send_command('I2P1000B9gM1000D200G5');
% Disconnect and delete device
% delete(pump);
Conclusion
Dans cet article de blog, nous avons présenté le pousse-seringue de laboratoire LSPone et exploré les bases de son contrôle externe via deux plateformes de programmation, Python et Matlab, en utilisant le jeu de commandes de communication LSPone. Nous espérons que cet article servira de guide précieux pour les chercheurs et les ingénieurs cherchant à employer le pousse-seringue de laboratoire LSPone dans leurs recherches et expériences microfluidiques.
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.

