pylabrobot.agilent.benchcel.BenchCel4R#

class pylabrobot.agilent.benchcel.BenchCel4R(name: str, host: str, *, port: int = 7612, timeout: float = 30.0, read_poll_timeout: float = 0.25, loading_tray_teachpoint_id: int | None = None, source_ip: str | None = None, stacks: Sequence[ResourceStack] | None = None, labware: Plate | BenchCelLabwareSettings | dict | None = None, loading_tray_location: Coordinate | None = None, size_x: float = 0.0, size_y: float = 0.0, size_z: float = 0.0, rotation: Rotation | None = None, category: str | None = None, model: str | None = 'Agilent BenchCel 4R')#

Bases: Resource

Agilent BenchCel 4R microplate handler.

The BenchCel is a sequential (“stacking access”) storage device: each of its four stackers is a single-ended LIFO stack of plates. The device exposes downstack/upstack transfers and tracks the expected plate order in four ResourceStack objects.

The four ResourceStack stacks track the expected plate order/content of each stacker.

Attributes

location

Where this resource sits, relative to its parent.

name

Get the name of this resource.

stacks

The four configured stacks, ordered by human stacker number.

Methods

__init__(name, host, *[, port, timeout, ...])

assign_child_by_anchor(resource[, ...])

Assign a child resource by aligning anchor points.

assign_child_resource(resource, location[, ...])

Assign a child resource to this resource.

at(location)

Return a copy of this resource at the given location.

center([x, y, z])

Get the center of this resource.

centers([xn, yn, zn])

Get equally spaced points in the x, y, and z directions.

check_can_drop_resource_here(resource, *[, ...])

Validate whether resource may be dropped onto this resource.

close_robot_gripper(*[, timeout])

Fully close the robot gripper.

close_stacker_clamps(stack, *[, timeout])

Close one stacker's pneumatic clamps using command 0x67.

copy()

deregister_did_assign_resource_callback(callback)

Remove a callback that will be called after a resource is assigned to this resource.

deregister_did_unassign_resource_callback(...)

Remove a callback that will be called after a resource is unassigned from this resource.

deregister_state_update_callback(callback)

Remove a callback that will be called when the state of the resource changes.

deregister_will_assign_resource_callback(...)

Remove a callback that will be called before a resource is assigned to this resource.

deregister_will_unassign_resource_callback(...)

Remove a callback that will be called before a resource is unassigned from this resource.

deserialize(data[, allow_marshal])

Deserialize a resource from a dictionary.

downstack(stack, *[, timeout])

Move the accessible plate of stack to the loading teachpoint.

find_resource([fn, metadata, has_metadata, ...])

Find the first matching resource, or None if not found.

find_resources([fn, metadata, has_metadata, ...])

Find resources matching top-level attributes, metadata, and/or a predicate.

get_absolute_location([x, y, z])

Get the absolute location of this resource, probably within the pylabrobot.resources.Deck.

get_absolute_rotation()

Get the absolute rotation of this resource.

get_absolute_size_x()

Get the absolute size in the x direction.

get_absolute_size_y()

Get the absolute size in the y direction.

get_absolute_size_z()

Get the absolute size in the z direction.

get_all_children()

Recursively get all children of this resource.

get_anchor([x, y, z])

Get a relative location within the resource.

get_highest_known_point()

Recursively finds the highest known point in absolute space.

get_location_wrt(other[, x, y, z])

Get the location of this resource with respect to another resource.

get_resource(name)

Get a resource by name.

get_root()

Get the root of the resource tree.

get_size_x()

Local size in the x direction.

get_size_y()

Local size in the y direction.

get_size_z()

Local size in the z direction.

has_resource(name)

Whether anything at or beneath this resource carries the given name.

home(*[, timeout])

Home all BenchCel motors and reconnect when the device becomes responsive.

is_in_subtree_of(other)

Return True if self is in the subtree rooted at other.

load_all_state(state)

Load state for this resource and all children.

load_from_json_file(json_file)

Loads resources from a JSON file.

load_state(state)

Load state for this resource only.

load_state_from_file(fn)

Load the state of this resource and all children from a JSON file.

move_plate_between_stacks(source, destination, *)

Move the accessible plate between two configured stacks and update PLR state.

move_to_stacker(stack, *[, timeout])

Move the arm to one of this BenchCel's configured stacks.

move_to_teachpoint(teachpoint_id, *[, ...])

Move to a teachpoint target id using command 0x65.

named(name)

Return a copy of this resource with the given name.

open_robot_gripper(*[, timeout])

Fully open the robot gripper.

open_stacker_clamps(stack, *[, timeout])

Open one stacker's pneumatic clamps using command 0x67.

register_did_assign_resource_callback(callback)

Add a callback that will be called after a resource is assigned to this resource.

register_did_unassign_resource_callback(callback)

Add a callback that will be called after a resource is unassigned from this resource.

register_state_update_callback(callback)

Register a callback that will be called when the state of the resource changes.

register_will_assign_resource_callback(callback)

Add a callback that will be called before a resource is assigned to this resource.

register_will_unassign_resource_callback(...)

Add a callback that will be called before a resource is unassigned from this resource.

request_all_stacker_sensor_statuses(*[, ...])

Return sensor status keyed by human stacker number 1-4.

request_arm_pose(*[, timeout])

Return the decoded arm location, rotation, and robot-gripper position.

request_axis_limits(*[, timeout])

Return per-axis travel limits as {axis: (minimum, maximum)}.

request_stacker_sensor_status(stack, *[, ...])

Return the sensor status for one configured stack.

request_status(*[, timeout])

Send 87 00 00 and return decoded/raw general status.

request_status_snapshot(*[, ...])

Return all stacker sensors and the general status from one polling cycle.

rotate([x, y, z, pivot_coordinate])

Rotate counter-clockwise around the parent-coordinate axes by the given degrees.

rotate_to([x, y, z, pivot_coordinate])

Set the rotation about each axis, where rotate turns by an amount instead.

rotated([x, y, z, pivot_coordinate])

Return a copy of this resource rotated by the given number of degrees.

save(fn[, indent])

Save a resource to a JSON file.

save_state_to_file(fn[, indent])

Save the state of this resource and all children to a JSON file.

serialize()

serialize_all_state()

Serialize the state of this resource and all children.

serialize_state()

Serialize the state of this resource only.

set_labware(labware, *[, timeout])

Push labware geometry to the BenchCel using the 0x7d settings command.

set_teachpoint(teachpoint, *[, timeout])

Write a numeric teachpoint with command 0x73.

setup()

Open the TCP connection to the BenchCel.

stop()

Close the TCP connection.

unassign()

Unassign this resource from its parent.

unassign_child_resource(resource)

Unassign a child resource from this resource.

upstack(stack, *[, timeout])

Move a plate from the loading teachpoint onto stack.
Parameters: