Connecting to Tecan Fluent#

This guide will walk you through how to connect Artificial to Tecan FluentControl using the Tecan Fluent Resource Library.

Attention

Before you get started, make sure your local Adapter development environment is set up and ready to go.

Supported Tecan Fluent versions#

Tecan Fluent 2.7, 3.1.11, 3.3, 3.6 with DeckCheck

Install the driver#

Download and install the Artificial Tecan Fluent Driver on the PC where FluentControl is running.

Note

For more information on how to install and configure the Driver, see our guide on Installing and Configuring Device Drivers.

Install the Resource Library in your Adapter#

Run the following command in the terminal of your adapter repository to install Artificial’s Tecan Fluent Resource Library:

uv add artificial-fluent-resource-library==3.0.*

Your pyproject.toml file should now include artificial-fluent-resource-library in the project dependencies section:

[project]
dependencies = [
  ...
  "artificial-fluent-resource-library==3.0.*",
]

Update your Adapter Config#

config.yaml#
adapter:
  name: FluentTutorialAdapter
  remoteConfig: False
  allowAnySequenceId: True # Useful when running in a local dev container
  plugin: # all resources this adapter can connect to
    resource:
      name: "Fluent"  # user friendly name, unique in the adapter
      id: "fluent" # This should match the device key in the asset_sync section below
      driver:
        name: "tecan" # Driver name, this is a non-configurable string that needs to match the driver identity
        url: "http://fluent.webaddress.com:49835" #  URL of the hardware and driver
        resource_simulation: false     # Set to true to run simulation without hardware
        driver_simulation: false       # Set to true to run simulation without a driver
        cert_file: "adapter/certs/ca.crt"
        user_name: ""  # user name if needed for the fluent software login
        user_password: ""  # password if needed for fluent software login
  asset_sync:
    devices: # device string names/prefix must match resource id above
       "fluent": { rid: "d1234567-34d0-4391-be64-7aef4e0b28be" }

  1. Fill in the correct URL (including the port) for the Fluent device. The device’s IPv4 URL can be obtained from Network & Internet Settings or by running ipconfig in a command window. The port is listed in the running driver server console window.

    Where to find the port number in the driver console window

  2. You may update the resource name above if you wish. Any string will work but it must be unique across the instance.

  3. Fill in the user_name and password if needed.

  4. If you wish to run in simulation without hardware or without a driver, change resource_simulation or driver_simulation to true, respectively.

  5. Update the asset_sync section to map the resource id to the instrument’s asset instance id in the digital twin. You can fill out the rest of the devices later. See Asset Sync Config for more information.

Use the Resource Library in your Adapter#

adapter/main/plugin.py file#
from artificial.adapter_common import ActionModulePlugin, action_modules
from artificial.adapter_common.plugin import PluginContext, plugin_config
from artificial.fluent.actions import FluentActions
from artificial.fluent.core import FluentResource
from artificial.fluent.driver_client_simulator import FluentDriverMock
from artificial.fluent.event_handler import FluentEventHandler
from artificial.fluent.models import FluentPluginConfig
from artificial.logging import get_logger
from artificial.resource_base.asset_syncer import ResourceAssetSyncer
from artificial.resource_base.models import SyncConfig

logger = get_logger(__name__)


@action_modules(FluentActions)
class AdapterPlugin(ActionModulePlugin):
    # Register the config to be used by the adapter
    _cfg = plugin_config(FluentPluginConfig)

    async def setup(self, pctx: PluginContext) -> None:
        prog_config = pctx.config
        plugin_conf = self._cfg
        sync_config: SyncConfig = pctx.raw_config.to_dataclass(SyncConfig, 'adapter.asset_sync')
        logger.debug(f'sync_config loaded: {sync_config}')

        # all resources in the adapter use the same res_syncer
        syncer = pctx.asset_sync_manager_v1(f'ResourceSyncer-{prog_config.adapter.name}')
        res_syncer = ResourceAssetSyncer(syncer, sync_config)
        await res_syncer.initialize()

        # create instances of resources for this adapter
        resource = FluentResource(
            pctx.alabPyBase,
            lab_id=prog_config.artificial.labId,
            adapter_id=prog_config.adapter.name,
            resource_id=plugin_conf.resource.id,
            name=plugin_conf.resource.name,
            res_syncer=res_syncer,
        )

        if resource:  # hook up action modules and event handlers
            resource.set_driver(driver_config=plugin_conf.resource.driver, simulator=FluentDriverMock())
            await resource.set_health_monitors(pctx.lab.health)
            # register custom action module
            module = FluentActions(resource)
            self.add_module(module)
            logger.debug('Fluent Action module added.')

            # subscribe to the events
            event_handler = FluentEventHandler(resource)
            resource.add_event_handler(event_handler)

Add the required Actors#

Add the following actors to the list of actors in adapter/main/__main__.py.

adapter/main/__main__.py#
actors = [
    ActorConfig(id='tecan', abilities={'tecan': 1, 'substrate': 1, 'fluent': 1}),
    ActorConfig(id='fluent', abilities={'exclusive_locks_global': 1, 'exclusive_locks_fluent': 1}),
]

Publish and run a test Workflow#

This workflow will run your chosen method and log a message in the UI upon successful completion. You will define which method in the request UI by inputting the method name (e.g., mymethod).

Note

Update the variable params to reflect the needs of your protocol. If your protocol does not require variables, set params to an empty list ([]).

from typing import List

from artificial.workflows.decorators import parameter, workflow
from artificial.workflows.runtime import show_info
from stubs.stubs_actions import VariableType, run_method_to_completion


@workflow('Simple Fluent Connectivity Test Workflow', 'simple_fluent_connectivity_test_workflow')
@parameter('samples', {'uiTitle': 'Samples', 'required': True, 'uiWidget': 'numeric'})
@parameter('protocol_name', {'uiTitle': 'ProtocolName', 'required': True, 'uiWidget': 'text'})
async def simple_fluent_connectivity_test_workflow(
    protocol_name: str = '',
    samples: int = 2,
) -> None:

    params: List[VariableType] = [
        VariableType(var_name='samples', var_value=str(samples), var_type='string'),
    ]

    await run_method_to_completion(protocol_full_name=protocol_name, parameters=params)
    await show_info('Congratulations, you successfully ran your hardware!', 'Hardware Success')