The first step is to find suitable components for the controller. As mentioned in the project description, we need to control pressure sources, regulate them at least moderately precisely, and be able to switch pressure on and off to many different tubes (~20-30 for our particular chips).
In case you are not familiar with microfluidics, here is a quick summary to provide a little context for this project.
The microfluidic chips we use are made of PDMS (polydimethylsiloxane, a transparent and flexible polymer). The way we create channels (through which we flow water, cells, and so on) in the chips is by "soft lithography" a.k.a. replica molding: the PDMS, which is a viscous liquid similar to epoxy when uncured, is poured onto a negative mold and allowed to cure in place. After this, the PDMS is peeled off of the mold and the chip is assembled: we use two layers of PDMS bonded to a glass substrate.
The channels are on the order of tens of microns wide and tall; and to get fluids onto the chip, we punch holes in the PDMS and connect thin tubing to them. This is our chip-to-lab interface: it is to these tubes that we need to apply pressure to push stuff around on the chip, and open and close elastomeric valves on the chip.
In the rest of this post, I will give an overview of the main components needed for the control system.
This is actually the second version of the system: version 0.1, as it was named, was based on an Arduino Mega and used mostly components that were already available in the lab.
For version 1.0, I wanted to start from scratch and not necessarily use any of the same components, but first search around for the best options first. After much research, It turned out that the components I had experience with were the best and cheapest ones available, so I ended up using very similar parts for version 0.1 and 1.0.. except I now have a list of alternatives, which I'll happily share if anyone is interested.
To switch pressure on and off to all these tubes, we need 3-way solenoid valves. 3-way means that air goes from the input to the output when open, and from the output to a vent when closed. This is necessary to release the pressure when we close the valve, since the downstream tubes and channels are either very thin or completely closed on one end; a two-way valve would shut off the input, but not allow the downstream tubes and channels to return to atmospheric pressure rapidly.
Most if not all solenoid valves suitable for this application are controlled simply by supplying power to them: they have a positive and negative lead, and applying 12V closes the valve. Some fancy valve assemblies have some sort of serial communication, requiring just a few wires to control many valves, but these are more rare (and expensive).
The valves used for this project are made by Pneumadyne. There are many variations in voltages, connector types, sizes and so on. I went with 12VDC version with flying leads (i.e. wires rather than a more expensive connector). The valves are mounted on manifolds, with up to 8 valves per manifold.
Pumps are probably the easiest components to find. We just need pumps that are able to supply relatively high pressures (upwards of 20 PSI (138kPa)), and, in the interest of integration, be small and easily powered.
I chose Parker diaphragm pumps, largely because I've used similar ones before and know that they will do the job fine, but mostly because I couldn't find comparable ones (in terms of maximum pressure, and size) for cheaper.
Ideally, I would have a do-it-myself solution for pressure control: buy some cheap sensors from Digikey, some solenoid valves, and have a microcontroller monitor the sensors and open/close the valves to maintain a given setpoint.
However, I have not had the luxury to experiment with this, and so I had to use commercially-available pressure regulators.
There are basically two options here: ProportionAir and Parker. I chose the latter mainly because they are smaller, and again, I had used some of these previously.
The interface for these controllers is rather straightforward: set an analog voltage between 0 and 5V on one pin to indicate the pressure setpoint, and read an analog voltage on another pin to know the current measured pressure. For example, a regulator with a range of 0-50 PSI will output 1V if it measures a pressure of 10 PSI.
Let's summarize the requirements for the microcontroller. Basically, we need:
- 34 digital outputs (for 32 solenoid valves + 2 pumps)
- 3 analog outputs
- 3 analog inputs
As mentioned above, version 0.1 used an Arduino Mega 2560. This was useful because it had many I/O pins, and being an Arduino, it was easy to program and widely documented. For this version, I wanted something a little more modern, possibly faster and with more memory, but most of all I wanted bluetooth, to make it easier to support a tablet-based user interface.
No popular, cheap microcontroller included all of these features, but I narrowed my selection down to two options: the Teensy 3.6, and the ESP32. These are roughly equivalent in terms of performance, number of ADC and DAC channels, etc.
The main advantage of the Teensy for this application is that it has *many* I/O pins (around 60); the main advantages of the ESP32 are the built-in bluetooth and the lower cost (~15$ for an ESP32 development board vs 30$ for the Teensy).
Ultimately I decided it was cheaper and easier to add I/O than to add Bluetooth, so I went for the ESP32.
The next log will detail the electronic components: how the microcontroller interfaces with the pumps, pressure regulators and solenoid valves.
Become a Hackaday.io Member
Create an account to leave a comment. Already have an account? Log In.