def send_task(fcode_stream):
# open the rsa key
client_key = get_or_create_default_key("./sdk_connection.pem")
# connect to delta, don't change the port 23811
robot = FluxRobot(('192.168.18.114', 23811), client_key)
# callback for uploading
def upload_progress(*args):
print(args)
# upload fcode in delta
robot.upload_stream(fcode_stream, 'application/fcode', size=len(fcode_stream.getvalue()), process_callback=upload_progress)
# start the task
robot.start_play()
# report progress
report = robot.report_play()
while report['st_id'] != 64:
report = robot.report_play()
print('report:', report)
sleep(1)
# complete, quit the task
robot.quit_play()
def main():
parser = argparse.ArgumentParser(description='flux robot')
parser.add_argument(dest='target', type=str,
help="Printer connect with. It can be printer uuid "
"or IP address like 192.168.1.1 or "
"192.168.1.1:23811")
parser.add_argument('--debug', dest='debug', action='store_const',
const=True, default=False, help='Print debug message')
parser.add_argument('--ipython', dest='ipython', action='store_const',
const=True, default=False, help='Use python shell')
parser.add_argument('--simple', dest='simple', action='store_const',
const=True, default=False, help='Use python shell')
parser.add_argument('--key', dest='clientkey', type=str, default=None,
help='Client identify key (A RSA pem)')
options = parser.parse_args()
options.clientkey = get_or_create_default_key(options.clientkey)
if options.ipython:
ipython_shell(options)
elif options.simple:
simple_shell(options)
else:
robot_shell(options)
return 0
def main():
parser = argparse.ArgumentParser(description='flux camera live')
parser.add_argument(dest='target', type=str,
help="Printer connect with. It can be printer uuid "
"or IP address like 192.168.1.1 or "
"192.168.1.1:23812")
parser.add_argument('--filename', dest='filename', type=str,
default="%(target)s-%(time)s.jpg",
help='Save photo as filename')
parser.add_argument('--strftime', dest='strftime', type=str,
default="%Y-%m-%d-%H-%M-%S-%f",
help='Formate datetime for filename')
parser.add_argument('--key', dest='clientkey', type=str, default=None,
help='Client identify key (A RSA pem)')
options = parser.parse_args()
options.clientkey = get_or_create_default_key(options.clientkey)
camera, device = connect_camera_helper(options.target, options.clientkey)
try:
if device:
metadata = device.to_dict()
else:
metadata = {"ipaddr": options.target}
serve_forever(options, camera, metadata)
finally:
camera.close()
return 0
def main(params=None):
parser = argparse.ArgumentParser(description=PROG_DESCRIPTION,
epilog=PROG_EPILOG)
parser.add_argument(dest='target', type=str,
help="Device uuid or ipaddress to connect to. "
"IP address can be '192.168.1.1' or "
"'192.168.1.1:23811'.")
parser.add_argument('--key', dest='clientkey', type=str, default=None,
help='Client identify key (A RSA pem)')
parser.add_argument('-s', '--shell', dest='shell', default='simple',
help="Shell will active after connect to device. "
"use 'flux_robot --shell help' to get more "
"informations.")
parser.add_argument('--verbose', dest='verbose', action='store_const',
const=True, default=False, help='Verbose output')
options = parser.parse_args(params)
options.clientkey = get_or_create_default_key(options.clientkey)
if options.shell == "simple":
simple_shell(options)
elif options.shell == "curses":
curses_shell(options)
elif options.shell == "help":
help_shell(options)
else:
python_shell(options)
return 0
def main():
parser = argparse.ArgumentParser(description='flux usb tool')
parser.add_argument('-d', dest='debug', action='store_const',
const=True, default=False, help='Print debug log')
parser.add_argument('-b', dest='baudrate', type=str, default=115200,
help="Baudrate")
parser.add_argument(dest='serial', type=str,
help="Device serial port")
options = parser.parse_args()
if options.debug:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
task = UsbTask(options.serial, get_or_create_default_key(),
options.baudrate)
logger.info("""Device:
Nickname: %(name)s
Serial: %(serial)s
UUID: %(uuid)s
Version: %(ver)s
Has Password: %(pwd)s
""" % {"name": task.name, "serial": task.serial, "uuid": task.uuid.hex,
"ver": task.remote_version, "pwd": task.has_password})
resp = do_auth(task).decode("ascii", "ignore")
if resp not in ("OK", "ALREADY_TRUSTED"):
raise RuntimeError(resp)
cmdline(task)
def robot(FLUX_ipaddr):
client_key = get_or_create_default_key("./sdk_connection.pem")
try:
robot = FluxRobot((FLUX_ipaddr, 23811), client_key)
except errors.RobotSessionError:
add_rsa(FLUX_ipaddr)
robot = FluxRobot((FLUX_ipaddr, 23811), client_key)
return robot
def main(params=None):
global logger
parser = argparse.ArgumentParser(description=PROG_DESCRIPTION,
epilog=PROG_EPILOG)
parser.add_argument(dest='target', type=str,
help="Printer connect with. It can be printer UUID "
"or IP address like 192.168.1.1 or "
"192.168.1.1:23811")
parser.add_argument('--key', dest='clientkey', type=str, default=None,
help='Client identify key (A RSA pem)')
parser.add_argument('--auto', dest='auto', action='store_const',
const=True, default=False, help='Start with no asking')
parser.add_argument('--verbose', dest='verbose', action='store_const',
const=True, default=False, help='Verbose output')
parser.add_argument('--steps', dest='steps', type=int, default=400,
help='Set steps for scan')
parser.add_argument('--path', dest='dist', type=str, default=".",
help="Where to save images")
parser.add_argument('--prefix', dest='prefix', type=str, default=None,
help="Image filename prefix")
options = parser.parse_args(params)
logger = setup_logger(__name__, debug=options.verbose)
options.clientkey = get_or_create_default_key(options.clientkey)
scan = prepare_robot(options)
scan.step_length(HW_PROFILE['model-1']['scan_full_len'] / options.steps)
if not options.auto:
total_steps = interactive(scan)
filename_prefix = options.prefix or \
datetime.datetime.now().strftime("scan_%Y%m%d_%H%M")
filename_prefix = os.path.join(options.dist, filename_prefix)
filename_prefix = os.path.join(options.dist, '')
logger.info("Image will save to %s*.jpg" % filename_prefix)
suffix = ['L', 'R', 'O']
images = scan.scanimages()
total_steps = options.steps
for step in range(total_steps):
print_progress(step, total_steps)
images = scan.scanimages()
for i in range(len(images)):
mime, buf = images[i]
filename = "%s_%03i_%i.jpg" % (filename_prefix, step, i)
filename = "%s%03i_%s.jpg" % (filename_prefix, step, suffix[i])
with open(filename, "wb") as f:
f.write(buf)
if step > 0:
scan.forward()
scan.quit()
print_progress(total_steps, total_steps)
sys.stdout.write("\n Done.")
return 0
def add_rsa(self):
my_rsakey = get_or_create_default_key("./sdk_connection.pem")
upnp_task = self.device.manage_device(my_rsakey)
try:
upnp_task.authorize_with_password(os.environ['password']) #It's the same password you entered in FLUX Studio's configuration page.
upnp_task.add_trust("my_public_key", my_rsakey.public_key_pem.decode())
print("Authorized")
return "Authorized"
except UpnpError as e:
error_code = "Authorization failed: %s" % e
return error_code
def main():
parser = argparse.ArgumentParser(description='flux scanner')
parser.add_argument('-a', dest='auto', action='store_const',
const=True, default=False, help='Start with no asking')
parser.add_argument('-d', dest='debug', action='store_const',
const=True, default=False, help='Print debug log')
parser.add_argument('--path', dest='dist', type=str, default=".",
help="Where to save images")
parser.add_argument('--prefix', dest='prefix', type=str, default=None,
help="Image filename prefix")
parser.add_argument(dest='target', type=str,
help="Printer connect with. It can be printer UUID "
"or IP address like 192.168.1.1 or "
"192.168.1.1:23811")
parser.add_argument('--key', dest='clientkey', type=str, default=None,
help='Client identify key (A RSA pem)')
options = parser.parse_args()
options.clientkey = get_or_create_default_key(options.clientkey)
if options.debug:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
robot = prepare_robot(options)
robot.set_scanlen(HW_PROFILE['model-1']['scan_full_len'] / 400.)
if not options.auto:
total_steps = interactive(robot)
filename_prefix = options.prefix or \
datetime.datetime.now().strftime("scan_%Y%m%d_%H%M")
filename_prefix = os.path.join(options.dist, filename_prefix)
filename_prefix = os.path.join(options.dist, '')
print(filename_prefix)
logger.info("Image will save to %s*.jpg" % filename_prefix)
suffix = ['L', 'R', 'O']
images = robot.scanimages()
total_steps = 400
for step in range(total_steps):
print_progress(step, total_steps)
images = robot.scanimages()
robot.scan_next()
for i in range(len(images)):
mime, buf = images[i]
filename = "%s_%03i_%i.jpg" % (filename_prefix, step, i)
filename = "%s%03i_%s.jpg" % (filename_prefix, step, suffix[i])
with open(filename, "wb") as f:
f.write(buf)
sys.stdout.write("\n Done.")
return 0
def main(params=None, oneshot=False):
parser = argparse.ArgumentParser(description=PROG_DESCRIPTION,
epilog=PROG_EPILOG)
parser.add_argument(dest='target',
type=str,
help="Printer connect with. It can be printer uuid "
"or IP address like 192.168.1.1 or "
"192.168.1.1:23812")
parser.add_argument('--key',
dest='clientkey',
type=str,
default=None,
help='Client identify key (A RSA pem)')
parser.add_argument('-p',
'--fps',
dest='fps',
type=float,
default=None,
help='Limit photo FPS')
parser.add_argument('--strftime',
dest='strftime',
type=str,
default="%Y-%m-%d-%H-%M-%S-%f",
help='Formate datetime for filename')
parser.add_argument('-f',
'--filename',
dest='filename',
type=str,
default="%(target)s-%(time)s.jpg",
help='Save photo as filename')
parser.add_argument('--path',
dest='path',
type=str,
default="",
help='Path to save photo')
options = parser.parse_args(params)
options.clientkey = get_or_create_default_key(options.clientkey)
logger = setup_logger(__name__, debug=False)
camera, device = connect_camera_helper(options.target, options.clientkey)
try:
if device:
metadata = device.to_dict()
else:
metadata = {"ipaddr": options.target}
serve_forever(options, camera, logger, metadata, oneshot=oneshot)
finally:
camera.close()
return 0
def main(params=None):
parser = argparse.ArgumentParser(description=PROG_DESCRIPTION,
epilog=PROG_EPILOG)
parser.add_argument(dest='target',
type=str,
help="Device uuid or ipaddress to connect to. "
"IP address can be '192.168.1.1' or "
"'192.168.1.1:23811'.")
parser.add_argument('--key',
dest='clientkey',
type=str,
default=None,
help='Client identify key (A RSA pem)')
parser.add_argument('-s',
'--shell',
dest='shell',
default='simple',
help="Shell will active after connect to device. "
"use 'flux_robot --shell help' to get more "
"informations.")
parser.add_argument('--verbose',
dest='verbose',
action='store_const',
const=True,
default=False,
help='Verbose output')
options = parser.parse_args(params)
options.clientkey = get_or_create_default_key(options.clientkey)
if options.shell == "simple":
simple_shell(options)
elif options.shell == "curses":
curses_shell(options)
elif options.shell == "help":
help_shell(options)
else:
python_shell(options)
return 0
def main(params=None, oneshot=False):
parser = argparse.ArgumentParser(description=PROG_DESCRIPTION,
epilog=PROG_EPILOG)
parser.add_argument(dest='target', type=str,
help="Printer connect with. It can be printer uuid "
"or IP address like 192.168.1.1 or "
"192.168.1.1:23812")
parser.add_argument('--key', dest='clientkey', type=str, default=None,
help='Client identify key (A RSA pem)')
parser.add_argument('-p', '--fps', dest='fps', type=float, default=None,
help='Limit photo FPS')
parser.add_argument('--strftime', dest='strftime', type=str,
default="%Y-%m-%d-%H-%M-%S-%f",
help='Formate datetime for filename')
parser.add_argument('-f', '--filename', dest='filename', type=str,
default="%(target)s-%(time)s.jpg",
help='Save photo as filename')
parser.add_argument('--path', dest='path', type=str, default="",
help='Path to save photo')
options = parser.parse_args(params)
options.clientkey = get_or_create_default_key(options.clientkey)
logger = setup_logger(__name__, debug=False)
camera, device = connect_camera_helper(options.target, options.clientkey)
try:
if device:
metadata = device.to_dict()
else:
metadata = {"ipaddr": options.target}
serve_forever(options, camera, logger, metadata, oneshot=oneshot)
finally:
camera.close()
return 0
def connect_delta(cls, target=None, ip=None, client_key=None, password=None, kick=False, blocking=True):
"""
Creates a Delta instance
:param str uuid: Device's UUID, optional
:param str ip: Device's IP, optional
:param str password: Device's password
:param bool kick: Force to kick other users
:param bool blocking: Blocking means python will only send commands when prior commands are finished.
"""
if client_key:
if type(client_key) == str:
client_key = get_or_create_default_key(client_key)
else:
type_check(client_key, (str, KeyObject), 'client_key')
else:
client_key = get_or_create_default_key()
if target:
type_check(target, str, 'target')
target = UUID(target)
if ip:
type_check(ip, str, 'ip')
if password:
type_check(password, str, 'password')
if target:
manager = DeviceManager.from_uuid(client_key, target)
elif ip:
manager = DeviceManager.from_ipaddr(client_key, ip)
if not manager.authorized:
manager.authorize_with_password(password)
if manager.authorized:
manager.add_trust('sdk key', client_key.public_key_pem.decode())
logger.warning('[Warning]: adding new key into flux delta')
else:
raise RuntimeError("Authorize error")
if manager.authorized:
robot = FluxRobot((ip, 23811), client_key)
st_id = robot.report_play()["st_id"]
if st_id > 0:
if st_id not in [64, 66, 128, 130]:
robot.abort_play()
while robot.report_play()["st_id"] in [66, 130]:
sleep(0.5)
robot.quit_play()
elif st_id < 0:
robot.kick()
while robot.report_play()["st_id"] != 0:
sleep(0.5)
m_delta = robot.icontrol() # retuen a Delta object
m_delta.blocking_flag = blocking
return m_delta
else:
raise RuntimeError("cannot connect to flux delta")
def connect_delta(cls,
target=None,
ip=None,
client_key=None,
password=None,
kick=False,
blocking=True):
"""
Creates a Delta instance
:param str uuid: Device's UUID, optional
:param str ip: Device's IP, optional
:param str password: Device's password
:param bool kick: Force to kick other users
:param bool blocking: Blocking means python will only send commands when prior commands are finished.
"""
if client_key:
if type(client_key) == str:
client_key = get_or_create_default_key(client_key)
else:
type_check(client_key, (str, KeyObject), 'client_key')
else:
client_key = get_or_create_default_key()
if target:
type_check(target, str, 'target')
target = UUID(target)
if ip:
type_check(ip, str, 'ip')
if password:
type_check(password, str, 'password')
if target:
manager = DeviceManager.from_uuid(client_key, target)
elif ip:
manager = DeviceManager.from_ipaddr(client_key, ip)
if not manager.authorized:
manager.authorize_with_password(password)
if manager.authorized:
manager.add_trust('sdk key',
client_key.public_key_pem.decode())
logger.warning('[Warning]: adding new key into flux delta')
else:
raise RuntimeError("Authorize error")
if manager.authorized:
robot = FluxRobot((ip, 23811), client_key)
st_id = robot.report_play()["st_id"]
if st_id > 0:
if st_id not in [64, 66, 128, 130]:
robot.abort_play()
while robot.report_play()["st_id"] in [66, 130]:
sleep(0.5)
robot.quit_play()
elif st_id < 0:
robot.kick()
while robot.report_play()["st_id"] != 0:
sleep(0.5)
m_delta = robot.icontrol() # retuen a Delta object
m_delta.blocking_flag = blocking
return m_delta
else:
raise RuntimeError("cannot connect to flux delta")
def main():
parser = argparse.ArgumentParser(description='network config')
parser.add_argument('-d', dest='debug', action='store_const',
const=True, default=False, help='Print debug log')
parser.add_argument('--ssid', dest='ssid', type=str, default=None,
help='SSID, example:: FLUX', required=True)
parser.add_argument('--security', dest='security', type=str, default=None,
choices=['', 'WEP', 'WPA-PSK', 'WPA2-PSK'],
help='wifi security')
parser.add_argument('--psk', dest='psk', type=str, default=None,
help='WPA-PSK')
parser.add_argument('--wepkey', dest='wepkey', type=str, default=None,
help='wepkey')
parser.add_argument('--ip', dest='ipaddr', type=str, default=None,
help='IP Address, example: 192.168.1.2. '
'If no ip given, use dhcp')
parser.add_argument('--mask', dest='mask', type=int, default=24,
help='Mask, example: 24')
parser.add_argument('--route', dest='route', type=str, default=None,
help='Route, example: 192.168.1.1')
parser.add_argument('--dns', dest='ns', type=str, default=None,
help='Route, example: 192.168.1.1')
parser.add_argument(dest='target', type=str,
help='Printer Serial ID or serial port')
parser.add_argument('--key', dest='clientkey', type=str, default=None,
help='Client identify key (A RSA pem)')
opt = parser.parse_args()
opt.clientkey = get_or_create_default_key(options.clientkey)
if opt.debug:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
method = "static" if opt.ipaddr else "dhcp"
c = parse_network(method=method, ipaddr=opt.ipaddr, mask=opt.mask,
route=opt.route, ns=opt.ns,
ssid=opt.ssid, security=opt.security,
wepkey=opt.wepkey, psk=opt.psk)
try:
if is_uuid(opt.target):
logger.info("Config network over LAN...")
task = UpnpTask(opt.target, opt.clientkey)
task.require_auth()
if not try_lan_config(task, c):
raise RuntimeError("Remote no response")
elif is_serial_port(opt.target):
logger.info("Config network over COM port...")
task = UsbTask(opt.target)
task.require_auth()
ret = task.config_network(c)
if ret != "OK":
raise RuntimeError(ret)
else:
logger.error("Unknow target: %s" % opt.target)
except RuntimeError as e:
if opt.debug:
raise
logger.error("Network change failed: %s" % e.args)
return 2
logger.info("Network config changed")
return 0
from fluxclient.upnp import UpnpDiscover
from fluxclient.encryptor import KeyObject
from fluxclient.upnp import discover_device, UpnpError
from fluxclient.commands.misc import get_or_create_default_key
from sys import argv
import os
my_rsakey = get_or_create_default_key("./sdk_connection.pem")
discovered_device = []
def my_func_device_discover(upnp_discover, device, **kw):
ip = str(device.ipaddr)
if device.status['st_id'] is None:
return
# Test if the machine authorized
if (not ip in discovered_device):
print("Device '%s' found at %s with st_id %s" % (device.name, ip, device.status['st_id']))
discovered_device.append(ip)
status = int(device.status['st_id'])
if (status == 16 or status == 48):
print("Skip running device")
return
if (device.version == argv[2]):
print("Skip latest version")
return
print("Auth %s" % device.name)
my_func_auth_device(device)
def get_or_create_keyobj(cls, path=None):
warnings.warn("get_or_create_keyobj is deprecated", DeprecationWarning)
from fluxclient.commands.misc import get_or_create_default_key
return get_or_create_default_key(path)