Difference between revisions of "Team:BostonU HW/Attributions"

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.

Choosing Electrical System | Zach Lasiuk

Analyzed pitfalls and advantages of several different systems to control servos, including a raspberry pi, custom PCB, motor controller through breadboards, and Arduino. Focusing in on the overall goals of Neptune’s hardware (low cost, easy to use, and modular), a custom PCB option was immediately removed due to not satisfying any of the three goals. Using a raspberry pi is difficult to setup relative to an Arduino and breadboard and was eliminated as such. Setting up a breadboard would require meticulous placement of many different electrical components as well as introduce noise into our electrical system; for these reasons the Arduino was chosen to control Neptune’s hardware.

Choosing Baseboard System | Zach Lasiuk

Analyzed pitfalls and advantages of several different types of base-plates to mount Neptune’s hardware, including a solid slab of wood, puzzle pieces that interlock, and modular squares. Focusing once again on Neptune’s hardware goals (low cost, easy to use, modular), a setup requiring an outside machine shop was never considered. When comparing these setups, despite many similarities, modular squares with pre-drilled holes wins out as the easiest to use do to the simplicity in component alignment during assembly. Furthermore, these holes are compatible with an emerging standard in microfluidics, the MEC board. The modular square system was thus chosen for Neptune.

Mapping Mechanical Motion | 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. This involved geometric modeling and trigonometry to translate the rotational motion of a servo arm to linear syringe pump motion. After the equation for off-center and on-axis piston rod motion was verified and tested, the response was modeled with a range of values for each parameter. The ideal parameters for a smooth and most linear response were selected, as well as limits imposed to ensure Neptune always delivers smooth syringe motion.

Developing Scalable Electronics | Zach Lasiuk

Because Neptune is inherently modular to change with synthetic biologists needs, Neptune’s electronic control circuitry must be equally as modular to ensure the user is not overpaying for extraneous hardware nor is unable to safely control their setup. The electronic system is comprised of power inputs, stackable Arduino motor controller shields, an Arduino Mega, and varies headers and capacitors to make the system respond appropriately. The power is delivered through 5v 10W laptop power supplies which are readily available, safe, and deliver enough power to control up to 16 servos at once. The stackable controllers can each control 16 servos per board, and therefore users do not have to order a more expensive system that can control 200 servos if they only need 10 to get started.

Constant Flow Rate Equation | Zach Lasiuk

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. Furthermore, the equation derived to map this motion is not invertible, preventing a simple equation to obtain change in linear motion with a 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.

Developed Modular Baseboard | 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 by creating modular squares that can be milled out one at a time and connected together. The 1/8” diameter holes are arranged in a grid, spaced 0.3” from one another and 0.15” from the edge of the board, enabling two boards to be connected forming a space of 0.3” between all holes. This is compatible with an emerging standard in microfluidic hardware, the MEC board, developed by the GroverLab at University of California, Riverside. 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

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.

Selecting Servos and Syringes | Zach Lasiuk

To bridge the gap between clicking a computer screen and moving fluid through a chip, users must select servos and syringes to move this fluid in the first place. In order to perfectly match the requirements of synthetic biologists to an appropriate servo/syringe combination, Neptune has an algorithm to convert the desired max volume and minimum tolerance of each dispenser to published values for servos and syringes. On the Build page this is seen clearly, when entering in fundamental requirements results in all servo/syringe combinations that can fulfill those specifications—even including price ranges.

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.

Control Infrastructure Prototyping | Zach Lasiuk & Priya Kapadia

To create the control infrastructure for all the hardware components, the hardware team had to design many prototypes to create the optimal support system. The prototyping took into account the upcoming standard of microfluidic control, which are the MEC platforms, and also had to consider how the system could be adapted to many different hardware setups. The design infrastructure was made to modular and allow easy access to all the parts. So, switching out components is extremely easy.

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!)