Technical Overview

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.

To learn more about Pipettin Bots equipment visit here

See Pipettin Bot in action: liquid handling demo here!

Due soon: liquid handling demo video

The motion system's drawings, manufacturing instructions and design notes are available at:
Motion System
XY Axes Linear Actuator
Z Axis Linear Actuator

To learn what technologies the robot uses to achieve controlled motion visit CNC

Pipetting¶

What can the pipettes be used for by the robot?

Pipettin bot, equipped with its precision pipettes, 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.

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

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.

To learn more about the pipette's drawings, manufacturing instructions and design notes visit Electronic Micropipettes

Gripper¶

Probably due for 2024-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.

Yellow pipette tips box © Nadina Wiórkiewicz, licensed under CC BY-SA 3.0.

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

Tube Rack © Karbohut, licensed under CC BY-SA 4.0.

Tube racks, can hold up to 80 tubes.

Microtubes, "falcon" tubes

Microtubes, often referred to as "falcon" tubes, are small 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 © Nadina Wiórkiewicz, licensed under CC BY-SA 3.0.

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.

Laboratory Equipment in Science Research Lab © Poughkeepsie Day School, licensed under CC BY-NC-SA 2.0.

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

A Visual Guide to Chemistry Glassware © Andy Brunning, licensed under CC BY-NC 4.0.

A guide to laboratory glassware

Equipment¶

Active "benchtop" equipment:

Centrifuges¶

Info

Discord thread https://discord.com/channels/1042462799772782613/1128199805122920509

Centrifuges are machines that spin samples at high speeds to separate components based on their density. They are used to separate solids from liquids, different cellular components, or particles of different sizes in solutions. These particles are separated according to the size, shape, density, and viscosity of the medium.

Prototype BLDC Centrifuge.

To learn how to build your DIY portable BLDC centrifuge from scratch go here and visit:

Issue for the task: https://gitlab.com/pipettin-bot/pipettin-bot/-/issues/212

GitLab repo: https://gitlab.com/pipettin-bot/pipettin-bot/

Thermocyclers¶

Info

Discord thread https://discord.com/channels/1042462799772782613/1130552183105015950/1130552183105015950

For now, Pipettin Bot does not support this yet, as it is currently undergoing development.

Thermocyclers, also known as PCR machines, are used in molecular biology for the polymerase chain reaction (PCR). The basic idea of a thermal cycler is that it provides a thermally controlled environment for PCR samples.

A thermal cycler usually contains a heating block with holes or depressions in it that receive sample tubes. For the PCR reactions to work properly, the block must change temperature at specific times, and spend specific durations of time at specific temperatures.

Prototype adaptation of the PocketPCR to automation.

To learn more about this project, visit:

Issue for the task: https://gitlab.com/pipettin-bot/pipettin-bot/-/issues/211

GitLab repo: https://gitlab.com/pipettin-bot/forks/labware/PocketPCR

Well-plate incubator¶

For now, Pipettin Bot does not support this yet, as it is currently undergoing development.

A well-plate incubator, also known as a microplate incubator, is a specialized equipment designed to provide a controlled and stable environment for cultivating and incubating samples in microplates. It offers several key capabilities that are essential for various biological and biochemical assays and experiments.

Probably due 2024.

Orbital shaker¶

For now, Pipettin Bot does not support this yet, as it is currently undergoing development.

An orbital shaker is another key equipment, designed to facilitate the mixing and agitation of samples placed in various containers.

The versatility of an orbital shaker to accommodate a wide range of labware depends on its orbital diameter, and having "slots" for a variety of labware, such as micro-well plates (a.k.a 96-well plates, ELISA plates). This means it can be used for cell culture and protein expression, where maintaining consistent environmental conditions and proper mixing are critical.

Prototype orbital shaker, fixed to the robot's baseplate.

Probably due 2024.

The orbital shaker mechanism relies on 3D-printed parts and standard bearings, such as the 608zz and 625z. The diameter of the orbit is a crucial parameter, which determines which kinds of labware it can effectively shake.

For microplates and applications that demand precise and small-scale mixing, a smaller orbit diameter is needed. In these cases, a standard orbit diameter of about 1 mm is often used to ensure uniform mixing while minimizing the impact on the samples.

However, achieving an orbit of this diameter requires a redesign of the eccentric couplers, which are responsible for generating the orbital motion. This modification would allow shaking of 96-well plates and small tubes, which is usually done with a benchtop "vortex" device.

Prototype orbital shaker.

Microscopes¶

For now, Pipettin Bot does not support this yet, as it is currently undergoing development.

Microscopes are optical instruments used to magnify and visualize small objects that are otherwise not visible to the naked eye. They are crucial for studying cells, tissues, microorganisms, and various structures in biological and material samples.

There are many different types of microscopes used in modern pathology laboratories and research departments around the world, these typically include stereo, compound, digital, and pocket microscopes as well as an electron, and fluorescence microscopes.

Probably due 2024.

Documentation: https://luherbert.gitlab.io/wiki-regosh-2023/hardware/microscop%C3%ADa/esp32-cam/

Colorimeters¶

Info

Discord thread https://discord.com/channels/1042462799772782613/1125799842111832155

For now, Pipettin Bot does not support this yet, as it is currently undergoing development.

Colorimeters are devices that measure the color of a sample. They do this by passing light through the sample and measuring how much of the light is absorbed at different wavelengths. The color of the sample is then determined by comparing the absorbance spectrum to a known standard.

To learn more about this project, visit:

Issue for the task: https://gitlab.com/pipettin-bot/pipettin-bot/-/issues/200

GitLab repo & documentation: https://gitlab.com/pipettin-bot/forks/equipment/photo-colorimeter

Spectrophotometers¶

Info

Discord thread https://discord.com/channels/1042462799772782613/1125799999498887289

For now, Pipettin Bot does not support this yet, as it is currently undergoing development.

Spectrophotometers measure the amount of light absorbed or transmitted by a substance as a function of the wavelength of light. They are utilized to analyze the concentration of substances in solutions, including DNA, RNA, proteins, and chemicals, by assessing their light-absorbing properties. This is achieved by passing light through the substance and quantifying the intensity of light absorbed or transmitted. By comparing the measured values to known standards, spectrophotometers enable accurate determination of the concentration of substances within the solution. They can also be used be used to quantify the composition of a sample.

Probably due 2024.

To learn how to build your DIY portable spectrophotometer from scratch go here

Plate Readers¶

Info

Discord thread https://discord.com/channels/1042462799772782613/1125801364774195301

For now, Pipettin Bot does not support this yet, as it is currently undergoing development.

Plate readers, also known as microplate readers, are devices used to measure various properties of samples contained in microplates (well plates). They can perform tasks like measuring the fluorescence, absorbance, or luminescence of samples, making them valuable tools for high-throughput experiments in fields such as biochemistry and drug discovery. A wide range of assays can be performed using a microplate reader including ELISAs, protein cell growth assays, nucleic acid and protein quantification, enzyme activity measurement, immunoassays, among others.

Probably due 2024.

To learn how to build your DIY portable plate reader from scratch go here

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 baseplate will be located on the bottom of the structure. On top of it you can see different labware.

And the XY carriages will be located on the top of the structure. This carriages will change in the midterm.

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

Motion system¶

The Linear actuator connects the XY Carriages with the XZ Axis Draft and is connected to the rest of the robot through its joints with the XY Carriages.

To learn more about the motion system's drawings, manufacturing instructions and design notes visit Motion System, XY Axes Linear Actuator and Z Axis Linear Actuator

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 pipettes drawings, manufacturing instructions and design notes visit Micropipettes

Tool-changer¶

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

Even though this aspect of the project is currently under development, the goal is that this mechanism will enable Pipettin Bot to switch between various types of liquid handling tools such as pipettes, dispensers, mixers, and probes, among others, depending on the protocol requirements.

To learn more about the tool-changer's drawings, manufacturing instructions and design notes visit Tool-changer

Control Electronics¶

Arduino UNO¶

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¶

Open-loop control with stepper motors¶

Pipettin bot uses stepper motors to achieve controlled motion.

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.

CNC probe tool¶

The probe is a valuable accessory used in CNC machines for various purposes. It is a precision measurement tool designed to gather information about the machine's workspace. The CNC probe is used in conjunction with the CNC controller and software to perform specific tasks, such as workspace alignment, tool length measurement, and surface mapping, among others. It enables the machine to perform a range of measurements and alignments, leading to improved accuracy, reduced setup time, and increased efficiency in machining operations.

Load cell¶

A load cell is a transducer that converts force or pressure into an electrical signal. In the context of pipetting bots or liquid handling systems, a load cell can be used to measure the tip placement pressure during the pipetting process. By integrating a load cell into the pipetting system, it becomes possible to monitor and control the applied pressure, ensuring accurate and consistent liquid dispensing.

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.

Pololu A4988 Driver¶

The A4988 is a 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.

DC-DC Converters Step Down¶

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.

CNC Firmware: Klipper¶

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/

Protocol translators and GCODE senders¶

Piper¶

Piper GCODE generation and Klipper handlers for pipetting, here.

Pipettin Bots Electronics¶

Pipettin Bots Electronics:

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

Main computer¶

Raspberry Pi¶

The Raspberry Pi is basically the bots computer. It receives the G-code in the form of pulses and performs the necessary mathematical operations to convert it into microstep instructions.

The Raspberry Pi has the GUI's web service and the interpreter which translates all the commands into G code. This Raspberry Pi can be connected directly by the GPIO to many things, such as the pipette's stepper driver, the pipette's servomotor and has several wires coming out from the Raspberry Pi to reset klipper in case something goes wrong.

Raspberry Pi: Hardware¶

Meet Raspberry Pi

Raspberry Pi Hardware

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

Software¶

Software for the pipettin bot project.

Components and general information flow:

Controllers¶

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

The main controller is the piper module.

Piper: GCODE generation and CNC handler for pipetting protocols¶

This module 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.

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 repo here.

Overview of the files in piper:

piper contains the main code, and the plugins subdirectory contains extensions.
The notebooks directory contains several test notebooks, for example:
moonraker_websocket_test.ipynb : code snippets for connecting to Klipper through Moonraker (through wbesockets or HTTTP).
klipper_uds_test.ipynb : newer tests for connecting to Klipper through its Unix-domain socket (UDS).
klipper_uds_test-old.ipynb : older code snippets for connecting to Klipper through its Unix-domain socket (UDS).
examples_piper-development.ipynb : many code snippets to connect to and/or run Klipper through different protocols (websockets, RPC, HTTP). Uses functions in coroutines.py and klippy_run.py. Contains most of the snippets in other notebooks.
examples_piper.ipynb : initial tests of the asyncio coroutines in coroutines.py.

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.

Newt API: Object generation module for the Pipettin project¶

WIP

The API is unfinished and non-functional. The JSON schemas for data validation and some low-level generator functions are complete.

Newt API is a module designed for the Pipettin project, and its 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, Deck, Platform, Workspace, and others.

The Hl_protocol class defines a high-level protocol schema, specifying properties like name, description, workspaceID, workspace, template, and steps. The Content, Deck, Platform, and Workspace classes define resource-related objects and their properties:

Hl_protocol: This is a class representing a high-level protocol schema, containing properties like name, description, workspaceID, workspace, template, and steps.
Content: This class represents the content of a resource, such as tips, tubes, or colonies, and has attributes like name, type, index, tags, maxVolume, and volume.
Deck: This class represents a deck pipetting system and defines its properties like name, description, width, length, height, origin, and color. It also contains methods for serialization and assigning/unassigning child resources.
Platform: This class represents a platform (e.g., Petri dish) in the workspace and has attributes like name, description, type, color, defaultTopPosition, rotation, and version. It also has methods for adding content and instantiating from JSON.
Position: This is a base class for defining positions with x, y, and z coordinates.
Coordinate: This class represents a position in three-dimensional space with x, y, and z coordinates.
RowsAndColumns: This class represents a position with row and column coordinates.
Resource: This is a base class for deck resources, defining common attributes like name, rotation, category, position, parent, and children. It also contains methods for serializing resources and handling child resources.
Robot: This class seems to be a base class for defining robot-specific characteristics.
Workspace: This class represents a workspace, and it has attributes like id, name, position, and tools. It is inherited from the Resource class and represents the larger environment for the robot.

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.

Web App¶

Web Interface: Pipettin Writer¶

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 enhance its functionality and performance further.

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

Node.js 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 more about node.js installation and its dependencies visit here.

React.js GUI¶

React.js, commonly referred to as React, is an open-source JavaScript library developed by Facebook. It is primarily used for building user interfaces (UI) and is one of the most popular front-end libraries in modern web development. React.js allows developers to create reusable UI components and efficiently manage the state of the application.

React plays a crucial role in making the web app functional by providing a powerful front-end framework for building dynamic and interactive user interfaces.

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.