System

class mundo.api.system.ProbeState(
value
)

The current status of the insertion and ejection of the probe. This keeps track on whether or not the probe is fully inserted, fully ejected, or somewhere inbetween.

EJECTED = 0

EJECT_IN_PROGRESS = 1

INSERT_IN_PROGRESS = 2

INSERTED = 3

class mundo.api.system.System(
load_plugins: bool = True
)

This class defines the interface used by the GUI. It controls the x,y,z-stages as a complete system. Thus abstracting the individual motors from the user interface.

__init__(
load_plugins: bool = True
) → None

Sets the configuration object and creates the x,y,z-stage motor objects.

Parameters

load_plugins – If plugins should be loaded, defaults to True

property context: mundo.api.context.ApplicationContext

Returns the application context.

Returns

The application context

property connection: mundo.api.connection.ConnectionManager

Return the internal connection manager instance of the ConnectionManager class. This allows you to manage the connection of the underlying controllers.

Returns

The connection manager instance

property plugins: mundo.api.plugins.PluginManager

The plugin manager instance.

Returns

A reference to the plugin manager instance

property probe_state: mundo.api.system.ProbeState

The current state of the insertion/ejection process.

broadcast(
event: mundo.api.events.Event,
*args
) → None

Broadcasts an event to plugins and registered event listeners.

Parameters

• event – The event to broadcast

• *args – Event arguments, if any

reload_plugins() → None

Reloads and reactivates application plugins. This will re-interpret the code exported by each available plugin, as well as re-render the plugins in the GUI.

get_current_position() → Optional[Tuple[Optional[float], Optional[float], Optional[float]]]

Gets the current position of the three connected motors as (X, Y, Z), defined in nanometers.

Returns

A tuple containing the (X, Y, Z) positions for each motor in nanometers

calibrate(
positions: Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]
) → Tuple[bool, Optional[matplotlib.figure.Figure]]

Calibrates the system by setting the position for the first sample tube. This must be called before methods such as start_session() can be called.

Parameters

positions – The three positions used as calibration points. Each position contains the position of each motor in the X, Y, and Z axes

Returns

A tuple containing True and a matplotlib figure with the sample positions if the calibration was set successfully. A tuple containing False and None otherwise

insert_probe() → bool

Move the platform so that the probe is inserted into the sample. The distance that the probe is inserted into the hole is defined in the config.

eject_probe() → bool

Move the platform so that the probe is out off the sample. This step must be preformed before moving any other direction.

move_step(
axis: mundo.api.axis.Axis,
direction: int = 1,
step_size: float = 1000000.0
) → None

Move manually in a single axis for a specified distance, specified in nanometers.

Parameters

• axis – The specified axis to move manually

• direction – The direction to move in. A positive value indicates that the motor should move away from the 0 position, whereas a negative value indicates that the motor should move towards the 0 position

• step_size – The distance that should be moved, specified in nanometers

move_to_position(
target: Tuple[Optional[float], Optional[float], Optional[float]]
) → bool

Moves the platform to absolute position. Each motor will be ran in a separate thread in order to perform each movement in parallel.

Parameters

target – The position to move to, in nanometers. If an axis has None as value, the platform will not move in this axis

Returns

True if the platform moved successfully in all axes that did not contain None as value, or if all axes are None. False otherwise

move_axis_to_position(
axis: mundo.api.axis.Axis,
position: float
) → bool

Moves the platform in a single axis to an absolute position.

Parameters

• axis – The axis to move in

• position – The position to move to in nanometers

Returns

True if the platform moved successfully in the selected axis. False otherwise

stop_movement() → bool

Stops the movement of the motors.

Returns

True if the motors was stopped successfully, False otherwise

pause_movement() → bool

Pauses the movement of the motors. The motors will no longer be able to move, unless resumed. :return: True if the motors was paused successfully,

False otherwise

resume_movement() → bool

Resumes the movement of the motors. The motors will now be able to move. :return: True if the motors was resumed successfully,

False otherwise

finish_current_sample() → Tuple[bool, Optional[mundo.api.sample.Sample]]

Finishes the currently processing sample by ejecting the probe.

process_sample(
next_sample: mundo.api.sample.Sample
) → Tuple[bool, Optional[mundo.api.sample.Sample]]

Processes the next sample in the sample queue.

stop_process() → bool

Stop the movement of the motors as fast as possible.

resume_process() → bool

Resume the movement of the motors.

reset_process() → Tuple[bool, Optional[mundo.api.sample.Sample]]

If the motors has been stopped or the process is over, then you can move the motors position to an initial position.

Returns

The sample that was previously being processed, or None if the reset failed, or no sample was being processed