iSWAP Module

In addition to the CO-RE gripper, the iSWAP module provides advanced plate handling capabilities for the Hamilton Microlab STAR. This module enables precise manipulation of labware across the deck, including tasks like plate covering, transportation to readers, and complex positioning scenarios that go beyond standard pipetting operations.

The iSWAP module offers a rotatable arm that can pick up and place labware at any position on the deck, providing greater flexibility for complex workflows. In addition, it has a better reach beyond the standard deck envelope, allowing for better access to off-deck integrations such as readers, incubators, and other laboratory equipment.

Prerequisites

• A switched on Microlab STAR device
• A plate carrier and a plate
• A running Microlab STAR connector
• Basic understanding of the liquid handler class (See the liquid handler tutorial)
• Basic understanding of how labware is used (See the using standard labware tutorial)

Key iSWAP Concepts

Before getting started, let's review a few key concepts when working with the iSWAP module.

Positional Reference Frame

Like the CO-RE gripper, the iSWAP's location is defined as the center point between its two gripper fingers. This center point serves as the reference for all its positioning operations, and is crucial to account for when using the module. However, this can easily cause confusion when working with other deck resources, since the default reference point for other labware is typically defined as its origin (front-left corner).

The UniteLabs labware library provides utilities to help with coordinate transformations and positioning calculations when working with the iSWAP module, in particular for converting between these two coordinate base frames (iSWAP center point vs. labware front-left origin). The key utility is the resource .center property.

The .center property returns a Vector instance representing the center point of the resource relative to that resource's own origin (the front-left corner). This Vector will have only x- and y-components. It does not represent the absolute location of the labware's center on the deck, therefore you must sum the plate's location and center to get the absolute position of the center point, as illustrated below.

Additionally, the .location property of a resource gives its absolute position on the deck, and when combined with .center, you can calculate the absolute center position of any labware.

    Deck View - Illustrating the Reference Frames

               ┌──────────────────────────────────────────────────────────┐
               │                                                          │
               │         ┌─────────┐                                      │
               │         └─────────┘                                      │
               │              ● ← iswap.current_location                  │
               │         ┌─────────┐                                      │
               │         └─────────┘                                      │
               │                                                          │
               │    ┌─────────────────┐                                   │
               │    │                 │                                   │
               │    │        ● ← my_plate.location + my_plate.center      │
               │    │                 │                                   │
               │    ●─────────────────┘                                   │
    y          │    ▲                                                     │
    ↑          │    └─ my_plate.location                                  │
    |          │                                                          │
    └ - → x    └──────────────────────────────────────────────────────────┘
 ↙
z

    Deck View - iSWAP Correctly Aligned to Plate Center

               ┌──────────────────────────────────────────────────────────┐
               │                                                          │
               │        ┌─────────┐                                       │
               │    ┌───└─────────┘───┐                                   │
               │    │                 │                                   │
               │    │        ● ←      │  iswap.current_location ==        │
               │    │                 │    my_plate.location              |
    y          │    ●───┌─────────┐───┘      + my_plate.center            │
    ↑          │        └─────────┘                                       │
    |          │                                                          │
    └ - → x    └──────────────────────────────────────────────────────────┘
 ↙
z

    Deck View - iSWAP Incorrectly Aligned to Plate Origin

               ┌──────────────────────────────────────────────────────────┐
               │                                                          │
               │         ┌─────────────────┐                              │
               │         │                 │                              │
               │    ┌─────────┐   ●        │                              │
               │    └─────────┘            │                              │
               │       → ●─────────────────┘  iswap.current_location ==   |
    y          │    ┌─────────┐                 my_plate.location         │
    ↑          |    └─────────┘                                           │
    |          │                                                          │
    └ - → x    └──────────────────────────────────────────────────────────┘
  ↙
z

The .center utility helps simplify coordinate transformations when working with the iSWAP module, making it easier to specify absolute coordinates that account for the different reference frames between the iSWAP and other deck resources.

With a plate on the deck, one would use these properties with the move_to method like so:

# Move to a plate location
# Calculate absolute center position
plate_center_absolute = my_plate.location + my_plate.center
# Use with iSWAP move_to method
await hamilton.iswap.move_to(location=plate_center_absolute)

# Move to a carrier site location
# Calculate absolute center position
carrier_center_absolute = my_carrier[0].location + my_carrier[0].center
# Use with iSWAP move_to method
await hamilton.iswap.move_to(location=carrier_center_absolute)

Rotation and Direction

The iSWAP has a unique rotational element which allows it to pick and place labware in multiple orientations.

The UniteLabs liquid handling SDK provides support for specifying rotation direction when handling labware with the iSWAP module in the form of the Direction enum:

class Direction(enum.IntEnum):
    FRONT = 1
    RIGHT = 2
    BACK = 3
    LEFT = 4

This enum defines the four cardinal directions from which the iSWAP can approach and handle labware. It can be imported directly from the liquid handling SDK like so:

from unitelabs.liquid_handling.hamilton.modules.iswap import Direction

All of the iSWAP's pick and place methods contain a direction parameter that accepts values from this enum. This parameter determines from which side the iSWAP approaches the labware for the operation. It is possible to use the corresponding integer values directly (1-4), but we recommend importing and using the enum values for better code readability.

Basic Setup

Here we describe the necessary steps to initialize and configure the iSWAP module for operation.

Power On the System

Ensure that the Microlab STAR is powered on and ready for operation. Verify that the connector is running and connected to the UniteLabs platform.

from unitelabs.sdk import AsyncApiClient
from unitelabs.liquid_handling.hamilton import MicrolabSTAR

client = AsyncApiClient()

# Initialize the Hamilton Microlab STAR
hamilton = MicrolabSTAR(
    name="Microlab STAR", # Or your connector's name on the UniteLabs platform
    client=client,
)
await hamilton.initialize()

Arrange the Deck

Arrange the deck layout using the components from the labware library. This guide uses a plate carrier with one standard 96 well microtiter plate that we move from one carrier site to another.

from unitelabs.labware import Standard96Plate, Vector
from unitelabs.labware.hamilton import PLT_CAR_L5MD_A00

plate_carrier = PLT_CAR_L5MD_A00()
plate = Standard96Plate()

plate_carrier[0] = plate
hamilton.deck.add(plate_carrier, track=1)

Using the iSWAP

Pick up Labware

Training locations should be done with labware in the iSWAP to ensure accuracy. This ensures that the positioning is valid for the specific labware to be transferred. Make sure that the plate is placed on the site and pass it to the iSWAP's pick_up_from method. The iSWAP moves on a safe traverse height to the site and picks up the plate. The method automatically transfers the plate from the carrier site to the iSWAP module. When the pick_up_direction argument is omitted, the iSWAP will approach from whichever orientation it is currently in. Here the strength parameter is set to the default value, which is used if not specified.

from unitelabs.liquid_handling.hamilton.modules.iswap.interfaces import Direction

await hamilton.iswap.pick_up_from(
    plate_carrier[0],
    # The direction from which the iSWAP arm approaches the labware to pick up.
    pick_up_direction=Direction.LEFT,
    # The pressure to apply on the plate ranging from 0 (low) to 99 (high).
    strength=30,
)

The parameters such as grip width and grip height are determined based on the definition of the labware that is being picked up while others have default values. All parameters can be specified explicitly if desired:

• pick_up_direction: Approach direction (Direction.FRONT, RIGHT, BACK, or LEFT). Default: None (uses current orientation).
• strength: Grip pressure ranging from 0 (low) to 99 (high). Default: 30.
• pick_up_offset: A Vector(dx, dy) offset in mm to adjust the pick up location. Default: None.
• width_offset: Offset in mm to adjust the labware size for grip width calculation. Default: 0.
• grip_gap: Initial gap in mm between the gripper and the labware. Default: 6.

The plate is now accessible on the iSWAP and the carrier site should be empty.

assert plate_carrier[0].get() == None
assert hamilton.iswap.get() == plate

Move Labware

Now that the plate is picked up, it can be moved to another position. The plate's center will be placed at the provided location. In move_to, the direction parameter specifies the approach direction for the iSWAP arm.

# Location 20 mm above the 5th carrier site's center
target_location = plate_carrier[4].absolute_location \
    + plate_carrier[4].center.update(z=20)

await hamilton.iswap.move_to(
    location=target_location,
    direction=Direction.RIGHT,
)

Release Labware

Labware can only be placed on carrier sites. Make sure that the site is empty and pass it to the iSWAP's put_down method. The method automatically transfers the plate from the iSWAP module to the site. The drop_direction parameter specifies the approach direction for the iSWAP arm when putting down the labware.

await hamilton.iswap.put_down(
    # The carrier's 5th site
    carrier_site=plate_carrier[4],
    # The direction from which the iSWAP arm approaches the labware to put it down.
    drop_direction=Direction.LEFT
)

The plate is now accessible on the carrier site and the iSWAP should be empty again.

assert hamilton.iswap.get() == None
assert plate_carrier[4].get() == plate

Home iSWAP

Repeat the above steps as necessary to manipulate additional labware. When you are done, using any other tool (e.g. the CoRe96 pipetting head) will return the iSWAP back to its home position. You can also home iSWAP explicitly:

await hamilton.iswap.home()

Conclusion

You should now be able to utilize the iSWAP gripper as an efficient solution for transporting labware during liquid handling workflows.