def initialize(
hardware_server: bool = False,
hardware_server_socket: str = None) \
-> ThreadManager:
"""
Initialize the Opentrons hardware returning a hardware instance.
:param hardware_server: Run a jsonrpc server allowing rpc to the hardware
controller. Only works on buildroot because extra dependencies are
required.
:param hardware_server_socket: Override for the hardware server socket
"""
checked_socket = hardware_server_socket\
or "/var/run/opentrons-hardware.sock"
robot_conf = robot_configs.load()
logging_config.log_init(robot_conf.log_level)
log.info(f"API server version: {__version__}")
log.info(f"Robot Name: {name()}")
loop = asyncio.get_event_loop()
hardware = loop.run_until_complete(initialize_robot())
if hardware_server:
# TODO: BC 2020-02-25 adapt hardware socket server to ThreadManager
loop.run_until_complete(
install_hardware_server(checked_socket, hardware)) # type: ignore
return hardware
def run(hardware, **kwargs): # noqa(C901)
"""
This function was necessary to separate from main() to accommodate for
server startup path on system 3.0, which is server.main. In the case where
the api is on system 3.0, server.main will redirect to this function with
an additional argument of 'patch_old_init'. kwargs are hence used to allow
the use of different length args
"""
loop = asyncio.get_event_loop()
if ff.use_protocol_api_v2():
robot_conf = loop.run_until_complete(hardware.get_config())
else:
robot_conf = hardware.config
logging_config.log_init(robot_conf.log_level)
log.info("API server version: {}".format(__version__))
if not os.environ.get("ENABLE_VIRTUAL_SMOOTHIE"):
initialize_robot(loop, hardware)
if ff.use_protocol_api_v2():
loop.run_until_complete(hardware.cache_instruments())
if not ff.disable_home_on_boot():
log.info("Homing Z axes")
if ff.use_protocol_api_v2():
loop.run_until_complete(hardware.home_z())
else:
hardware.home_z()
try:
udev.setup_rules_file()
except Exception:
log.exception(
"Could not setup udev rules, modules may not be detected")
if kwargs.get('hardware_server'):
if ff.use_protocol_api_v2():
loop.run_until_complete(
install_hardware_server(kwargs['hardware_server_socket'],
hardware._api))
else:
log.warning(
"Hardware server requested but apiv1 selected, not starting")
server.run(
hardware,
kwargs.get('hostname'),
kwargs.get('port'),
kwargs.get('path'),
loop)
def __init__(self,
point_set,
hardware,
pickup_tip=None,
loop=None,
log_level=None):
# URWID user interface objects
if not loop:
loop = asyncio.get_event_loop()
loop = urwid.main_loop.AsyncioEventLoop(loop=loop)
controls = '\n'.join([
'arrow keys: move the gantry',
'q/a: move the pipette up/down',
'=/-: increase/decrease the distance moved on each step',
'1/2/3: go to calibration point 1/2/3',
'enter: confirm current calibration point position',
'space: save data (after confirming all 3 points)',
'p: perform tip probe (after saving calibration data)',
'esc: exit calibration tool',
'?: Full Instructions'
])
self._tip_text_box = urwid.Text(controls)
self._status_text_box = urwid.Text('')
self._pile = urwid.Pile([self._tip_text_box, self._status_text_box])
self._filler = urwid.Filler(self._pile, 'top')
self.hardware = hardware
self._pipettes = {}
if not feature_flags.use_protocol_api_v2():
self._current_mount = right
else:
self._current_mount = types.Mount.RIGHT
self.update_pipette_models()
self.current_transform = identity_deck_transform()
self._tip_length = DEFAULT_TIP_LENGTH
# Other state
if not pickup_tip:
self._tip_length =\
self._pipettes[self._current_mount]._fallback_tip_length
if feature_flags.use_protocol_api_v2():
self.hardware.add_tip(types.Mount.RIGHT, self._tip_length)
if self._pipettes[types.Mount.LEFT]:
self.hardware.add_tip(
types.Mount.LEFT,
self._pipettes[types.Mount.LEFT]._fallback_tip_length)
else:
for pip in self._pipettes.values():
if pip:
pip._add_tip(pip._tip_length)
self.current_position = (0, 0, 0)
self._steps = [0.1, 0.25, 0.5, 1, 5, 10, 20, 40, 80]
self._steps_index = 2
self._current_point = 1
self.model_offset = self._pipettes[self._current_mount].model_offset
deck_height = 0
if not feature_flags.use_protocol_api_v2():
deck_height = self._tip_length
self.actual_points = {1: (0, 0), 2: (0, 0), 3: (0, 0)}
self._expected_points = self.set_deck_height_expected_points(
deck_height, point_set)
self._test_points = self.set_deck_height_test_points(deck_height)
slot5 = self._test_points['slot5']
log_val = self.hardware.config.log_level
if log_level:
log_val = log_level.upper()
logging_config.log_init(log_val)
self.key_map = {
'-':
lambda: self.decrease_step(),
'=':
lambda: self.increase_step(),
'z':
lambda: self.save_z_value(),
'p':
lambda: self.probe(slot5),
'enter':
lambda: self.save_point(),
'\\':
lambda: self.home(),
' ':
lambda: self.save_transform(),
'esc':
lambda: self.exit(),
'q':
lambda: self._jog(self._current_mount, +1, self.current_step()),
'a':
lambda: self._jog(self._current_mount, -1, self.current_step()),
'n':
lambda: self.update_pipette_models(),
'up':
lambda: self._jog('Y', +1, self.current_step()),
'down':
lambda: self._jog('Y', -1, self.current_step()),
'left':
lambda: self._jog('X', -1, self.current_step()),
'right':
lambda: self._jog('X', +1, self.current_step()),
'm':
lambda: self.validate_mount_offset(),
's':
lambda: self.switch_mounts(),
't':
lambda: self.try_pickup_tip(),
'1':
lambda: self.validate(self._expected_points[1], 1, self.
_current_mount),
'2':
lambda: self.validate(self._expected_points[2], 2, self.
_current_mount),
'3':
lambda: self.validate(self._expected_points[3], 3, self.
_current_mount),
'4':
lambda: self.validate(self._test_points['slot5'], 4, self.
_current_mount),
'5':
lambda: self.validate(self._test_points['corner3'], 5, self.
_current_mount),
'6':
lambda: self.validate(self._test_points['corner8'], 6, self.
_current_mount),
'7':
lambda: self.validate(self._test_points['corner9'], 7, self.
_current_mount),
'?':
lambda: self.print_instructions(),
}
self.ui_loop = urwid.MainLoop(self._filler,
handle_mouse=False,
unhandled_input=self._on_key_press,
event_loop=loop)
log.debug("Starting gantry calibration command line interface (CLI)")
