Inheco ODTC#

Inheco
ODTC
WIPv1
thermocycler
thermocyclingheatingactive cooling
Models
ModelSupport
96-wellWIP
384-wellWIP
APIpylabrobot.inheco.ODTC

Property

Value

Connection

Ethernet, SiLA 1 SOAP; device port 8080

Models

96-well and 384-well

Block temperature

4–99 °C

Lid temperature

30–110 °C (96); 30–115 °C (384)

Units

°C, seconds, microliters

Hardware verification required for this implementation on both variants. Offline tests cover protocol compilation and simulated communication; they do not establish thermal accuracy or safe robotic placement. setup() logs a warning until a verified hardware run is reported.

Connection and physical setup#

Connect the ODTC controller to Ethernet and power, following the manufacturer’s operating manual. Configure an address reachable from this computer. The instrument sends completion and temperature callbacks to the computer: allow the selected client_ip and callback_port through its firewall. The default callback port is chosen automatically. Supply a fixed port if firewall rules require it.

The driver opens no connection during construction. plate_holder represents the plate location; its zero child offset is not a measured loading position. Calibrate its placement before robotic transfers. Load compatible labware manually for an initial hardware check.

The controls below move and heat real hardware. Run them only when the instrument and labware are ready.

from pylabrobot.inheco import ODTC
from pylabrobot.inheco.odtc import (
    ODTCProtocol, ODTCStage, ODTCStep, compile_protocol, method_set_to_xml, ODTCMethodSet,
)

odtc = ODTC(
    name="odtc",
    odtc_ip="192.168.1.50",  # use the configured instrument address
    variant=96,
    # client_ip="192.168.1.10",  # computer interface reachable from the ODTC
    # callback_port=8081,
)

Set up#

Set up the HTTP connection and callback listener, register the listener, and initialize the device. Setup refuses to reset a busy or faulted instrument. Calling it again on an established session leaves the session intact. simulation_mode=True selects the instrument firmware’s simulation mode; it is not an offline simulator.

await odtc.setup()

Open the drawer#

Open and wait for command completion. Repeating an already confirmed open or close does not issue another movement. The firmware provides no door-position query: door_open is the last command-confirmed state, or None after connection, a failed movement, or a fault.

await odtc.open_door()

Load the plate, then close#

Place the plate on the ODTC mount before running this cell.

await odtc.close_door()

Read temperatures#

Read all eight sensors in degrees C. This operation is also available while a method is running.

temperatures = await odtc.request_temperatures()
print(temperatures)

Define a temperature profile#

ODTCStep holds a target temperature and duration. ODTCStage repeats an ordered sequence of steps or nested stages. Temperatures, durations, and ramp rates are checked before upload. Native methods are limited to 100 steps; deeply nested loops sharing an endpoint may need expansion.

Lid temperature and maximum sample volume are supplied per run. An explicit step lid temperature or ramp rate overrides the run’s lid default or the variant’s transition rate.

protocol = ODTCProtocol(stages=[
    ODTCStage([ODTCStep(95, duration=300)]),
    ODTCStage([
        ODTCStep(95, duration=30),
        ODTCStep(55, duration=30),
        ODTCStep(72, duration=60),
    ], repeats=30),
    ODTCStage([ODTCStep(72, duration=600), ODTCStep(4, duration=30)]),
])

Inspect the native method without hardware#

Compilation is pure Python. The volume selects the device’s compensation range: below 30 µL, 30–below 75 µL, or 75–100 µL. The volume must be positive and no greater than 100 µL.

Automatic empirical overshoot is disabled by default: the coefficients have not been validated against a manufacturer reference or this implementation’s hardware runs. apply_overshoot=True opts in with a warning. A loop entry with different incoming temperatures requires explicit ODTCOvershoot settings because a single calculated excursion would be ambiguous. Its temperature is an excursion magnitude, not an absolute target. Explicit overshoot and PID settings are retained in native XML round trips. Validate thermal compensation on the actual model and labware.

method = compile_protocol(protocol, variant=96, volume=25, lid_temperature=105)
print(method_set_to_xml(ODTCMethodSet(methods=[method])))

Run: prepare, execute, and wait#

run_protocol uploads the method, runs a matching block/lid premethod when necessary, and waits for completion. Preparation can take several minutes. It waits for firmware completion rather than merely observing the target on a temperature sensor. Compatible conditions retained from a completed premethod or post-heated method can be reused within the session.

The firmware executes timed temperature steps because its command interface has no direct block-setpoint primitive. PLR performs compilation and sequencing.

post_heating=True keeps regulation at the final step after completion. Pass False to disable it. timeout limits each execution wait; a timeout does not stop the instrument.

await odtc.run_protocol(protocol, volume=25, lid_temperature=105, post_heating=True)

Read measured progress#

The latest callback provides elapsed time and target, block, and lid temperatures. None means no sample has arrived for this execution. Step numbers, cycle counts, and estimated remaining time are not reported as measured device state.

progress = await odtc.request_progress()
print(progress)

Stop temperature control#

This stops an active method or regulation remaining after a method or premethod. It remains available while run_protocol() is awaiting completion. An interrupted run raises ODTCProtocolStopped. To run concurrently with other work, create an asyncio task for run_protocol; canceling that task only cancels the wait. Call stop_protocol() to stop the hardware. A later wait_for_completion() still observes completion errors.

await odtc.stop_protocol()

Prepare independently#

Use explicit preparation when the block and lid should be ready before loading a plate. The same preparation is included in run_protocol. Temperatures are per-operation arguments.

await odtc.prepare(temperature=95, lid_temperature=105)

Store a named method#

Compile with a persistent name, then upload. Existing names require overwrite=True. The plr_currentProtocol and plr_currentPreMethod slots are reserved for the driver’s working methods; unnamed runs replace only these slots. Uploads never clear the instrument’s method library.

stored_method = compile_protocol(
    protocol, name="StandardPCR", variant=96, volume=25, lid_temperature=105,
)
await odtc.upload_protocol(stored_method)

Retrieve methods#

Downloaded ODTCMethod objects retain native step numbers, loop targets/counts, independent overshoot rates, PID sets, and metadata. They can be inspected or edited using dataclasses.replace, then uploaded explicitly. request_method_set() includes premethods too.

stored = await odtc.request_protocol("StandardPCR")
print(stored)

Run a stored method#

Use its stored volume, lid, and ramp settings. PLR prepares matching initial thermal conditions before executing it.

await odtc.run_stored_protocol("StandardPCR")

Disconnect#

stop() stops temperature control and closes the HTTP connection and callback server. Transport cleanup also runs if the stop command fails; the exception still reports that the device did not confirm stopping.

await odtc.stop()

Variant verification and protocol references#

Choose variant=384 for a 384-well unit. Its current compiler limits are 5 °C/s heating and 115 °C lid, compared with 4.4 °C/s and 110 °C for the 96-well unit. Both use a 2.2 °C/s cooling limit. The variant codes, plate types, volume compensation, and limits need confirmation on each hardware variant; passing mock tests is not hardware validation.

The wire format, method storage, premethod sequence, callback sample units, and return codes are covered by the INHECO Firmware Command Set v1.06 (sections 3, 5, 6, 7.3, 9, and 10). This 2016 document does not establish which firmware revision is installed on a particular device. Record the instrument and firmware version when reporting a hardware verification run. The tests use its example method and data series as fixtures, alongside simulated SOAP exchanges. Thermal overshoot coefficients are not established by that command-set document.