Team:BostonU HW/Attributions


Neptune abstracts a very intricate workflow to provide an intuitive experience for its user. Below is a detailed depiction of all of the components that are under Neptune's hood.

Each of BostonU Hardware Team's members played an integral part in the success of Neptune's development.

Liquid Flow Relations & User Constraints File | Shane McCormack
In order to increase accessibility of our tool (and microfluidics in general), a method for describing microfluidics in a few simple lines was formed! This standard consists of Liquid Flow Relations (or LFR), and the User Constraints File (or UCF). The LFR file is where the user describes the inputs, outputs, and tells of any operations which occur on those inputs and outputs. These operations are described as symbols on the LFR, but are informed by the UCF. The few lines of LFR are the only things needed to run a chip through Neptune; a sample UCF is provided with Neptune that can be fine-tuned, but will not need to be written in its entirety.

The UCF can be thought of as a library of microfluidic components where, once a component is defined, it will never have to be written again! In more detail, once a component is defined inside the UCF, all subsequent LFR files can utilize the symbol the component is linked to without redefining the details of the component. The UCF leverages the MINT standard of describing parametric microfluidics. This parametrization unlocks great potential in the rapid prototyping of designs, where one number can be changed in the UCF, and all subsequent designs will have the updated component! For example, if our fictional synthetic biologist Dr. Ali found that his mixer's bends were too short in length, with one number edit in the UCF he could fix every bend of every mixer in all of his designs thereafter! This is far more accessible than redrawing every bend by hand on AutoCAD.

μShroom Mapper | Shane McCormack
With the new facilitated design method of Liquid Flow Relations, a behind-the-scenes software tool was needed to interpret and translate the LFR and UCF into a functional MINT file. This task is fulfilled with muShroomMapper; muShroomMapper takes LFR and UCF as inputs, maps the LFR into a graph with the support of NetSynth, then informs that graph with the UCF. The informed graph is then translated into a MINT file, to be placed and routed to a blueprint for fabrication.

μShroom Mapper-Neptune Integration | Kestas Subacius & Shane McCormack
Liquid Flow Relation files and User Constraint Files greatly simplify the microfluidic design process. With the implementation of the LFR and UCF file types also came the development of uShroom Mapper, an algorithm that takes LFR and UCF file inputs and converts them into MINT file types. These file types and tools by themselves are incredibly useful, enabling researchers to specify more complex designs with greater ease. Unfortunately, alone these tools would be cumbersome and difficult to use for an inexperienced programmer.

Therefore we integrated the LFR and UCF file types into Neptune, and we integrated the uShroom Mapper algorithm into Neptune's backend libraries. To make these tools easy to use, we developed a sleek, simple and appealing user interface where LFR and UCF files can be edited and then sent to uShroom mapper for conversion to MINT. We also integrated a front end terminal that provides compilation feedback and throws errors when design rules are violated. All this to speak, we integrated uShroom Mapper with Neptune by sculpting a clean user interface that makes the design simple and efficient.

Fluigi-Neptune Integration | Kestas Subacius & Shane McCormack
After uShroom Mapper outputs a MINT specification of a microfluidic chip, designers can modify this file type to do fine-tuning and optimization of their design. A microfluidic designer can also opt to skip specification at the LFR level, and they can go right into designing a MINT file. This being said, MINT files are not the end of the pipeline, and this filetype must be converted to a microfluidic design schematic that can be used for fabrication.

Fluigi is a powerful algorithm that takes a MINT description of a microfluidic chip, and from this description it outputs a microfluidic chip design. This tool is analogous to a place and route tool for a circuit schematic, allowing for complicated designs to be specified and then realized. Fluigi takes in a MINT specification, and outputs design schematics in the form of SVG’s for CNC mill fabrication, and EPS files for photolithography.

We integrated the MINT file type, along with the Fluigi compiler into Neptune. As a standalone tool Fluigi can be pretty daunting to navigate, requiring shell scripting experience and a solid software background. We eliminated all difficulty from Fluigi by integrating Neptune as a user interface for Fluigi. Users can compile their MINT files through Neptune, and Fluigi will in turn provide the designer feedback in a console. Design errors and design status is all fed back to Neptune. All in all, we integrated Fluigi with Neptune, providing a robust and easy to use UI for editing and compiling MINT files.

Choosing Mechanical System | Zach Lasiuk
Analyzed the pitfalls and advantages of both the rack and pinion system as well as the piston rod system. In order to properly choose a system for Neptune, the overall goals of Neptune were called to mind: Low cost, easy to use, and modular. With these design goals in mind, the piston rod system was ultimately chosen to ensure accuracy, modularity, and the ability to dispense very small to very large amounts of liquid with a feedback control active.

Designing Electrical System | Zach Lasiuk
Focusing in on the overall goals of Neptune’s hardware (low cost, easy to use, and modular), the Arduino Mega was chosen to control Neptune’s hardware. Because Neptune is inherently modular to change with synthetic biologists needs, Neptune’s electronic control circuitry must be equally as modular and scalable. The electronic system is comprised of power inputs, stackable Arduino motor controller shields, an Arduino Mega, and various headers and capacitors to make the system respond appropriately.

Mapping Mechanical Motion & Constant Flow Rate Equation | Zach Lasiuk
In order to accurately control Neptune’s hardware, the mechanical motion of the servo and syringe paring must be completely defined. Therefore, the equation for off-center piston-rod motion was derived. An inherent characteristic of the piston rod mechanical system is a non-linear response from the syringe pump being controlled. Based on where the servo arm is in its circular path of motion, the syringe pump will move different amounts with the same change in theta of the servo arm. This problem was overcome by developing an algorithm to ensure a constant flow rate is always achieved with Neptune given the specific values of the active servo and syringe, involving two lookup tables and linear extrapolation.

Modular Baseboard Implementation | Zach Lasiuk
The challenge of Neptune’s baseboard is to utilize a desktop CNC mill to achieve the functionality of a full machine shop. More specifically, Neptune’s baseboard must retain system expandability to arbitrary dimensions and maintain ease of use by providing places to auto-align components. This is done using an emerging standard in microfluidic hardware, the MEC board, developed by the GroverLab at University of California, Riverside. By creating these modular MEC squares that can be milled out one at a time and connected together. Neptune’s board can use a multitude of materials and even a combination of materials, currently tested with HDPE plastic, ABS plastic, and wood.

Created Parametric 3D Parts | Zach Lasiuk & Priya Kapadia
To ensure Neptune meets the requirements of any microfluidic experiment with different requirements for flow-rate and max volume to be dispensed, Neptune has completely parametric 3D parts. These parts hold and align the servo and syringe combination and enable the fluid motion of both. From 100mL to 10uL, Neptune’s 3D printed hardware will adjust in shape to accommodate different size syringes and servos to meet synthetic biologist’s experimental needs. While Neptune has tested servos and syringes on file to choose from by default, should a biologist need more volume to dispense or more precision in flow-rates they can input their own servo or syringe to obtain the exact response they desire. The final result is completely parametric 3D parts that adapt to a specific servo or syringe’s dimensions, enabling a massive amount of freedom for synthetic biologists in using Neptune.

Developed System Firmware | Zach Lasiuk
Reliability and repeatability of experiments are essential for Neptune to deliver results. The firmware developed for the Arduino Mega ensures these standards are met and maintained. Currently implemented, this firmware has the capability to work with both digital and analog servos, up to 13 servo shields stacked on top of the Arduino Mega (enabling the control of over 200 servos at once), control valves with instant motion, and control dispensers with variable flow-rates. In addition to working seamlessly with Neptune’s control page, there is another option to use the Arduino IDE should the need arise, retaining the ability to control both valves and dispensers.

Neptune's Specify Page | Kestas Subacius
Neptune’s “Specify” page is an integrated development environment for microfluidic chips designed through LFR. The “Specify” page was designed to encompass all parts of microfluidic design specification using LFR and UCF files, and this page is integrated with the uShroom mapper tool to convert designs to a MINT elaboration. In this IDE, users can define a microfluidic chip with specific inputs, outputs, and functionality. Designers can also define microfluidic chip parameters such as gradient generators, serpentine mixers and cell traps here. The Specify IDE provides a terminal for interfacing with uShroom mapper, and an editor for writing and editing files. This editor also provides syntax highlighting for LFR and UCF files, and error checking for improperly created files. Also, the Specify IDE has a user interface element for creating new microfluidic operators, making it very easy for designers to add new parts to their chip.

Neptune's Design Page | Kestas Subacius
Neptunes “Design” page is an integrated development environment for microfluidic chips designed through MINT. The “Design” page was created to encompass all the subtleties of elaborating a microfluidic chip using MINT files and configuration files. In this IDE, users can edit the fine aspects of their chip. A developer in this IDE has control over the sizing of each channel, port, valve and primitive in their design. Here users can also modify parameters related to how Fluigi compiles and outputs a design schematic. Parameters like chip dimensions are also defined in this section. The “Design” page also provides a visual preview the microfluidic design generated, allowing designers to see their chip layout as they modify their device. Design schematics generated on the “Design” page are immediately integrated with the build, assembly, and control sections of Neptune, allowing for clean navigation through the workflow.

Neptune's Workspaces | Kestas Subacius
Neptune was designed to be a easy-to-use desktop application. To this end, a file system had to be developed for Neptune that would allow for designers to store their designs locally on their computer, and to modify these designs through Neptune. Neptune was implemented like many other IDE’s, where designers can select workspaces on their computer, and any modifications they make to their designs happen locally. More importantly, these workspaces and this filesystem was implemented such that it will be expanded for cloud services in the future.

Neptune's Build & Assembly Pages | Priya Kapadia
After the user has designed the microfluidic chip, they can then move on to select hardware components to match their needs. They would need to first input the volume of liquid they would like to dispense, and the precision they require. Neptune would then search through its database of servos and syringes to recommend hardware combinations to the user based on complex calculations involving torque, the range of pulse-width modulations, the bandwidth-delay product, and so on. Consequently, users are provided with a large personalized list of items that they can choose from. The user can then map the hardware to the dispensers on the chip that they just designed. The mapping allows Neptune to calibrate the dispensers for the experiment. The user is then provided with an ordering list consisting of all the parts that they need for the experiment. The ordering list would include the new hardware that the user has just selected, some predetermined items such as a roll of 3D printing support, and also some variable items like the number of 6-32 screws for instance. These would be calculated using the user's choices and the chip at hand.

To ease the usage and to help the user put all the pieces together, Neptune's Assembly Page takes the user through a step by step process where they can make and connect all the pieces required to control the microfluidic device. Currently, the users can download all the file required to 3D print the infrastructure of the hardware we suggest to them in the Build page. However, moving forward, both the Build and Assembly page would allow for the user to input their own servo and syringe combination into Neptune. The ability for the user to create custom 3D printing files are currently in development. Aside from that, the Assembly page includes descriptions on how to create the infrastructure, mill out the microfluidic chip, connect the Arduino to the hardware, and set up the system for control.

Neptune's Control Page | Becca Wolf
Once users have milled out their microfluidic chip and assembled the supporting control infrastructure, he or she can control the valves and dispensers of their device through Neptune’s Control user interface. This interface displays a visual of their chip with controls to open or close valves, set a dispense rate for any given dispenser, or increment the dispensed liquid volume one unit of resolution at a time with only the click of a button. Through this page, a user may change the preset specs of each servo-syringe combination if he or she decides to change their setup. The control feature may be used to control any device using hardware formatted for use in Neptune regardless of the current project being designed to enable quick control adaption to different project environments. It is also through the control page that the user will establish connection to the arduino so that commands may be sent to pumps to operate valves and dispensers.

3DuF Integration | Becca Wolf
3DuF is a microfluidic design CAD tool which is part of a project led by Josh Lippai (see mentor section below for further details). We decided to leverage the JSON visualization features which 3DuF has to offer in Neptune to display a visual of the user’s chip for intuitive interaction with valves and dispensers on their microfluidic device in Neptune’s Control user interface. 3DuF is integrated into Neptune’s front end operation to this end. 3DuF’s version upkeep within Neptune is designed to handle the primitive features which are used in chip design bu Fluigi (see mentor section below) outputs.

Neptune-Arduino Integration | Johan Ospina & Becca Wolf
Neptune can be used to operate the valves and dispensers of a microfluidic chip through an Arduino Mega. In order to be able to send commands to the arduino to be interpreted and acted upon by firmware, Neptune opens a serial communication connection with the port the arduino is connected to. This is done quite simply by the user through the Control page and is as simple as selecting the port and pushing the “Connect” button. Neptune will then send commands specified by the user in the Control page to the arduino through UART.

Firmware-Neptune Integration | Zach Lasiuk & Becca Wolf
The way in which Neptune communicates to the Arduino Mega which powers the control of the microfluidic chip is standardized throughout the Neptune UI-firmware interaction. Commands are sent to the arduino through the Neptune Control page in the form of an 8-digit code where the first 4 digits indicate the index of the pin on the arduino which the servo-syringe combination is connected to, and the last 4 digits indicate a PWM value which indicates the position which the servo should rotate to.

Even Fluid Dispension-Neptune Integration | Zach Lasiuk & Becca Wolf
Integrated conversion of a set volume to dispense over time for dispensers in Neptune’s microfluidic devices are integrated into Neptune’s Software. A table of PWM and uL values at even intervals of fluid dispensing are generated and stored for each servo-syringe combination within Neptune to be used by the front end of the system to send dispense commands to the arduino. This can be done by the user through the Control page in an intuitive, pictorial way.

Neptune Packaging | Priya Kapadia
After creating Neptune as a web-application, the hardware team thought of packaging the entire application into a desktop application that the biologist could download onto his local computer. This would enable the user to use Neptune offline, making it more convenient. To do so, a packaging tool called Electron was introduced to host Neptune. This is under development, and moving forward, Neptune may become a desktop application that biologists can use anywhere and anytime.

Microfluidic Chip Prototyping | Shane McCormack
In order to ensure our design, build, and control workflow was functioning properly, we took designs through the Neptune workflow and tested them with mock experiments using colored water, or by collaborating with other iGEM teams to test biology inside our accessible microfluidic platform (checkout our collaborations page for more details on biology inside our systems!)

We stand on the shoulders of giants.
Our work would not have been possible without the foundations laid by our mentors. Neptune’s microfluidic design and fabrication tool leverages projects such as Fluigi Place and Route, Mint description language, MakerFluidics, and 3DuF in order to provide the most intuitive and cohesive experience for users. These projects have been built and expanded on by our graduate student mentors. We would like to thank our mentors for all of the work they have done to allow us to bring Neptune to life.
Fluigi | Radhakrishna Sanka
A place and route tool for microfluidic devices. Fluigi takes a MINT file as input and strategically routes the features specified in the MINT into an optimized microfluidic design. Fluigi outputs the design in a series of visual formats: SVG files (which can be used to mill out the different layers of the microfluidic chip using a CNC mill), a JSON file (which can be used to visualize the microfluidic design with 3DuF), and EPS files (which can be used to build the chip using photolithography if the user so chooses).

MINT | Radhakrishna Sanka
A microfluidic description language generated as an output of MuShroom mapper and used as an input to Fluigi. This language is used to describe the features of the specified microfluidic device in great detail including specification of feature shape, size and spacing.

Netsynth | Prashant Vaidyanathan
Netsynth is a software tool that was originally built by Prashant Vaidyanathan to translate Verilog logic descriptions into wire and gate lists. Netsynth has been modified for use in Neptune through a collaboration between Shane McCormack (BostonU_HW Team member) and Vaidyanathan to produce output formatted for interpretation in the context of microfluidic design. MuShroom mapper (a tool build by McCormack) uses this output alongside a variety of other inputs to produce a MINT file output in the Specify stage of Neptune.

3DuF | Joshua Lippai
A CAD-like drawing web application. 3DuF can be used to manually draw a microfluidic design if the user wishes to bypass high-level specifications. 3DuF will then output SVG files (for CNC milling layers of the microfluidic chip) and a JSON file for later visualization and editing purposes. When used in the context of Neptune, 3DuF is leveraged to visualize the JSON output of Fluigi so that the user may control his or her microfluidic device intuitively through the Neptune interface.

MakerFluidics | Ryan Silva
MakerFluidics is an accessible, inexpensive microfluidic fabrication technique used to manufacture microfluidic chips. A user will use an SVG file to mill out both the control and flow layers of a microfluidic chip. Then he or she will use these 2 layers to sandwich a piece of PDMS and vacuum the chip to create a seal. Through Neptune, the user is encouraged to use this fabrication infrastructure to make their chip so that they may rapidly prototype many chips inexpensively for any iterations of their experiment and easily control their microfluidic system through the Neptune interface.

Microfluidic Application | Ali Lashkaripour
Explorations into the biological applications for Neptune’s workflow are spearheaded by Ali Lashkaripour. He designs and tests features to be added to our UCF repo as relevant primitives to chip designs for synthetic biological application. Design constraints of microfluidic design through Neptune’s toolchain are also investigated by Lashkaripour.

Thank you to our sponsors for their support