Tecan Infinite 200

The Tecan Infinite 200 connector connects the reader over USB without running Tecan's i-control software. Use GroundControl to check the available read actions, then read a plate from a notebook in the platform's IDE.

What you need

Install and configure the connector

1. In GroundControl, add a connector and search for Tecan Infinite 200 (connector configuration).
2. Prepare USB access for your operating system:
   • Windows: Install i-control for its USB driver, then close it before starting the connector. If the reader already uses a Zadig driver, see usbio below.
   • macOS: Connect the reader by USB and leave usbio unset to use libusb.
   • Linux: Have the host administrator create /etc/udev/rules.d/99-tecan-infinite.rules with the line below. Run sudo udevadm control --reload-rules && sudo udevadm trigger, then unplug and reconnect the reader. Run the connector as your normal user.

     SUBSYSTEM=="usb", ATTRS{idVendor}=="0c47", MODE="0666"
     

     
     This rule grants USB access to all Tecan devices with vendor id 0c47 on the host. lsusb -d 0c47: lists matching devices.
3. Fill in the connector configuration:

   Field	Value
   simulation_mode	Defaults to true: measurements return synthetic data and the reader does not move. Set to false to use the reader.
   device	Available from connector version 0.2.0. Leave unset for automatic selection, or set the reader's USB product id (0x8001, decimal 32769, for the F200; 0x8007, decimal 32775, for the M200 Pro).
   usbio	Leave unset to use the vendor USB driver on Windows and libusb elsewhere. Set to false on Windows if the reader was rebound with Zadig. Setting true outside Windows prevents connection.

4. Start the connector with simulation_mode set to false and enable platform connectivity. In GroundControl, inspect the instrument capabilities under Device Provider and note the service name for Python.

Simulation mode registers every module regardless of what is attached. With simulation_mode set to false, the connector registers only the modules the reader has: without a heater there is no TemperatureController; M-series readers have no FilterController. A read action appears only if the reader supports that measurement type. Readers with the same model name can differ. Check the modules in GroundControl or, once connected from Python, with print(reader.modules.keys()).

Under Measurement Controller in GroundControl, check whether Read Absorbance, Read Fluorescence Intensity, or both are available. For F-series readers, also run Get All Filter Definitions to find the installed filters for that read type.

First successful test

Sign in to the UniteLabs platform in the browser and open IDE. Create a notebook and paste each block into its own cell. The notebook signs in with your platform account, so the blocks need no credentials. If the first line, from unitelabs.sdk import AsyncApiClient, fails, the SDK is not installed on your tenant yet; ask your UniteLabs contact to install it.

Before running a script, extend the carrier and place a 96-well plate on it. In GroundControl, use Carrier Controller, then Extend. If you already have a connected Python variable named reader, you can instead run await reader.carrier_controller.extend(). The script retracts the carrier with the plate before it reads.

Select the tab for your type of reader below. Each script connects, retracts the carrier, and reads well A1. Adjust the measurement settings for your assay.

Replace the service name with the one shown in GroundControl. Keep all shown parameters explicit: omitting wells selects the whole plate.

Wavelengths and bandwidths are in nanometres. settle_time is in milliseconds; lag_time and integration_time are in microseconds.

from unitelabs.sdk import AsyncApiClient

client = AsyncApiClient()
# "Tecan Infinite 200" is the service name you set in GroundControl
reader = await client.get_service_by_name(name="Tecan Infinite 200")
measurement = reader.measurement_controller

await reader.carrier_controller.retract()
print(await measurement.read_fluorescence_intensity(
    excitation_wavelength=430, excitation_bandwidth=20,  # ExcitationWavelength, ExcitationBandwidth
    emission_wavelength=535, emission_bandwidth=25,      # EmissionWavelength, EmissionBandwidth
    mode="top", flashes=10, settle_time=0, gain_value=30, lag_time=0,
    integration_time=20, plate_layout="96", wells=["A1"], z_position=0,
))

from unitelabs.sdk import AsyncApiClient

client = AsyncApiClient()
# "Tecan Infinite 200" is the service name you set in GroundControl
reader = await client.get_service_by_name(name="Tecan Infinite 200")
measurement = reader.measurement_controller

await reader.carrier_controller.retract()
print(await measurement.read_absorbance(
    wavelength=600, bandwidth=10,  # ExcitationWavelength, ExcitationBandwidth
    reference_wavelength=0, flashes=10, settle_time=0, plate_layout="96", wells=["A1"],
))

from unitelabs.sdk import AsyncApiClient

client = AsyncApiClient()
# "Tecan Infinite 200" is the service name you set in GroundControl
reader = await client.get_service_by_name(name="Tecan Infinite 200")
measurement = reader.measurement_controller

filters = await measurement.get_all_filter_definitions()
abs_filter = next((f for f in filters if f["Usage"] == "absorbance"), None)
fi_filter = next((f for f in filters if f["Usage"] == "fluorescence intensity"), None)

await reader.carrier_controller.retract()
if abs_filter:
    print("Absorbance with slot", abs_filter["Slot"])
    print(await measurement.read_absorbance(
        wavelength=abs_filter["ExcitationWavelength"],
        bandwidth=abs_filter["ExcitationBandwidth"],
        reference_wavelength=0, flashes=10, settle_time=0, plate_layout="96", wells=["A1"],
    ))
elif fi_filter:
    print("Fluorescence intensity with slot", fi_filter["Slot"])
    print(await measurement.read_fluorescence_intensity(
        excitation_wavelength=fi_filter["ExcitationWavelength"],
        excitation_bandwidth=fi_filter["ExcitationBandwidth"],
        emission_wavelength=fi_filter["EmissionWavelength"],
        emission_bandwidth=fi_filter["EmissionBandwidth"],
        mode="top", flashes=10, settle_time=0, gain_value=30, lag_time=0,
        integration_time=20, plate_layout="96", wells=["A1"], z_position=0,
    ))
else:
    print("No absorbance or fluorescence intensity filter on the slide:", filters)

from unitelabs.sdk import AsyncApiClient

client = AsyncApiClient()
# "Tecan Infinite 200" is the service name you set in GroundControl
reader = await client.get_service_by_name(name="Tecan Infinite 200")
measurement = reader.measurement_controller

await reader.carrier_controller.retract()
print(await measurement.read_absorbance(
    wavelength=600, reference_wavelength=0, bandwidth=10,
    flashes=10, settle_time=0, plate_layout="96", wells=["A1"],
))

from unitelabs.sdk import AsyncApiClient

client = AsyncApiClient()
# "Tecan Infinite 200" is the service name you set in GroundControl
reader = await client.get_service_by_name(name="Tecan Infinite 200")
measurement = reader.measurement_controller

await reader.carrier_controller.retract()
print(await measurement.read_fluorescence_intensity(
    excitation_wavelength=485, excitation_bandwidth=9,
    emission_wavelength=535, emission_bandwidth=20,
    mode="top", flashes=10, settle_time=0, gain_value=30, lag_time=0,
    integration_time=20, plate_layout="96", wells=["A1"], z_position=20000,
))

From your own IDE

You can also write the code on your own computer, for example to turn it into a workflow that runs on the platform. This needs a development machine with the SDK installed and authenticated, which includes API client credentials in a .env file.

A Python file cannot use await at the top level. Put the lines of a block into an async function and start it with asyncio, as in Send your first request:

import asyncio

from dotenv import load_dotenv
from unitelabs.sdk import AsyncApiClient


async def main():
    client = AsyncApiClient()
    reader = await client.get_service_by_name(name="Tecan Infinite 200")
    ...  # the remaining lines of the block, indented


if __name__ == "__main__":
    load_dotenv()
    asyncio.run(main())

To run the code on the platform, package it as a workflow. Automate your workflows writes a workflow in one file and runs it locally, and Deploy a workflow ships it to the platform.

Known quirks and errors

More snippets

• Unload the plate: await reader.carrier_controller.extend() after a completed read.
• Stop a read: await reader.measurement_controller.stop_reading().
• Choose wells: pass ["A1"], a list, a range such as ["A1-C7"], or ["ALL"]. Results follow plate order. Pair returned WellIds with returned Intensities or Absorbances.
• Watch the reader: device_provider.subscribe_state(), carrier_controller.subscribe_is_extended() and, on F-series readers, filter_controller.subscribe_is_inserted() report current state when you subscribe, then updates. Measurement streams subscribe_fluorescence_intensity_readings() and subscribe_absorbance_readings() emit values as each plate row completes.
• Plate layouts: set plate_layout to "96", "384" or "custom". Define a custom layout first with define_custom_plate_layout() under Measurement Controller.
• Shake: if Shaker Controller is available, await reader.shaker_controller.start(mode="orbital", amplitude=2.0, duration=10) shakes for 10 seconds at a 2 mm amplitude and returns when finished.
• Heat: on readers with a heater, the temperature controller offers start, stop and a target temperature up to 42 °C. Its sensor reports the target, with no live temperature read-back.
• Timing: on an F200, fluorescence at 25 flashes and 20 microseconds integration takes about 15 s for three wells and 85 s for 96 wells through the platform. Timing varies with the reader and settings.

One read handles one wavelength, or one excitation and emission pair; there is no spectral-scan action. For multiple wavelengths, run separate reads at the settings you need.

Connector reference

Vendor documentation

Tecan's i-control Instructions for Use covers operating the reader through the vendor software. Use the instrument's own manual for operating limits, plate handling, maintenance and safety. This page covers the UniteLabs connection and first Python read.