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