def _main():
parser = argparse.ArgumentParser(description="Simple command line"
" interface for UPDI programming")
parser.add_argument("-d",
"--device",
choices=Device.get_supported_devices(),
required=True,
help="Target device")
parser.add_argument(
"-c",
"--comport",
required=True,
help="Com port to use (Windows: COMx | *nix: /dev/ttyX)")
parser.add_argument("-e",
"--erase",
action="store_true",
help="Perform a chip erase (implied with --flash)")
parser.add_argument("-b", "--baudrate", type=int, default=115200)
parser.add_argument("-f", "--flash", help="Intel HEX file to flash.")
parser.add_argument("-fs",
"--fuses",
action="append",
nargs="*",
help="Fuse to set (syntax: fuse_nr:0xvalue)")
parser.add_argument("-v",
"--verbose",
action="store_true",
help="Set verbose mode")
args = parser.parse_args(sys.argv[1:])
if args.fuses is None and args.flash is None and not args.erase:
print("No action (erase, flash or fuses)")
sys.exit(0)
if args.verbose:
logging.basicConfig(
format="%(asctime)s %(levelname)s:%(name)s %(message)s",
level=logging.INFO)
else:
logging.basicConfig(format="%(levelname)s:%(name)s %(message)s",
level=logging.WARNING)
nvm = UpdiNvmProgrammer(comport=args.comport,
baud=args.baudrate,
device=Device(args.device))
try:
nvm.enter_progmode()
except:
print("Device is locked. Performing unlock with chip erase.")
nvm.unlock_device()
nvm.get_device_info()
if not _process(nvm, args):
print("Error during processing")
nvm.leave_progmode()
def __init__(self, path, debug=False):
Device.__init__(self)
self.caps[TRIGGER] = self.set_trigger
self.caps[TRIGGER_MASK] = self.set_trigger_mask
self.caps[TRIGGER_EDGE] = self.set_trigger_edge
self.caps[TRIGGER_BOTH_EDGE] = self.set_trigger_both_edges
self.caps[TRIGGER_REPEAT] = self.set_trigger_repeat
self.caps[TRIGGER_AFTER] = self.set_trigger_after
self.dev = None
self._open(str(path))
def __init__(self, path, debug = False):
Device.__init__(self)
self.caps[TRIGGER] = self.set_trigger
self.caps[TRIGGER_MASK] = self.set_trigger_mask
self.caps[TRIGGER_EDGE] = self.set_trigger_edge
self.caps[TRIGGER_BOTH_EDGE]= self.set_trigger_both_edges
self.caps[TRIGGER_REPEAT] = self.set_trigger_repeat
self.caps[TRIGGER_AFTER] = self.set_trigger_after
self.dev = None
self._open(str(path))
def main():
# change to get arguments from command line
data_folder = "dataset/data/cifar-10"
input_folder = data_folder + "/train"
label_file = data_folder + "/trainLabels.csv"
batch_size = 128
dataset = Dataset(data_folder, input_folder, label_file, True)
TrainingSet = DataIterator(dataset.train_x, dataset.train_y, batch_size)
TestSet = DataIterator(dataset.test_x, dataset.test_y, batch_size)
config = {
"learning_rate": 0.001,
"other": 1,
"checkpoint_path": "checkpoint/test",
"checkpoint_name": "test",
"summary_path": "graphs/test",
"training": False,
"epochs": 55
}
try:
create_directories(["checkpoint", "graphs"])
except:
print("Cannot create directory")
tf.reset_default_graph()
model = TestModel(config)
model.build_model()
device = Device()
session = device.get_session()
session.run(tf.global_variables_initializer())
saver = tf.train.Saver()
if config["training"]:
model.restore_model(saver, session)
logger = Logger(session, config)
trainer = Train(session, model, saver, TrainingSet, TestSet, logger)
trainer.train(config["epochs"])
else:
inference = Inference(session, model, config, saver)
inference.load_from_saved_model(saver)
prediction = inference.prediction(TestSet)
print(prediction)
def _connect(executor: ThreadPoolExecutor, address: DeviceAddress,
on_stage_changed: Callable[[Stage], None]) -> 'Worker':
try:
# Connect
LOGGER.debug(f'Connecting to {address}')
on_stage_changed(Stage.CONNECTING)
dev = Device(address, CHANNEL_COUNT, SOCKET_TIMEOUT)
# Write defaults
LOGGER.debug(f'Writing defaults to {address}')
on_stage_changed(Stage.WRITING_DEFAULTS)
if defaults is None:
LOGGER.warning(f'No default values')
else:
for r, v in defaults.controller.items():
dev.controller.write(r, v)
for cell in dev.cells:
for r, v in defaults.cell.items():
cell.write(r, v)
# Read state
LOGGER.debug(f'Reading state from {address}')
on_stage_changed(Stage.READING_STATE)
ctl, cells = _read_device_state(dev)
except (EOFError, OSError) as e:
msg = f'Failed to connect to {address}: {e}'
LOGGER.error(msg)
on_stage_changed(Stage.DISCONNECTED)
raise ConnectionError(msg)
LOGGER.info(f'Connected to {address}')
on_stage_changed(Stage.CONNECTED)
return Worker(executor, dev, ctl, cells)
def update_device_list(self, device_list):
for device in device_list:
dev = Device.update_or_create(device["id"],
device["description"],
device_type_dict=device["device_type"],
attribute_dict=device["attributes"],
module_names=device["modules"]
)
def run(self):
print(self._config.devices)
for name, script in self._config.devices:
try:
device = Device(name, self._logger, script)
self._devices.append(device)
except DeviceNotFoundException as e:
print('An exception with a device device occurred: ')
print(e)
for device in self._devices:
ensure_future(print_events(device))
self._loop = get_event_loop()
self._loop.run_forever()
def __init__(self, _game, _name):
self.game = _game
self.name = _name
# Player physics body
self.pPhysicsBody = None
self.pRayNode = None
self.playerModel = None
# Fsm State
self.playerActiveState = None
## Physics
self.physics = PlayerPhysics(self)
# Player Device
self.device = Device(self)
def collect_energy_values(self):
for device in Device.find_by_module(DeviceModule.SP3):
broadlink_device = sp2(
(device.get_attribute("ip_address", flat=True), 80),
mac=device.get_attribute("mac_address", flat=True),
devtype=38010)
try:
broadlink_device.auth()
energy = broadlink_device.get_energy()
dp = Datapoint(device, energy)
PowerMonitor.DATAPOINT_LIST.append(dp)
except OSError:
log.error("Device {} is not reachable".format(device))
except ValueError:
log.error(
"Device {} doesnt return a correct Value".format(device))
def _push_config(self, device_name, rule):
self.logger.debug("Loading {} candidate ...".format(rule.deploy))
with Device(device_name,
self.device_class,
self.username,
self.password,
timeout=self.timeout,
optional_args=self.optional_args) as device:
device.get_config()
self.running_config[device_name] = device.running_config
try:
f"device.load_{rule.deploy}_candidate(filename=rule.filename, config=rule.config)"
except (MergeConfigException, ReplaceConfigException) as err:
exc_type, exc_value, exc_traceback = sys.exc_info()
stacktrace = traceback.extract_tb(exc_traceback)
self.logger.critical(
"_push_config: fatal error: {}, In loading merge/replace configuration: {} - {}"
.format(err, exc_type, exc_value))
self.logger.debug(sys.exc_info())
self.logger.debug(stacktrace)
device.close()
raise
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
stacktrace = traceback.extract_tb(exc_traceback)
self.logger.critical(
"_push_config: unknown error in loading merge/replace configuration: {} - {}. AAGGGHHHH! We're all going to die!"
.format(exc_type, exc_value))
self.logger.debug(sys.exc_info())
self.logger.debug(stacktrace)
device.close()
raise
diffs = device.compare_config()
self.logger.warning("Configuration Diffs: {}".format(diffs))
choice = ''
if self._prompt:
# You can commit or discard the candidate changes.
while choice not in 'yN':
choice = input(
"\nWould you like to commit these changes? [yN]: ")
if not self._prompt or choice == 'y':
print('Committing ...')
self.logger.debug("Committing...")
try:
device.commit_config()
except (MergeConfigException, ReplaceConfigException) as err:
exc_type, exc_value, exc_traceback = sys.exc_info()
stacktrace = traceback.extract_tb(exc_traceback)
self.logger.critical(
"_push_config: fatal error: {}, In committing merge/replace configuration: {} - {}"
.format(err, exc_type, exc_value))
self.logger.debug(sys.exc_info())
self.logger.debug(stacktrace)
device.close()
raise
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
stacktrace = traceback.extract_tb(exc_traceback)
self.logger.critical(
"_push_config: unknown error in committing merge/replace configuration: {} {}. AAGGGHHHH! We're all going to die!"
.format(exc_type, exc_value))
self.logger.debug(sys.exc_info())
self.logger.debug(stacktrace)
device.close()
raise
elif self._prompt and choice == 'N':
print('Discarding ...')
self.logger.debug("Discarding...")
device.discard_config()
else:
self.logger.critical(
"Something horrible has happened in pushing the configuration to device {} and I cannot continue."
.format(device_name))
self.logger.critical(
"You will need to manually check the device and manually correct if necessary."
)
raise RuntimeError(
"Error pushing configuration. Manually check the device and manually correct the configuration."
)
from threading import Thread
import power.power as power
import util.indent as indent
from device.device import Device
TASK_TIMEOUT = 600 # max time to run the fuzz script (seconds)
PING_DELAY = 1 # time to wait in between pings (seconds)
BOOT_TIMEOUT = 120 # max time for the target to boot (aka respond to pings) (seconds)
REMOTE_COMMAND = "~/_research/rosenbridge/fuzz/deis/fuzz_deis.sh"
SIM = False
systems = [
Device(3, "192.168.3.160", "delta", "password", "unknown"),
Device(2, "192.168.3.161", "delta", "password", "unknown"),
Device(1, "192.168.3.162", "delta", "password", "unknown"),
Device(5, "192.168.3.163", "delta", "password", "unknown"),
Device(6, "192.168.3.164", "delta", "password", "unknown"),
Device(7, "192.168.3.165", "delta", "password", "unknown"),
Device(0, "192.168.3.166", "delta", "password", "unknown"),
]
if SIM:
systems = [Device(1, "localhost", "deltaop", "xxx", "unknown")]
def device_up(device):
device.dprint("pinging %s" % device.ip)
response = os.system("timeout 1 ping -c 1 " + device.ip + " > /dev/null 2>&1")
return response == 0
def _main():
if sys.version_info[0] < 3:
print("WARNING: for best results use Python3")
parser = argparse.ArgumentParser(description="Simple command line"
" interface for UPDI programming")
parser.add_argument("-d",
"--device",
choices=Device.get_supported_devices(),
required=True,
help="Target device")
parser.add_argument(
"-c",
"--comport",
required=True,
help="Com port to use (Windows: COMx | *nix: /dev/ttyX)")
parser.add_argument("-e",
"--erase",
action="store_true",
help="Perform a chip erase (implied with --flash)")
parser.add_argument("-b", "--baudrate", type=int, default=115200)
parser.add_argument("-f", "--flash", help="Intel HEX file to flash.")
parser.add_argument("-r", "--reset", action="store_true", help="Reset")
parser.add_argument("-i", "--info", action="store_true", help="Info")
parser.add_argument("-fs",
"--fuses",
action="append",
nargs="*",
help="Fuse to set (syntax: fuse_nr:0xvalue)")
parser.add_argument("-fr",
"--readfuses",
action="store_true",
help="Read out the fuse-bits")
parser.add_argument("-fe",
"--eeprom",
help="Intel HEX file to write to EEPROM.")
parser.add_argument("-v",
"--verbose",
action="store_true",
help="Set verbose mode")
args = parser.parse_args(sys.argv[1:])
if not any((args.fuses, args.flash, args.erase, args.reset, args.readfuses,
args.info, args.eeprom)):
print("No action (erase, flash, eeprom, reset, fuses or info)")
sys.exit(0)
if args.verbose:
logging.basicConfig(format="%(levelname)s:%(name)s %(message)s",
level=logging.INFO)
else:
logging.basicConfig(format="%(levelname)s:%(name)s %(message)s",
level=logging.WARNING)
nvm = UpdiNvmProgrammer(comport=args.comport,
baud=args.baudrate,
device=Device(args.device))
if not args.reset: # any action except reset
# Reteieve info before building the stack to be sure its the correct device
nvm.get_device_info()
try:
nvm.enter_progmode()
except:
print("Device is locked. Performing unlock with chip erase.")
nvm.unlock_device()
print("Device info: {0:s}".format(str(nvm.get_device_info())))
if not _process(nvm, args):
print("Error during processing")
# Reset only needs this.
nvm.leave_progmode()
async def print_events(device: Device):
async for event in device.async_read_loop():
device.input_event(event.code, event.value)
import power.power as power
import util.indent as indent
import generator
from device.device import Device
TASK_TIME = 3 # seconds
PING_TIME = 1 # seconds
USERNAME = "******"
PASSWORD = "******"
COMMAND = "~/_research/rosenbridge/fuzz/exit/fuzz_exit.sh"
SIM = False
systems = [Device(0, "192.168.3.169", "unknown")]
if SIM:
systems = [Device(0, "localhost", "unknown")]
USERNAME = "******"
PASSWORD = "******"
#TODO: maybe alternate between strategies? the strategy needs to be integrated
# into the master generator, so that each instruction is tried with both
# strategies
JUMP_STRATEGY = 2
#TODO: want to be able to assign a device to a specific SHARED strategy ...
# that is, we're not generating data for just that device, we generate it for a
# strategy, and then many devices can pull from that data
strategy_set_0 = [
self.device)
worker.start()
except Exception as exception:
pass
if __name__ == "__main__":
print "[Info - Main] Service Start ... "
config = Config()
rabbitmq_ip = config.rabbitmq.get_ip()
reqister_queue = config.register.get_queue_name()
status_queue = config.status.get_queue_name()
control_queue = config.controller.get_queue_name()
interval = config.device.get_interval()
device = Device()
job = Job(device, rabbitmq_ip, reqister_queue, status_queue, control_queue)
while True:
if job.register() == True:
print "[Info - Register] Register Success"
print "[Info - Main] Sleep %s Seconds" % interval
time.sleep(interval)
threading.Thread(target=job.report,
args={interval},
name="reporter-thread").start()
threading.Thread(target=job.controller,
args={},
name="controller-thread").start()
exit()
else:
time.sleep(interval * 10)
def _main():
if sys.version_info[0] < 3:
print("WARNING: for best results use Python3")
parser = argparse.ArgumentParser(description="Simple command line"
" interface for UPDI programming")
parser.add_argument("-d",
"--device",
choices=Device.get_supported_devices(),
required=True,
help="Target device")
parser.add_argument(
"-c",
"--comport",
required=True,
help="Com port to use (Windows: COMx | *nix: /dev/ttyX)")
parser.add_argument("-e",
"--erase",
action="store_true",
help="Perform a chip erase (implied with --flash)")
parser.add_argument("-b", "--baudrate", type=int, default=115200)
parser.add_argument("-f", "--flash", help="Intel HEX file to flash.")
parser.add_argument("-k",
"--batch",
action="store_true",
help="Batch flash with Micro-UPDI Programmer")
parser.add_argument("-r", "--reset", action="store_true", help="Reset")
parser.add_argument("-fs",
"--fuses",
action="append",
nargs="*",
help="Fuse to set (syntax: fuse_nr:0xvalue)")
parser.add_argument("-fr",
"--readfuses",
action="store_true",
help="Read out the fuse-bits")
parser.add_argument("-v",
"--verbose",
action="store_true",
help="Set verbose mode")
args = parser.parse_args(sys.argv[1:])
if not any(
(args.fuses, args.flash, args.erase, args.reset, args.readfuses)):
print("No action (erase, flash, reset or fuses)")
sys.exit(0)
if args.verbose:
logging.basicConfig(format="%(levelname)s:%(name)s %(message)s",
level=logging.INFO)
else:
logging.basicConfig(format="%(levelname)s:%(name)s %(message)s",
level=logging.WARNING)
if args.batch:
nvm = UpdiNvmProgrammer(comport=args.comport,
baud=args.baudrate,
device=Device(args.device))
nvm.setLEDs('off')
while True:
'''nvm = UpdiNvmProgrammer(comport=args.comport,
baud=args.baudrate,
device=Device(args.device))'''
while not nvm.getBTN():
time.sleep(0.016)
state = False
while nvm.getBTN():
state = not state
nvm.setLEDs('green' if state else 'off')
time.sleep(0.055)
nvm.setLEDs('yellow')
try:
nvm.application.datalink.start()
except:
nvm.setLEDs('red')
while not nvm.getBTN():
time.sleep(0.016)
continue
if not args.reset: # any action except reset
try:
nvm.enter_progmode()
except:
print(
"Device is locked. Performing unlock with chip erase.")
nvm.unlock_device()
nvm.get_device_info()
try:
if not _process(nvm, args):
print("Error during processing")
nvm.setLEDs('red')
else:
nvm.setLEDs('green')
except:
nvm.setLEDs('red')
nvm.leave_progmode()
while not nvm.getBTN():
time.sleep(0.016)
else:
nvm = UpdiNvmProgrammer(comport=args.comport,
baud=args.baudrate,
device=Device(args.device))
nvm.application.datalink.start()
if not args.reset: # any action except reset
try:
nvm.enter_progmode()
except:
print("Device is locked. Performing unlock with chip erase.")
nvm.unlock_device()
nvm.get_device_info()
if not _process(nvm, args):
print("Error during processing")
# Reset only needs this.
nvm.leave_progmode()
from device.device import Device
class Controller(object):
device = ""
@staticmethod
def start():
app.run(debug=False, host="0.0.0.0", port=3000)
app = Flask(__name__)
@app.route('/led', methods=['POST'])
def control_led():
body = request.get_json(force=True)
if body.get('power') == None:
abort(400)
try:
Controller.device.addon.led.set(int(body.get('power')))
return app.response_class(response="OK", status=200)
except:
return app.response_class(response="Failed", status=500)
if __name__ == "__main__":
Controller.device = Device()
Controller.start()
def get_device_info(self):
for device_name in self.device_list:
self.logger.info("Getting info for device {}".format(device_name))
self.logger.debug("Entering context manager for {}".format(
self.device_class))
if not self._skip_info:
with Device(device_name,
self.device_class,
self.username,
self.password,
timeout=self.timeout,
optional_args=self.optional_args) as device:
if not self._skip_config:
self.logger.debug(
"Getting config for device {}".format(device_name))
device.get_config()
self._running_config[
device_name] = device.running_config
self.logger.debug("Received config")
elif device_name not in self._running_config:
self._running_config[device_name] = ""
if not self._skip_facts:
self._device_facts[device_name] = device.get_facts()
elif device_name not in self._device_facts:
self._device_facts[device_name] = {}
self.logger.debug("command list for {}: {}".format(
device_name, self._cli_command_list))
if not self._skip_commands and self._cli_command_list:
self.logger.debug("Sending commands {} to {}".format(
self._cli_command_list, device_name))
device.run_cli_command_list(self._cli_command_list)
self._cli_commands[
device_name] = device.cli_command_output
logger.debug("_cli_commands for device {} : {}".format(
device_name, self._cli_commands[device_name]))
elif device_name not in self._cli_commands:
self._cli_commands[device_name] = {}
if not self._skip_methods and self._get_method_list:
self._get_methods[device_name] = {}
for method in self._get_method_list:
self.logger.debug(
"Running napalm method {} to {}".format(
method, device_name))
result = eval(f"device.{method}()")
self._get_methods[device_name][method] = result
logger.debug(
"results for method {} on device {} : {}".
format(method, device_name,
self._get_methods[device_name][method]))
logger.debug("final methods dictionary: {}".format(
self._get_methods[device_name]))
elif device_name not in self._get_methods:
self._get_methods[device_name] = {}
else:
if device_name not in self._running_config:
self._running_config[device_name] = ""
if device_name not in self._device_facts:
self._device_facts[device_name] = {}
if device_name not in self._cli_commands:
self._cli_commands[device_name] = {}
if device_name not in self._get_methods:
self._get_methods[device_name] = {}
"""
"""
Simple command line interface for programming flash
"""
if __name__ == "__main__":
# Simple command line interface for demo purposes
import sys
if len(sys.argv) != 4:
print("Python UPDI programmer demo")
print("Usage: pyupdi.py comport device filename")
sys.exit(1)
# Retrieve parameters
comport = sys.argv[1]
device = Device(sys.argv[2])
filename = sys.argv[3]
nvm = UpdiNvmProgrammer(comport=comport, baud=115200, device=device)
# Retrieve data to write
data, start_address = nvm.load_ihex(filename)
# Enter programming mode
try:
nvm.enter_progmode()
except Exception:
print("Device is locked. Performing unlock with chip erase.")
nvm.unlock_device()
# Read and display device info
