def __init__(self, rc: RemoteController): self._controller = rc self._data_ready_event = Event() self._controller_detected_callback = None self._controller_lost_callback = None self._message = None self._log = get_logger('RemoteControllerScheduler')
def __init__(self, port_idx, name, interface: RevvyControl, configurator): self.log = get_logger(f'{name} {port_idx}') self._port_idx = port_idx self._configurator = configurator self._interface = interface self._driver = None self._config_changed_callbacks = FunctionAggregator()
def __init__(self, device_name: Observable, serial, long_message_handler): self._deviceName = device_name.get() self._log = get_logger('RevvyBLE') os.environ["BLENO_DEVICE_NAME"] = self._deviceName self._log(f'Initializing BLE with device name {self._deviceName}') device_name.subscribe(self._device_name_changed) dis = RevvyDeviceInformationService(device_name, serial) bas = CustomBatteryService() live = LiveMessageService() long = LongMessageService(long_message_handler) self._named_services = { 'device_information_service': dis, 'battery_service': bas, 'long_message_service': long, 'live_message_service': live } self._advertised_uuid_list = [live['uuid']] self._bleno = Bleno() self._bleno.on('stateChange', self._on_state_change) self._bleno.on('advertisingStart', self._on_advertising_start)
def __init__(self, robot_manager: RobotBLEController, storage: LongMessageStorage, asset_dir, ignore_config): self._robot = robot_manager self._ignore_config = ignore_config self._asset_dir = asset_dir self._progress = None self._storage = storage self._log = get_logger("LongMessageImplementation")
def __init__(self, interface: RevvyControl, imu: IMU): self._interface = interface self._motors = [] self._left_motors = [] self._right_motors = [] self._log = get_logger('Drivetrain') self._imu = imu self._controller = None
def __init__(self, commands, default_volume): self._default_volume = default_volume self._commands = commands self._lock = threading.Lock() self._processes = [] self._max_parallel_sounds = 4 self._log = get_logger('SoundControl') self._run_command(self._commands['init_amp']).wait()
def __init__(self, bus_factory=None): if bus_factory is None: bus_factory = self._default_bus_factory self._bus_factory = bus_factory self._assets = Assets() self._assets.add_source(os.path.join('data', 'assets')) self._log = get_logger('Robot')
def __init__(self, long_message_storage: LongMessageStorage): self._long_message_storage = long_message_storage self._long_message_type = None self._status = LongMessageHandler.STATUS_IDLE self._current_message = None self._message_updated_callback = None self._upload_started_callback = None self._upload_progress_callback = None self._upload_finished_callback = None self._log = get_logger('LongMessageHandler')
def __init__(self, storage_dir): self._storage_dir = storage_dir self._log = get_logger('FileStorage') try: os.makedirs(self._storage_dir, 0o755, True) with open(self._access_file(), "w") as fp: fp.write("true") except IOError as e: raise StorageError( f"Storage directory {storage_dir} is not writable.") from e
def __init__(self, sound_interface: SoundControlBase, sounds): self._sound = sound_interface self._playing = {} self._key = 0 self._get_sound_path = sounds self.set_volume = sound_interface.set_volume self.reset_volume = sound_interface.reset_volume self._log = get_logger('Sound')
def __init__(self, interface: RevvyControl): self._interface = interface self._log = get_logger('RobotStatusIndicator') self._robot_status = RobotStatus.StartingUp self._controller_status = RemoteControllerStatus.NotConnected self._master_led = None self._bluetooth_led = None
def register_uncaught_exception_handler(): log = get_logger('Exception logger') def log_uncaught_exception(exctype, value, tb): trace = "\t".join(traceback.format_tb(tb)) log_message = f'Uncaught exception: {exctype}\nValue: {value}\nTraceback: \n\t{trace}\n\n' log(log_message, LogLevel.ERROR) log.flush() sys.excepthook = log_uncaught_exception
def __init__(self): self._log = get_logger('RemoteController') self._analogActions = [] # ([channel], callback) pairs self._analogStates = [ ] # the last analog values, used to compare if a callback needs to be fired self._buttonHandlers = [EdgeDetector() for _ in range(32)] self._buttonActions = [ None ] * 32 # callbacks to be fired if a button gets pressed for handler in self._buttonHandlers: handler.handle(1)
def __init__(self, name, interface: RevvyControl, default_driver, amount: int, supported: dict): self._log = get_logger(f"PortHandler[{name}]") self._types = supported self._port_count = amount self._default_driver = default_driver self._ports = { i: PortInstance(i, f'{name}Port', interface, self.configure_port) for i in range(1, amount + 1) } self._log(f'Created handler for {amount} ports') self._log('Supported types:\n {}'.format("\n ".join( self.available_types)))
def __init__(self, robot: Robot, sw_version, revvy_ble): self._log = get_logger('RobotManager') self._log('init') self.needs_interrupting = True self._configuring = False self._robot = robot self._ble = revvy_ble self._sw_version = sw_version self._status_update_thread = periodic(self._update, 0.005, "RobotStatusUpdaterThread") self._background_fns = [] rc = RemoteController() rcs = RemoteControllerScheduler(rc) rcs.on_controller_detected(self._on_controller_detected) rcs.on_controller_lost(self._on_controller_lost) self._remote_controller = rc self._remote_controller_thread = create_remote_controller_thread(rcs) self._resources = { 'led_ring': Resource('RingLed'), 'drivetrain': Resource('DriveTrain'), 'sound': Resource('Sound'), **{ f'motor_{port.id}': Resource(f'Motor {port.id}') for port in self._robot.motors }, **{ f'sensor_{port.id}': Resource(f'Sensor {port.id}') for port in self._robot.sensors } } revvy_ble['live_message_service'].register_message_handler( rcs.data_ready) revvy_ble.on_connection_changed(self._on_connection_changed) self._scripts = ScriptManager(self) self._config = empty_robot_config self._status_code = RevvyStatusCode.OK self.exited = Event() self.start_remote_controller = self._remote_controller_thread.start
def __init__(self, owner: 'ScriptManager', script, name, global_variables: dict): self._owner = owner self._globals = global_variables.copy() self._inputs = {} self._runnable = script self.sleep = self._default_sleep self._thread = ThreadWrapper(self._run, f'ScriptThread: {name}') self.log = get_logger(f'Script: {name}') self.stop = self._thread.stop self.cleanup = self._thread.exit self.on_stopped = self._thread.on_stopped self.on_stopping = self._thread.on_stop_requested assert (callable(script)) self.log('Created')
def __init__(self, func, name="WorkerThread"): self._log = get_logger(f'ThreadWrapper [{name}]') self._log('created') self._lock = Lock() # lock used to ensure internal consistency self._interface_lock = RLock( ) # prevent concurrent access. RLock so that callbacks may restart the thread self._func = func self._stopped_callbacks = [] self._stop_requested_callbacks = [] self._control = Event( ) # used to wake up thread function when it is stopped self._stop_event = Event( ) # used to signal thread function that it should stop self._thread_stopped_event = Event( ) # caller can wait for thread to stop after calling stop() self._thread_stopped_event.set() self._thread_running_event = Event( ) # caller can wait for the thread function to start running self._state = ThreadWrapper.STOPPED self._is_exiting = False self._thread = Thread(target=self._thread_func, args=()) self._thread.start()
def __init__(self, robot): self._robot = robot self._globals = {} self._scripts = {} self._log = get_logger('ScriptManager')
def __init__(self, transport: RevvyTransport): self._transport = transport self._command_byte = self.command_id self._log = get_logger( f'{type(self).__name__} [id={self._command_byte}]')
# SPDX-License-Identifier: GPL-3.0-only import json from json import JSONDecodeError from revvy.robot.configurations import Motors, Sensors from revvy.scripting.runtime import ScriptDescriptor from revvy.utils.functions import b64_decode_str, dict_get_first, str_to_func from revvy.scripting.builtin_scripts import builtin_scripts from revvy.utils.logger import get_logger _log = get_logger('RobotConfig') motor_types = [ None, Motors.RevvyMotor, # motor [ [ # left Motors.RevvyMotor_CCW, Motors.RevvyMotor ], [ # right Motors.RevvyMotor, Motors.RevvyMotor_CCW ] ] ] motor_sides = ["left", "right"]
def __init__(self, robot: RevvyControl): self._robot = robot self._is_enabled = [False] * 32 self._is_enabled[self.mcu_updater_slots["reset"]] = True self._handlers = [None] * 32 self._log = get_logger('McuStatusUpdater')
def __init__(self, port: 'PortInstance', driver): self._driver = driver self._port = port self._on_status_changed = FunctionAggregator() self.log = get_logger(f'[{driver}]', base=port.log)
def __init__(self): self._log = get_logger('Assets') self._files = defaultdict(dict)
def __init__(self, name='Resource'): self._lock = Lock() self._log = get_logger(f'Resource [{name}]', LogLevel.DEBUG) self._current_priority = -1 self._active_handle = null_handle
def __init__(self, fw_dir): self._fw_dir = fw_dir self.log = get_logger('FirmwareLoader')
def __init__(self, storage: StorageInterface, temp_storage: StorageInterface): self._storage = storage self._temp_storage = temp_storage self._log = get_logger('LongMessageStorage')
def __init__(self, robot: Robot): self._robot = robot.robot_control self._bootloader = robot.bootloader_control self._stopwatch = Stopwatch() self._log = get_logger('McuUpdater')
def __init__(self, interface: RevvyControl): self._log = get_logger('McuErrorReader') self._interface = interface self._count = interface.error_memory_read_count() self._log(f'Stored errors: {self._count}')