Here is our final product! The components are annotated in the images below.

Ender-3 Frame:

The Ender-3 frame comprises a rail system that supports movement along the x, y, and z axes, each axis designed for specific directional movement. The X-axis rail, mounted horizontally on the Z-axis frame, allows for left and right movement across the base of the frame. The Y-axis, oriented along the base itself, controls the forward and backward motion of the entire platform. The Z-axis enables vertical movement, using vertical rails and lead screws attached to stepper motors to raise and lower the X-axis rail. This was perfect for us, and hence, we decided to build up our system from this base.

Main base, pipette tip holder, and beaker holder: To hold up and support our beakers (containing magnetic stirbars), pipette tips, and waste bin, as well as house our magnetic stirring mechanism

Magnetic stirring panel: Comprises 6 cooling fans screwed down, with each fan having a neodymium magnet glued to the centre. Fans are connected in parallel to an external power source (power bank).

Summary of how our automated serial dilution machine works:

When the program starts, the user is presented with three options on the screen:
Option ‘1’ to return the machine to the home position, which resets it and prepares it for the next task. Option ‘2’ to initiate the pipetting process with a customizable choice of repetitions, from one to five. Option ‘3’ to bring up a component labeled E0, used for debugging purposes.

Let’s say the user selects Option ‘2’ for pipetting. The program then prompts the user to input the number of pipetting repetitions they’d like, anywhere from one to five. This flexibility allows the user to set the precise number of cycles needed for their experiment. Based on the input, the machine will automatically carry out the selected number of pipetting actions. The user can then activate the fans for stirring to ensure thorough mixing in each beaker.

Once the pipetting option is confirmed, the dilution process begins. The movable arm moves the pipette to pick up a new pipette tip. The pipette holder presses down onto the tips located on the main base to securely attach a tip. Next, the arm travels to the beaker containing the stock solution. It draws up the required amount of solution to begin the dilution. The pipette then moves to the next beaker, which is filled with the diluent. It ejects the stock solution into the diluent, achieving the first dilution step. After this, the arm moves to the waste bin, where it ejects the used pipette tip, ensuring no cross-contamination for the next cycle. This process is repeated according to the number of dilutions required. The machine continues moving between the pipette tips, stock solution, diluent, and waste bin until the entire series of dilutions is completed as specified by the user.

On our user interface:

How our system is controlled: 

The firmware of our pipetting system comprises an Arduino Mega 2560 with an attached RAMPS 1.6 shield and Marlin firmware. 

Marlin refers to an open-source firmware widely used in 3D printing and Computer Numerical Control (CNC) systems for precise movement control. It is able to interpret G-code commands, which specify the movement paths, speeds, and steps needed to complete a task. Thus, we used Marlin to control the pipetting system’s motors, guiding the arm along the X, Y, and Z axes and performing the additional motions for ejecting the pipette tip and pushing the plunger. Marlin’s versatility allowed it to be configured with our specific pressing and moving dimensions to handle the pattern of motion of our pipetting system. 

The Arduino Mega 2560 is a microcontroller board with input/output pins. It serves as the main controller of the system to run the Marlin firmware and manage the various signals to the stepper motors. The Mega 2560 in specific comprises a high number of input/output pins, enough memory, and a high amount of processing power to control our motors and interpret complex instructions for coordinated movement in the x, y, and z axes. 

The stepper motors themselves are motors that move in discrete steps, allowing for precise positioning along the x, y and z axes, and are controlled by motor drivers. Our motor drivers are small modules that control the direction and speed of stepper motors by translating signals from the Arduino into electrical pulses that the motors can interpret. Thus, these drivers act as intermediaries, receiving commands from the RAMPS shield and powering the motors with the correct voltage and current. By controlling the direction and step size, the motor drivers ensure that each stepper motor moves with the precision required for pipetting.

The RAMPS 1.6 shield is a shield designed to expand the Arduino Mega, and seamlessly integrate it with our stepper motors and motor drivers.

This allows the Arduino to control multiple stepper motors through dedicated connections for motor drivers. It would also support higher voltages than the Arduino alone, as the motors often require more power than the microcontroller can directly supply. Additionally, the shield makes wiring simpler and more organized, making it easier to connect and manage each motor driver and stepper motor.

Thus, for our final set-up, we attached 5 motor drivers to our RAMPS 1.6 shield, with 3 jumpers attached per motor. Each motor driver was attached to a stepper motor. These 5 stepper motors correspond to the X, Y, and Z axes of movement, as well as the two additional axes of movement required for the pushing mechanism for the ejector button and plunger of our micropipette. Our stepper motor and jumpers allow for 1/16 jumping and hence 1/80 mm steps, which are necessary for the precise movements needed to pick up the narrow tips and eject liquid into small 25ml ml beakers. 

Here, each G-code command was written individually, rather than within loops (such as for loops). This is due to our commands consisting of many quick, precise movements, where loops caused commands to been issued too quickly and resulted in intermittent skipping of some of our commands embedded within the loop.

For our magnetic stirring mechanism, we utilised PWM speed controllers, cooling fans, neodymium magnets, and stirbars. 

PWM speed controllers are devices that regulate the speed of DC motors , or, in this case fans, by rapidly switching the motor on and off at different intervals. This effectively controls the fan speed without reducing torque.

Our cooling fans acted as the base of a magnetic stirrer, where the magnet was attached to the top of the fan. When the fan rotates, it spins the attached magnet at its center, and interact with our stirbars. Our stirbars are magnetized bars, coated in a chemically inert material. Thus, the rotation of the magnet generates a magnetic field that causes our stir bars (placed in each beaker) to spin by pulling the stir bar in the corresponding beaker to stir the solution, thus mixing the contents thoroughly. The fans are set up beneath each beaker, each connected to its PWM speed controller to regulate stirring speed independently.

The 6 PWM speed controllers are connected in parallel- one for each beaker-stir bar set. The Arduino mega is then connected to the cooling fans, with neodymium magnets glued to the centre.