Technical Overview

Mechanics¶

Baseplate¶

The baseplate connects the machine's structural frame to various protocol objects such as tube and tip racks. It is no more than a "table" with regular holes on which curb are attached, allowing you to align objects on its surface.

To learn more about the baseplate drawings, manufacturing instructions and design notes visit Baseplate

Structure¶

All of the Pipettin bots parts are assembled inside the structural frame, such as the baseplate and the carriages. Therefore, building the structural frame is the first step in the assembly process.

The motion system will be mounted on the top of the structure.

The baseplate will be located on the bottom of the structure, where different labware items can be placed. We call those platform items.

To learn more about the structural frame, manufacturing instructions and design notes visit Structural Frame

Motion system¶

Three linear actuators are mounted on the structure.

All of them are belt-driven, with the Z-axis featuring a mechanical reduction to increase torque roughly equivalent to a 8x4 leadscrew.

To learn more about the motion system, manufacturing instructions, and design notes visit Motion System.

Micropipettes¶

In the Pipettin Bot project, we decided to dive into the adventure of building our very own pipette from scratch:

To learn more about the pipette, manufacturing instructions, and design notes visit the Micropipettes page.

Tool-changer¶

As mentioned above, Pipettin Bot comes with an amazing tool-changer mechanism, inspired by the awesome Jubilee Project and E3D's tool-changer design.

This mechanism enables robots to switch between various types of tools such as pipettes, dispensers, mixers, and probes, among others, depending on a protocol's requirements.

The interface is the same that Jubilee uses, making all tools compatible. Only a swap of wedge-plates is needed.

To learn more about the tool-changer, manufacturing instructions, and design notes visit the Tool-changer page.

Control Electronics¶

Below is an overview of Pipettin's main control electronics.

To learn more about the electronics, assembly instructions and design notes visit the Electronics page.

Open-loop¶

Pipettin bot uses stepper motors to achieve controlled motion. This open-loop setup is simple and proven to work well within certain boundary conditions.

In open-loop control, stepper motors operate without feedback. In this configuration, the motor driver sends a sequence of pulses to the motor, which causes it to move in steps. However, the system does not have any feedback mechanism to confirm if the motor has reached the desired position (i.e. actually carried out the steps).

The only feedback is provided by limit switches at the start of a protocol, through a process called "homing". When the stepper motors are first powered on, the robot's position is uncertain. During homing, the machine moves its axes until each one triggers its own limit switch (a.k.a. an endstop). The machine is then considered to be at the "home position", which corresponds to a set of position values associated with it (e.g. x=0, y=0, z=0, etc.).

Open-loop control and stepper motors are commonly used in CNC for their simplicity, cost-effectiveness, and ability to provide accurate and repeatable motion control required for precise tasks. Pipetting bots typically perform operations at relatively low speeds and require accurate positioning, making this a suitable choice for the application.

There are many types of motors, and some of them even include electronics for closed-loop control. You can always choose to use more advanced control techniques, and modify pipettin accordingly.

Firmware¶

We use a fork of the popular 3D-printer firmware we call: Klipper for CNC

Klipper runs on the Arduino
Klippy runs on Raspberry Pi

Klipper is a firmware that runs on a Raspberry Pi and can control multiple axes. It receives step and time instructions from the microcontrollers and executes them. Four ports are connected to the Raspberry Pi, allowing Klipper to control multiple axes simultaneously.

The project has moved from GRBL to Klipper, but will stick to the Arduino UNO + CNC shield. Using more expensive boards is trivial with Klipper.

The directory contains general information relevant to the specific configuration for this project.

The full Klipper software stack has been forked and published over here:

Meta-repo including all forks as submodules: https://gitlab.com/pipettin-bot/forks/klipper-stack
All forks, including Klipper: https://gitlab.com/pipettin-bot/forks/

Hardware¶

Controller board¶

We use a pair of Arduino UNOs to achieve 7-axis synchronized motion.

The Arduino is a board based on an ATMEL microcontroller. Microcontrollers are integrated circuits that can be programmed to perform specific tasks. The Arduino IDE is a software environment that allows you to write and upload programs to the Arduino board.

Generic Uno © Olaldin, licensed under CC BY-SA 4.0.

The Arduino has two interfaces: an input interface and an output interface. The input interface allows you to connect different types of peripherals to the Arduino board. The output interface allows you to send data from the Arduino board to other peripherals.

The input interface is used to read data from peripherals. For example, you can connect a button to the input interface and the Arduino will be able to read whether the button is pressed or not. You can also connect a sensor to the input interface and the Arduino will be able to read the sensor's data.

The output interface is used to send data to peripherals. For example, you can connect an LED to the output interface and the Arduino will be able to turn the LED on or off. You can also connect a speaker to the output interface and the Arduino will be able to play sounds.

In several words, the raspberry pi tells the Arduino when it has to make a step, then the Arduino raises a pin and that is received by the pololu and takes care of motion.

Serial communication between the Raspberry Pi and Arduino is through a USB port.

To summarize:

The Raspberry Pi sends a signal to the Arduino.
The Arduino receives the signal and interprets it as a command to make a step.
The Arduino raises a pin, which is a physical connection that is used to send data to the Pololu.
The Pololu receives the signal from the Arduino and takes care of the motion.

Arduino Uno (Versión Informática) © Maxbrothers2020, licensed under CC BY-SA 4.0.

Arduino Pinout Diagram © Arduino.cc, licensed under CC BY 4.0.

Arduino Pinout diagram

CNC Shield¶

The CNC Shield for Arduino is a small board that makes it easy to control up to 4 stepper motors with your Arduino. It is a shield, which means that it plugs directly onto the Arduino board. The CNC Shield supports 4 Pololu A4988 power controllers, which are not included. It also has all the necessary connections to connect limit switches, relay outputs, and various sensors.

The CNC Shield is fully compatible with the GRBL/Klipper control firmware. This means that you can use it to control a CNC machine or other similar device. The CNC Shield can be used with any Arduino model, but it is recommended to use an Arduino UNO type model.

Arduino UNO compatible board, CNC shield stepper motor controller, and a NEMA 17 stepper motor © DotEagle, licensed under CC BY-SA 4.0.

Stepper Drivers¶

The Pololu A4988 is a basic stepper motor driver that simplifies the control of stepper motors from a PLC or processor, such as the Arduino. In other words, it controls the movement of the motors.

The A4988 handles the high voltages and currents that stepper motors require. It also limits the current that circulates through the motor, and provides protections to prevent damage to the electronics.

Main computer¶

The Raspberry Pi is the bot's main computer.

It has the GUI's web service and the interpreter which translates all the commands into GCODE for the firmware, and is connected to the CNC electronics through regular USB cables.

Raspberry Pi¶

The Raspberry Pi computer is open-source hardware too.

Here are relevant guides for this project:

Raspberry Pi software setup.
Systemd units for the Raspberry Pi.

RaspberryPi Model 4B © Jstrom99, licensed under CC BY-SA 4.0.

Raspberrypi block function v01 © Wirepath, licensed under CC BY-SA 3.0.

Power Supply¶

The Pi is powered through its GPIO header, with a step-down converter.

The DC-DC converter step-down is a device that converts a higher input voltage to a lower output voltage. The output voltage is always lower than the input voltage, regardless of changes in the input voltage or load.

In the case of a Raspberry Pi, the DC-DC converter step-down is used to convert a 24V input voltage to a 5V output voltage. This is necessary because the Raspberry Pi can only be powered by a 5V supply. If the Raspberry Pi were to be powered by a 24V supply, it would be damaged.

The DC-DC converter step-down is a simple device, but it is essential for protecting the Raspberry Pi from damage.

Software¶

Software for the pipettin bot project.

Components and general information flow:

Main Controller¶

In Pipettin-land, "controllers" are Python modules that coordinate and control hardware devices.

The main controller is the piper module. This is the central python module handling GCODE generation and CNC operation.

piper handles commands from the Pipettin Writer webapp/GUI. The events are received as socketio events by the GUI's backend, and proceesed into GCODE or other commands for hardware devices. The main program that piper interacts with is Moonraker, and its main functionality is defined by plugins.

Info

SocketIO is a library that enables real-time, bidirectional and event-based communication between the browser and the server.

Info

Moonraker is a Python 3 based web server that exposes APIs with which client applications may use to interact with the 3D printing firmware Klipper.

To learn more about Piper visit the online git repository.

APIs¶

Pipettin Writer's backend¶

The backend of the Pipettin Writer web-app exposes a public API.

More information below and at the repo's technical documentation, here.

PyLabRobot¶

We have written adapters to control the robot using PyLabRobot, a python library to write protocols programatically.

For more information browse the example notebook. More notebooks are available in the PLR fork's repository.

Note that our fork is limited to work with piper for now.

Newt¶

Newt is a python module centered on generation of valid data objects for the Pipettin project. These data objects are protocols, their steps, platforms, workspaces, etc. Everything the robot needs to know in order to work.

Newt's purpose is to provide convenience functions for generating and validating JSON representations of pipetting objects. These objects include protocols, steps, labware, workspaces, platforms, and contents. The Newt API aims to create JSON "schemas" for each type of data, which can be used to ensure the consistency and correctness of the generated JSON objects.

The Newt API module plays a crucial role in the project, providing functions to create, manage, and validate various JSON objects used in the pipetting workflow. The code snippet provided earlier demonstrates the definition of different Python classes that represent key components in the project, such as Hl_protocol, Content, Platform, Workspace, and others.

To learn more about Newt API visit the repo here

Database¶

A database is an organized collection of structured information, or data, typically stored electronically in a computer system. A database is usually controlled by a database management system (DBMS).

Most databases use structured query language (SQL) for writing and querying data. SQL is a programming language used by nearly all relational databases to query, manipulate, and define data, and to provide access control. Although simple, these early systems were inflexible.

Pipetting' Bots database use no structured query language (NoSQL). NoSQL databases came about as a response to the growth of the internet and the need for faster speed and processing of unstructured data.

A NoSQL, or nonrelational database, allows unstructured and semistructured data to be stored and manipulated (in contrast to a relational database, which defines how all data inserted into the database must be composed). NoSQL databases grew popular as web applications became more common and more complex.

MongoDB¶

MongoDB is a source-available cross-platform document-oriented database program. MongoDB uses JSON-like documents with optional schemas.

For data storage and retrieval, the Pipettin Bot app, Pipettin Writer, uses MongoDB, a NoSQL database. MongoDB stores the configurations of workspaces, platforms, and protocols, making it easy to manage and retrieve data related to the robot's operations.

Pipettin Bot uses MongoDB v3.2.12 version. More information about installation and requirements here.

Pipettin Writer UI¶

Web Interface¶

Pipettin Writer is a web application designed for creating protocols and operating the Pipettin bot. It offers an easy setup process for workspaces and protocols, allowing users to create and edit various platforms (tube racks, tip racks, petri dishes, or buckets) within the workspace. The app serves as an interface to interact with the robot, enabling users to send commands directly to it for executing predefined protocols.

Pipettin Writer is developed using web technologies, primarily based on a client-server architecture. The frontend of the web app is built using HTML, CSS, and JavaScript, with the help of popular front-end libraries and frameworks such as React.js, Redux, and Material-UI. These technologies provide a dynamic and user-friendly user interface where users can create workspaces, define platforms, and set up protocols conveniently.

On the server-side, the web app utilizes Node.js as the runtime environment and Express.js as the backend web framework. This combination allows the app to handle incoming HTTP requests from the frontend, manage routes, and interact with the robot through various API endpoints, as mentioned before.

In summary, Pipettin Writer serves as an easy-to-use web app for interacting with the Pipettin bot. Additionally, the future features planned for the app aim to further enhance its functionality and performance.

Pipettin Writer git repo: https://gitlab.com/pipettin-bot/pipettin-gui
Start the GUI.
Software Install requirements.

The frontend of our Web App is built using React.js, Redux, and Material-UI. To connect the frontend with the backend (Node.js), the app utilizes HTTP requests and responses over the network.

Overall, React.js simplifies UI development, enhances performance, and promotes maintainable code, making it an ideal choice for building modern, interactive, and scalable web applications.

Backend and API¶

The backend of the Pipettin Writer webapp exposes a public API.

More information can be found at the API's repo directory: https://gitlab.com/pipettin-bot/pipettin-gui/-/tree/develop/api

In the context of our Web App, Node.js serves as the backend runtime environment, handling various server-side tasks to make the app functional.

Info

Node.js: is a lightweight, event-driven JavaScript runtime environment that runs on the V8 JavaScript engine. It is used to build scalable and real-time applications, especially on the backend, where it can handle network requests, file I/O, and databases.

Info

Express.js is a popular web application framework for Node.js. It provides a set of functionalities and utilities that simplifies the process of building web applications and APIs. Express.js acts as a middleware, allowing you to handle incoming HTTP requests and define how your application responds to those requests.

To learn how to install the backend and its dependencies visit the software setup guide.

Lab automation¶

General information on lab automation.

Liquid handling¶

Liquid handling refers to the precise and automated transfer of liquids, such as reagents, samples, or solutions, from one container to another. This capability is vital in various laboratory workflows, as it significantly reduces human error, enhances accuracy, and improves efficiency in handling repetitive tasks.

There are some fantastic articles on automation and open source:

Wolf and Gollapudi's light but comprehensive intro to lab automation: https://theautomatedlab.com/index.html
Tim Dobb's proposal on integration of open lab hardware: https://www.autobio.blog/open-source-integration-will-give-you-super-powers/

The liquid handling system of Pipetting Bot involves handcrafted electronic micropipettes with specialized pipette tips. A resin 3D printed tip holder is used to attach different tip sizes, such as 20 μL, 200 μL and 1000 μL. This mechanism allows Pipettin Bot to handle a wide range of liquid volumes accurately, from microliters to milliliters.

Tip holder with 20 μL, 200 μL and 1000 μL tips.

Pipettin Bot also comes with a tool-changer mechanism inspired by the awesome Jubilee project. The tool-changing mechanism serves the purpose of automating the process of changing and swapping different tools or instruments without manual intervention.

The tool-changer's drawings, manufacturing instructions and design notes visit Tool Changer

Other projects, however, have adopted different liquid handling approaches that set them apart from our bot:

Jubilee is an open source hardware multi-tool motion platform that can run G-code for low-force automation tasks. Jubilee is configured for multimaterial 3D printing and multicolor pen plotting, but it can also be used for light liquid handling and image stitching. It is designed to be extended by the community, and people from all over the world have added new tools and applications to the project. Pipettin bots tool-changer mechanism was adapted from this project and we believe it will continue upgrading and developing new tools for CNC machines.

Open LH, for instance, employs an off the-shelf robotic arm coupled with a syringe pump to dispense liquids. A syringe pump or injector (in this case with infusion and withdrawal capabilities) is a small infusion pump used to gradually administer small amounts of fluid. This robot can perform liquid handling tasks in micro-scale accuracy. It can be built for around $3000 USD and it is open source.

Others, like Echo 525 Acoustic Liquid Handler, unlike Pipettin Bot and other traditional liquid handling robots, does not use traditional pipettes. It uses sound waves to transfer liquid, offering high precision in dispensing extremely small volumes. However, it may not be suitable for handling milliliter-scale volumes. The transfer of liquids from sound is achieved through the acoustic droplet ejection (ADE) technique. This technique uses high-intensity acoustic waves to generate liquid droplets of a specific size and volume. The cost of building this robot cannot be estimated since it is not open source.

The D300e Digital Dispenser, on the other hand, uses inkjet printing to dispense liquids in picoliter to microliter volumes. Inkjet printing for liquid dispensing works by using a print head to create small droplets of liquid and then eject them onto a substrate. It is a more precise and accurate way to dispense liquids than traditional methods, such as micropipettes. The cost of building this robot cannot be estimated since it is not open source.

The Opentrons Flex is a proprietary hardware liquid handling system is a modular platform that allows users to swap out different components to customize their workflow. The system includes a variety of swappable 1-, 8-, and 96-channel pipettes, with volume ranges from 1 to 1000 µL. Users can also swap out the on-deck hardware, gripper, and other modules. The Flex Gripper can move plates and tip racks across the deck or on or off modules. The Opentrons Flex is a powerful and versatile liquid handling system, but it has its drawbacks. The system is relatively expensive, costing around $20,000 USD fully assembled. Additionally, the system is is not open source hardware, only the general dimensions have been published. The control software and firmware are open source.

There are three main differences we can outline between Pipettin Bot and other robots:

Open Source

Open source makes Pipettin Bots documentation reachable to people all around the globe. The Wiki, GitLab, and Discord server are all accessible for anyone to explore and learn from. The information available may include, but is not limited to:

Hardware design files: These files contain the schematics and 3D models of the robot's hardware components. This information can be used to build or modify the robot.

Software: This includes the robot's firmware, which controls the hardware, and the software that is used to operate the robot. This information can be used to customize the robot's behavior or to develop new applications for it.

Documentation: This includes the robot's assembly guide, which provides instructions on how to build, use, and maintain the robot. It also includes technical documentation, such as API documentation, which can be used to develop software that interacts with the robot.

Open source projects also opens up a world of innovation. They are often more innovative than commercial ones. This is because they are developed by a large community of people who are constantly sharing ideas and working to improve the project, in our case, Open Lab Automata.

Affordability

Pipettin Bot was designed to be affordable and easy to use, so that anyone can make or buy it. This means that more people can use their time to do more research, rather than repetitive tasks like pipetting. As a result, we believe it is now possible to automate laboratories, Biotech companies and more institutions in Argentina.

Open source projects are often free or low-cost, which can make them a more affordable option than commercial ones.

Tool-changer mechanism

Another main difference between our robot and others is that ours can be adapted to a wide range of laboratory tasks and workflows thanks to its tool-changer mechanism. This means that a variety of tools and equipment, such as centrifuges, photocolorimeters, and plate readers, among others, can be attached to the robot, making it a versatile and adaptable solution for laboratory automation. This allows you to have a single low-cost CNC machine with multiple functions and applications in molecular biology.

Pipetting¶

What can the pipettes be used for by the robot?

Pipettin bot serves a wide range of liquid handling tasks in laboratories and automated systems:

Liquid Transfers: Pipettin Bot can aspirate a specific volume of liquid from a source container (e.g., test tube, microplate well) and dispense it into a target container with high precision. The primary function of the pipettes is to perform accurate and precise liquid transfers. The graphical user interface (GUI) allows you to select the specific location where the pipette will start aspirating and dispensing liquid.
Tip Placement and Attachment: Pipettin Bot, with its 3D printed tip holder, precisely positions and attaches disposable pipette tips to the pipette's tip cone. This precise tip placement guarantees a secure seal, preventing liquid leaks and ensuring reliable pipetting performance. The effectiveness of this mechanism is attributed to the integration of load cells, which enable the measurement of "pressure" during tip placement. This is important for tasks such as aliquoting and serial dilution, where the volume of liquid transferred can be affected by the placement of the pipette tip.
Compatible Pipette Tips: The robot can work with a variety of compatible pipette tips. These tips come in different volumes and designs. The volumes to be transferred by the robot can range from 1μL (minimum volume) to 1000μL (maximum volume). The selection of these tips will be influenced by both the specific protocol prerequisites and the volume of liquid intended for transfer. A specific tip must be chosen depending on how much liquid yo aim to transfer.
Accuracy and Precision: Pipettin Bot, when paired with calibrated and high-quality pipettes, delivers exceptional accuracy and precision in liquid handling. Accuracy refers to how close the dispensed volume is to the target volume, while precision refers to the consistency of repeated measurements. This is important for many laboratory experiments, where even small errors in volume can have a significant impact on the results.

Compatible tip sizes and their error tolerances:

Tip Size (µL)	Minimum Volume (µL)	Maximum Volume (µL)	Error (µL, ISO 8655-1:2022)
20	0.2	20	± 0.02
200	2	200	± 0.05
1000	100	1000	± 0.1

To learn more about the pipettes, manufacturing instructions, and design notes visit Electronic Micropipettes

Gripper¶

PLANNED

This feature is planned, work will begin in 2025.

Labware¶

The labware is also referred as "platforms" or "protocol objects" along the wiki.

Passive equipment and plastic consumables compatible with the robot:

Standard well plates

Flat plates consist of multiple evenly spaced depressions, known as wells, that hold samples or liquids. Well plates are used to simultaneously test multiple samples. Well plates come in different formats, including 96-well and 384-well plates, each offering a different number of wells for accommodating different scales of experiments.

Standard dimensions of an SBS-compliant 96-well plate.

Tip racks, tube racks

Tip racks hold disposable pipette tips securely in an organized grid, ensuring easy access for robotic or manual pipetting procedures. These tips are crucial for preventing cross-contamination between samples and ensuring accurate liquid transfers. These tips are usually discarded in the discard box after being used to avoid contaminating different samples.

Tube racks, on the other hand, provide a stable and organized storage solution for various types of tubes. These enable scientists to keep tubes properly labeled, making it easier to retrieve and handle samples during experiments or storage.

Both tip racks and tube racks play a vital role in maintaining the integrity of samples and improving the precision and reliability of laboratory workflows.

Tip rack containing 96 tips in total, 200 μL tip sizes included.

Tube racks, can hold up to 80 tubes.

Falcon tubes

Conical centrifuge tubes, often referred to as "Falcon" tubes (a brand name from Corning), are cylindrical containers used in laboratories to store and handle small volumes of liquid samples. These tubes come in various sizes and are made from materials like polypropylene. They are designed to securely hold liquids, ensuring minimal evaporation or contamination. Microtubes are commonly used for tasks such as centrifugation, storage of DNA or protein samples, and conducting small-scale experiments, among others.

Falcon tubes available in both 50 mL and 15 mL sizes.

Glassware: flask, graduated cylinder, etc.

Glassware, including items like flasks and graduated cylinders, is fundamental equipment in laboratories for measuring and containing liquids.

Flasks are versatile containers with various shapes and sizes, designed for mixing, heating, or storing liquids. They often have narrow necks to minimize evaporation and enable easy pouring. Graduated cylinders, on the other hand, have precise volume markings along their sides, allowing accurate measurement of liquid volumes.

These tools are indispensable for tasks such as preparing solutions, measuring reagents, and conducting experiments where precise volumes are crucial.

Several types of glassware, such as Erlenmeyer flasks, beakers, Buchner flasks, and graduated cylinders.

A guide to laboratory glassware

Equipment¶

Integrations with active "benchtop" equipment are a planned feature.

Information on this front can be found in the Equipment page.