HexapodDevice

class lsst.ts.athexapod.HexapodDevice

Bases: object

Implement a fake PI Hexapod controller.

Methods Summary

activate_soft_limit(x, y, z, u, v, w)	Activate the software limits.
check_offset(x, y, z, u, v, w)	Check that the hexapod can move.
format_check_active_soft_limit()	Check that the software limits are active.
format_clv()	Return the closed loop velocity.
format_controller_ready()	Return formatted controller ready response.
format_error()	Return get error string
format_high_position_soft_limit()	Return formatted higher position software limit string.
format_low_position_soft_limit()	Return formatted lower position software limit string.
format_motion_status()	Return formatted motion status response.
format_offset(x, y, z, u, v, w)	Set offset for hexapod.
format_on_target()	Return formatted on target string.
format_pivot_point()	Return formatted get pivot point string
format_position_unit()	Return formatted get position unit string.
format_real_position()	Return formatted position response.
format_referencing_result()	Return formatted reference result.
format_sv()	Return the system velocity.
format_target_position()	Return formatted string for target position
parse_message(line)	Parse the message and return a response if any.
reference()	Reference the hexapod.
set_clv(x, y, z, u, v, w)	Set the closed loop velocity.
set_high_position_soft_limit(x, y, z, u, v, w)	Set higher position software limit.
set_low_position_soft_Limit(x, y, z, u, v, w)	Set the lower position software limit. Parameters ---------- x : float The x axis minimum software limit. y : float The y axis minimum software limit. z : float The z axis minimum software limit. u : float The u axis minimum software limit. v : float The v axis minimum software limit. w : float The w axis minimum software limit.
set_pivot_point(x, y, z)	Set the pivot point.
set_position(x, y, z, u, v, w)	Set the position.
set_sv(velocity)	Set the system velocity.
stop_all_axes()	Stop all axes.

Methods Documentation

async activate_soft_limit(x: float, y: float, z: float, u: float, v: float, w: float) → None

Activate the software limits. Parameters ———- x : float y : float z : float u : float v : float w : float

async check_offset(x: float, y: float, z: float, u: float, v: float, w: float) → str

Check that the hexapod can move. Parameters ———- x : float y : float z : float u : float v : float w : float

async format_check_active_soft_limit() → None

Check that the software limits are active.

async format_clv() → None

Return the closed loop velocity.

async format_controller_ready() → str

Return formatted controller ready response.

async format_error() → str

Return get error string

async format_high_position_soft_limit() → str

Return formatted higher position software limit string.

async format_low_position_soft_limit() → str

Return formatted lower position software limit string.

async format_motion_status() → str

Return formatted motion status response.

async format_offset(x: float, y: float, z: float, u: float, v: float, w: float) → None

Set offset for hexapod. Parameters ———- x : float y : float z : float u : float v : float w : float

async format_on_target() → None

Return formatted on target string.

Not implemented.

async format_pivot_point() → str

Return formatted get pivot point string

async format_position_unit() → None

Return formatted get position unit string.

async format_real_position() → str

Return formatted position response.

async format_referencing_result() → str

Return formatted reference result.

async format_sv() → str

Return the system velocity.

async format_target_position() → str

Return formatted string for target position

async parse_message(line: str) → None | str

Parse the message and return a response if any.

Parameters:

linestr

The command received.

Returns:

Optional[str]

Returns a string response if expected.

Raises:

Exception

Raised if command is not implemented.

async reference() → None

Reference the hexapod.

async set_clv(x: float, y: float, z: float, u: float, v: float, w: float) → None

Set the closed loop velocity. Parameters ———- x : float y : float z : float u : float v : float w : float

async set_high_position_soft_limit(x: float, y: float, z: float, u: float, v: float, w: float) → None

Set higher position software limit. Parameters ———- x : float y : float z : float u : float v : float w : float

async set_low_position_soft_Limit(x: float, y: float, z: float, u: float, v: float, w: float) → None

Set the lower position software limit. Parameters ———- x : float

The x axis minimum software limit.

yfloat

The y axis minimum software limit.

zfloat

The z axis minimum software limit.

ufloat

The u axis minimum software limit.

vfloat

The v axis minimum software limit.

wfloat

The w axis minimum software limit.

async set_pivot_point(x: float, y: float, z: float) → None

Set the pivot point. Parameters ———- x : float y : float z : float

async set_position(x: float, y: float, z: float, u: float, v: float, w: float) → None

Set the position. Parameters ———- x : float y : float z : float u : float v : float w : float

async set_sv(velocity: int) → None

Set the system velocity. Parameters ———- velocity : int

async stop_all_axes() → None

Stop all axes.

Not implemented due to axes not actually moving naturally.