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}')
