async def initialize_robot() -> ThreadManager:
if os.environ.get("ENABLE_VIRTUAL_SMOOTHIE"):
log.info("Initialized robot using virtual Smoothie")
return ThreadManager(API.build_hardware_simulator)
packed_smoothie_fw_file, packed_smoothie_fw_ver = _find_smoothie_file()
systemd.daemon.notify("READY=1")
hardware = ThreadManager(API.build_hardware_controller,
threadmanager_nonblocking=True,
firmware=(packed_smoothie_fw_file,
packed_smoothie_fw_ver))
try:
await hardware.managed_thread_ready_async()
except RuntimeError:
log.exception('Could not build hardware controller, forcing virtual')
return ThreadManager(API.build_hardware_simulator)
loop = asyncio.get_event_loop()
async def blink():
while True:
await hardware.set_lights(button=True)
await asyncio.sleep(0.5)
await hardware.set_lights(button=False)
await asyncio.sleep(0.5)
blink_task = loop.create_task(blink())
if not ff.disable_home_on_boot():
log.info("Homing Z axes")
await hardware.home_z()
blink_task.cancel()
await hardware.set_lights(button=True)
return hardware
def main():
"""
This application creates and starts the server for both the RPC routes
handled by opentrons.server.rpc and HTTP endpoints defined here
"""
log_init()
arg_parser = ArgumentParser(description="Opentrons application server",
prog="opentrons.server.main")
arg_parser.add_argument(
"-H",
"--hostname",
help="TCP/IP hostname to serve on (default: %(default)r)",
default="localhost")
arg_parser.add_argument(
"-P",
"--port",
help="TCP/IP port to serve on (default: %(default)r)",
type=int,
default="8080")
arg_parser.add_argument(
"-U",
"--path",
help="Unix file system path to serve on. Specifying a path will cause "
"hostname and port arguments to be ignored.",
)
args, _ = arg_parser.parse_known_args(sys.argv[1:])
if args.path:
log.debug("Starting Opentrons server application on {}".format(
args.path))
else:
log.debug("Starting Opentrons server application on {}:{}".format(
args.hostname, args.port))
try:
robot.connect()
except Exception as e:
log.exception("Error while connecting to motor-driver: {}".format(e))
log.info("API server version: {}".format(__version__))
log.info("Smoothie FW version: {}".format(robot.fw_version))
if not ff.disable_home_on_boot():
log.info("Homing Z axes")
robot.home_z()
if not os.environ.get("ENABLE_VIRTUAL_SMOOTHIE"):
setup_udev_rules_file()
atexit.register(unlock_resin_updates)
lock_resin_updates()
web.run_app(init(), host=args.hostname, port=args.port, path=args.path)
arg_parser.exit(message="Stopped\n")
async def initialize_robot() -> ThreadManager:
if os.environ.get("ENABLE_VIRTUAL_SMOOTHIE"):
log.info("Initialized robot using virtual Smoothie")
return ThreadManager(API.build_hardware_simulator)
await check_for_smoothie_update()
hardware = ThreadManager(API.build_hardware_controller)
if not ff.disable_home_on_boot():
log.info("Homing Z axes")
await hardware.home_z()
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)