The Daisy Piston is a state-of-the-art displacement pump designed to provide exceptionally precise and efficient fluid dispensing. It works by moving a cylindrical shaft within the pump head space — similar to a syringe pump. Valve timing at the ports controls which way the fluid moves during aspiration and dispensing cycles.
Unlike a syringe pump, however, this piston pump does not use an elastic sealing material at the top of the piston, which dramatically reduces wear and tear, extending its lifetime over two orders of magnitude over that of a syringe pump. In fact, the Daisy Piston is designed to operate for up to 10 million dispensing cycles.
With 0.5% accuracy and <0.03% CV at full dispense volume, the Daisy Piston is our most accurate and precise pump model. It is suitable for automated pipetting and dispensing applications that require repeated and long-term precision. It can also be used in microfluidic flow control applications where precise control and stability over flow velocity is required — even in dynamically changing flow resistance or fluid viscosity conditions.
The Daisy Piston head is rated for 500 psi pressure before leakage. From vacuum up to 30 psi operation, we recommend using the integrated solenoid valves on either side of the pump head to control the aspirating and dispensing cycles. You can also use solenoid blocks such as the Daisy Sol Val modules. For pressures between 30-150 psi, we suggest using the Daisy Multi Valve modules.
Experience the power and precision of the Daisy Piston Pump and take your fluid dispensing to the next level. Trust in its accuracy and efficiency to meet your needs with ease.
Customizations
If you need a different pump head and piston material for your specialized application, contact us with your request.
Maintenance
The easiest way to take care of your Daisy Piston pump is to flush it with plenty of DI water after each use. Letting the pump go through its aspirate-dispense cycle at its full capacity 10 to 20 times should be sufficient. The goal is to wash away any residual solutions containing salt, as salt crystals remaining behind after aqueous buffers dry out will otherwise wear out the internal moving parts over time.
If organic materials were used with the Daisy Piston pump, flushing it 10-20x with ethanol first (followed by DI water) is a good idea.
After cleaning flushes, DI water may be left inside the pump for short-term storage.
Avoid using suspensions with solid particles in them with the Daisy Piston pump. Solid particles, just like salt crystals, can cause mechanical damage to the pump internals during operation over time, reducing its lifetime and performance.
Command Set
As usual, start your automation scripts with the interface set up. Assuming the piston pump is the first instrument in the first group:
piston_pump = self.my_interface.groups[0].inst[0]
The next step is to home the piston pump:
piston_pump.home()
This command by default waits for the finish of the homing action, during which the piston pushes up to its maximum stroke.
Finally, the run command controls both the piston position and the valves (as needed). Command format is:
piston_pump.run(<Piston speed in ul/min>, <target volume in ul>, <valve # 0|1>, <wait flag>)
For instance, the following command aspirates 1000.0 ul of fluid into the pump through valve 0 (priming valve P, connected to the lower side port on the pump head), and the script waits until the aspiration action is complete:
piston_pump.run(20000.0, 1000.0, 0, wait=True)
If we wish to pump all 1000.0 ul of fluid through the dispensing valve (valve 1, connected to the top port of the pump head), our command will be:
piston_pump.run(20000.0, 0.0, 1, wait=True)
Application Example 1: Microfluidic Flow Control
Putting it all together, here is a script segment that controls two piston pumps at different rates for a microfluidic droplet generation or mixing application:
g1 = self.my_interface.groups[0]
piston_pump_1 = g1.inst[0] # first Daisy Piston
piston_pump_2 = g1.inst[1] # second Daisy Piston in the chain
# Start by homing the pumps
piston_pump_1.home() # waits automatically to finish
piston_pump_2.home() # waits automatically to finish
# First, aspirate. Assuming 100 ul capacity piston pumps
aspiration_volume_1 = 50 # ul
aspiration_volume_2 = 100 # ul
piston_pump_1.run(1000, aspiration_volume_1, 0, False) # aspirate 50 ul; don't wait
piston_pump_2.run(1000, aspiration_volume_2, 0, True) # aspirate 100 ul; wait to finish (takes 100/1000 mins = 6 seconds)
for i in range(20): # repeat 20 times (5x20 = 100 mins, plus 20 aspirations)
piston_pump_1.run(10, 0, 1, wait=False) # pump all 50 ul at 10 ul/min (5 min)
piston_pump_2.run(20, 0, 1, wait=True) # pump all 100 ul at 20 ul/min (5 min)
Application Example 2: Sequential Droplet Dispensing
The script segment below defines the piston pump interface, homes it, then runs a loop to aspirate 640.0 ul of fluid into the pump, and dispenses 10 ul drops. This pump could be used together with a Daisy Gantry instrument to dispense drops into a 96 well plate. In that case, each dispensing could be sandwiched between the gantry moving a different microwell under the dispensing tip.
g1 = self.my_interface.groups[0]
piston_pump = g1.inst[0] # first instrument in the chain is the Daisy Piston
gantry = g1.inst[1] # second instrument in the chain is Daisy Gantry
# Start by homing the pump and the gantry
piston_pump.home() # waits automatically to finish
gantry.home() # waits automatically to finish homing
# Then, aspirate 1000 ul
pump_capacity = 1000; # ul
aspiration_volume = 640
pull_volume = min(aspiration_volume, pump_capacity) # just for safety
piston_pump.run(12000, pull_volume, 0, True) # aspirate 640 ul into the pump at 12 ml/min
# Determine target positions for the gantry carriage
X_Pos = [50, 60, 70, 80, 90, 100, 110, 120]
Y_Pos = [100, 110, 120, 130, 140, 150, 160, 170]
# Then, dispense in 10 ul increments
dispense_increment = 10
target_volume_location = pull_volume
for X in X_Pos:
for Y in Y_Pos:
# First, move gantry carriage to desired position
gantry.run(X, Y, wait=True)
# Then determine how much volume to dispense
target_volume_location -= dispense_increment
piston_pump.run(12000, target_volume_location, 1, True)
