def watch_connection_state(should_run):
while not should_run.is_set():
socketio.emit('event', {
'type': 'connection_status',
'is_connected': robot.is_connected()
})
socketio.sleep(1.5)
async def _update_firmware(filename, loop):
"""
This method remains in the API currently because of its use of the robot
singleton's copy of the driver. This should move to the server lib project
eventually and use its own driver object (preferably involving moving the
drivers themselves to the serverlib)
"""
# ensure there is a reference to the port
if not robot.is_connected():
robot.connect()
# get port name
port = str(robot._driver.port)
# set smoothieware into programming mode
robot._driver._smoothie_programming_mode()
# close the port so other application can access it
robot._driver._connection.close()
# run lpc21isp, THIS WILL TAKE AROUND 1 MINUTE TO COMPLETE
update_cmd = 'lpc21isp -wipe -donotstart {0} {1} {2} 12000'.format(
filename, port, robot.config.serial_speed)
proc = await asyncio.create_subprocess_shell(
update_cmd, stdout=asyncio.subprocess.PIPE, loop=loop)
rd = await proc.stdout.read()
res = rd.decode().strip()
await proc.wait()
# re-open the port
robot._driver._connection.open()
# reset smoothieware
robot._driver._smoothie_reset()
# run setup gcodes
robot._driver._setup()
return res
def run(self):
self.default_setup()
while not self.stop.is_set():
if self.disconnect.is_set():
if robot.is_connected():
robot.disconnect()
logging.debug('OT-2 robot disconnected')
self.disconnect.clear()
try:
command = command_queue.get(block=True, timeout=0.01)
missive = command['missive']
except Empty:
continue
with stdout_redirect() as out:
try:
print(missive)
retval = eval(missive, self.global_context,
self.local_context)
if retval:
print(retval)
except SyntaxError:
try:
exec(missive, self.global_context, self.local_context)
except Exception as E:
print('EXEC Caught an "%s" exception: %s' %
(type(E).__name__, str(E)))
print(traceback.format_exc())
# pdb.post_mortem()
except Exception as e:
print('EVAL Caught an "%s" exception: %s' %
(type(e).__name__, str(e)))
print(traceback.format_exc())
# pdb.post_mortem()
if len(out.getvalue()) > 0:
command['missive'] = str(out.getvalue())
else:
command['missive'] = 'ACK'
response_queue.put(command)
command_queue.task_done()
if robot.is_connected():
robot.disconnect()
logging.debug('OT-2 robot disconnected')
async def _update_firmware(filename, loop):
"""
Currently uses the robot singleton from the API server to connect to
Smoothie. Those calls should be separated out from the singleton so it can
be used directly without requiring a full initialization of the API robot.
"""
try:
from opentrons import robot
except ModuleNotFoundError:
res = "Unable to find module `opentrons`--not updating firmware"
rc = 1
log.error(res)
else:
# ensure there is a reference to the port
if not robot.is_connected():
robot.connect()
# get port name
port = str(robot._driver.port)
# set smoothieware into programming mode
robot._driver._smoothie_programming_mode()
# close the port so other application can access it
robot._driver._connection.close()
# run lpc21isp, THIS WILL TAKE AROUND 1 MINUTE TO COMPLETE
update_cmd = 'lpc21isp -wipe -donotstart {0} {1} {2} 12000'.format(
filename, port, robot.config.serial_speed)
proc = await asyncio.create_subprocess_shell(
update_cmd,
stdout=asyncio.subprocess.PIPE,
loop=loop)
rd = await proc.stdout.read()
res = rd.decode().strip()
await proc.communicate()
rc = proc.returncode
if rc == 0:
# re-open the port
robot._driver._connection.open()
# reset smoothieware
robot._driver._smoothie_reset()
# run setup gcodes
robot._driver._setup()
return res, rc
from opentrons import robot, containers, instruments
import opentrons
import curses
import time
from curses import wrapper
from equipment import getEquipment
movementamounts= {1:0.1, 2:0.5, 3:1, 4:5, 5:10,6:20,7:40,8:80}
equipment=getEquipment()
robot.connect(robot.get_serial_ports_list()[0])
if not robot.is_connected():
raise Exception('Did not connect')
input("Robot will now home, press enter to continue.")
robot.home()
placeables = {}
pipettes = {}
for key, value in equipment.items():
if hasattr(value, 'axis'):
pipettes[key]=value
else:
placeables[key]=value
placeableNames=sorted(list(placeables.keys()))
pipetteNames=sorted(list(pipettes.keys()))
def main(stdscr):
def _run(self):
def on_command(message):
if message['$'] == 'before':
self.log_append()
if message['name'] == command_types.PAUSE:
self.set_state('paused')
if message['name'] == command_types.RESUME:
self.set_state('running')
self._reset()
_unsubscribe = self._broker.subscribe(command_types.COMMAND,
on_command)
self.startTime = now()
self.set_state('running')
try:
if self._use_v2:
self.resume()
self._pre_run_hooks()
self._hardware.cache_instruments()
ctx = ProtocolContext.build_using(self._protocol,
loop=self._loop,
broker=self._broker,
extra_labware=getattr(
self._protocol,
'extra_labware', {}))
ctx.connect(self._hardware)
ctx.home()
run_protocol(self._protocol, context=ctx)
else:
robot.broker = self._broker
assert isinstance(self._protocol, PythonProtocol),\
'Internal error: v1 should only be used for python'
if not robot.is_connected():
robot.connect()
self.resume()
self._pre_run_hooks()
robot.cache_instrument_models()
robot.discover_modules()
exec(self._protocol.contents, {})
# If the last command in a protocol was a pause, the protocol
# will immediately finish executing because there's no smoothie
# command to block... except the home that's about to happen,
# which will confuse the app and lock it up. So we need to
# do our own pause here, and sleep the thread until/unless the
# app resumes us.
#
# Cancelling from the app during this pause will result in the
# smoothie giving us an error during the subsequent home, which
# is tragic but expected.
while self.state == 'paused':
sleep(0.1)
self.set_state('finished')
self._hw_iface().home()
except SmoothieAlarm:
log.info("Protocol cancelled")
except Exception as e:
log.exception("Exception during run:")
self.error_append(e)
self.set_state('error')
raise e
finally:
_unsubscribe()
def is_connected():
robot = Robot.get_instance()
return flask.jsonify({
'is_connected': robot.is_connected(),
'port': robot.get_connected_port()
})
def initall():
robot.connect(robot.get_serial_ports_list()[0])
robot.is_connected()
robot.home()
