def __init__(self):
self._comm_interface = RevvyTransportI2C(1)
self._robot_control = self._comm_interface.create_application_control()
self._ring_led = RingLed(self._robot_control)
self._sound = SoundControlV2()
#self._status = RobotStatusIndicator(self._robot_control)
self._status_updater = McuStatusUpdater(self._robot_control)
self._status_updater.reset()
self._battery = BatteryStatus(0, 0, 0)
self._imu = IMU()
self._motor_ports = create_motor_port_handler(self._robot_control)
self._sensor_ports = create_sensor_port_handler(self._robot_control)
self.disabled = False
# Need to enable battery and IMU
self._status_updater.enable_slot("battery", self._process_battery_slot)
self._status_updater.enable_slot("axl", self._imu.update_axl_data)
self._status_updater.enable_slot("gyro", self._imu.update_gyro_data)
self._status_updater.enable_slot("yaw", self._imu.update_yaw_angles)
#set led color to purple on init
self.set_led_color(0x6600cc)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('--inject-test-error',
help='Record an error',
action='store_true')
parser.add_argument('--clear',
help='Clear the error memory',
action='store_true')
parser.add_argument(
'--only-current',
help='Only display errors that were recorded with the current firmware',
action='store_true')
args = parser.parse_args()
with RevvyTransportI2C() as transport:
robot_control = RevvyControl(transport.bind(0x2D))
current_hw_version = robot_control.get_hardware_version()
current_fw_version = robot_control.get_firmware_version()
print('Current version numbers: HW: {} FW: {}'.format(
current_fw_version, current_fw_version))
if args.inject_test_error:
print('Recording a test error')
robot_control.error_memory_test()
# read errors
error_count = robot_control.error_memory_read_count()
if error_count == 0:
print('There are no errors stored')
def _default_bus_factory() -> RevvyTransportBase:
from revvy.hardware_dependent.rrrc_transport_i2c import RevvyTransportI2C
return RevvyTransportI2C(1)
def start_revvy(config: RobotConfig = None):
current_installation = os.path.dirname(os.path.realpath(__file__))
os.chdir(current_installation)
# base directories
package_data_dir = os.path.join(current_installation, 'data')
print('Revvy run from {} ({})'.format(current_installation, __file__))
# prepare environment
serial = getserial()
manifest = read_json('manifest.json')
sound_files = {
'alarm_clock': 'alarm_clock.mp3',
'bell': 'bell.mp3',
'buzzer': 'buzzer.mp3',
'car_horn': 'car-horn.mp3',
'cat': 'cat.mp3',
'dog': 'dog.mp3',
'duck': 'duck.mp3',
'engine_revving': 'engine-revving.mp3',
'lion': 'lion.mp3',
'oh_no': 'oh-no.mp3',
'robot': 'robot.mp3',
'robot2': 'robot2.mp3',
'siren': 'siren.mp3',
'ta_da': 'tada.mp3',
'uh_oh': 'uh-oh.mp3',
'yee_haw': 'yee-haw.mp3',
}
def sound_path(file):
return os.path.join(package_data_dir, 'assets', file)
sound_paths = {key: sound_path(sound_files[key]) for key in sound_files}
device_name = Observable("ROS")
ble_storage_dir = os.path.join(current_installation, 'ble')
ble_storage = FileStorage(ble_storage_dir)
long_message_storage = LongMessageStorage(ble_storage, MemoryStorage())
long_message_handler = LongMessageHandler(long_message_storage)
ble = RevvyBLE(device_name, serial, long_message_handler)
# if the robot has never been configured, set the default configuration for the simple robot
initial_config = default_robot_config
with RevvyTransportI2C() as transport:
robot_control = RevvyControl(transport.bind(0x2D))
robot = RobotManager(robot_control, ble, sound_paths,
manifest['version'], initial_config)
lmi = LongMessageImplementation(robot, config is not None)
long_message_handler.on_upload_started(lmi.on_upload_started)
long_message_handler.on_upload_finished(lmi.on_transmission_finished)
long_message_handler.on_message_updated(lmi.on_message_updated)
# noinspection PyBroadException
try:
robot.start()
print("Press Enter to exit")
input()
# manual exit
ret_val = RevvyStatusCode.OK
except EOFError:
robot.needs_interrupting = False
while not robot.exited:
time.sleep(1)
ret_val = robot.status_code
except KeyboardInterrupt:
# manual exit or update request
ret_val = robot.status_code
except Exception:
print(traceback.format_exc())
ret_val = RevvyStatusCode.ERROR
finally:
print('stopping')
robot.stop()
print('terminated.')
return ret_val
def start_revvy(config: RobotConfig = None):
current_installation = os.path.dirname(os.path.realpath(__file__))
os.chdir(current_installation)
# base directories
writeable_data_dir = os.path.join(current_installation, '..', '..', '..',
'user')
package_data_dir = os.path.join(current_installation, 'data')
ble_storage_dir = os.path.join(writeable_data_dir, 'ble')
data_dir = os.path.join(writeable_data_dir, 'data')
def log_uncaught_exception(exctype, value, tb):
log_message = 'Uncaught exception: {}\n' \
'Value: {}\n' \
'Traceback: \n\t{}\n' \
'\n'.format(exctype, value, "\t".join(traceback.format_tb(tb)))
print(log_message)
logfile = os.path.join(data_dir, 'revvy_crash.log')
with open(logfile, 'a') as logf:
logf.write(log_message)
sys.excepthook = log_uncaught_exception
# self-test
if not check_manifest(os.path.join(current_installation, 'manifest.json')):
print('Revvy not started because manifest is invalid')
return RevvyStatusCode.INTEGRITY_ERROR
print('Revvy run from {} ({})'.format(current_installation, __file__))
# prepare environment
serial = getserial()
manifest = read_json('manifest.json')
device_storage = FileStorage(data_dir)
ble_storage = FileStorage(ble_storage_dir)
sound_files = {
'alarm_clock': 'alarm_clock.mp3',
'bell': 'bell.mp3',
'buzzer': 'buzzer.mp3',
'car_horn': 'car-horn.mp3',
'cat': 'cat.mp3',
'dog': 'dog.mp3',
'duck': 'duck.mp3',
'engine_revving': 'engine-revving.mp3',
'lion': 'lion.mp3',
'oh_no': 'oh-no.mp3',
'robot': 'robot.mp3',
'robot2': 'robot2.mp3',
'siren': 'siren.mp3',
'ta_da': 'tada.mp3',
'uh_oh': 'uh-oh.mp3',
'yee_haw': 'yee-haw.mp3',
}
def sound_path(file):
return os.path.join(package_data_dir, 'assets', file)
sound_paths = {key: sound_path(sound_files[key]) for key in sound_files}
dnp = DeviceNameProvider(device_storage, lambda: 'Revvy_{}'.format(serial))
device_name = Observable(dnp.get_device_name())
device_name.subscribe(dnp.update_device_name)
long_message_storage = LongMessageStorage(ble_storage, MemoryStorage())
long_message_handler = LongMessageHandler(long_message_storage)
ble = RevvyBLE(device_name, serial, long_message_handler)
# if the robot has never been configured, set the default configuration for the simple robot
initial_config = config
if config is None:
status = long_message_storage.read_status(
LongMessageType.CONFIGURATION_DATA)
if status.status != LongMessageStatus.READY:
initial_config = default_robot_config
with RevvyTransportI2C() as transport:
robot_control = RevvyControl(transport.bind(0x2D))
bootloader_control = BootloaderControl(transport.bind(0x2B))
updater = McuUpdater(robot_control, bootloader_control)
update_manager = McuUpdateManager(
os.path.join(package_data_dir, 'firmware'), updater)
update_manager.update_if_necessary()
robot = RobotManager(robot_control, ble, sound_paths,
manifest['version'], initial_config)
lmi = LongMessageImplementation(robot, config is not None)
long_message_handler.on_upload_started(lmi.on_upload_started)
long_message_handler.on_upload_finished(lmi.on_transmission_finished)
long_message_handler.on_message_updated(lmi.on_message_updated)
# noinspection PyBroadException
try:
robot.start()
print("Press Enter to exit")
input()
# manual exit
ret_val = RevvyStatusCode.OK
except EOFError:
robot.needs_interrupting = False
while not robot.exited:
time.sleep(1)
ret_val = robot.status_code
except KeyboardInterrupt:
# manual exit or update request
ret_val = robot.status_code
except Exception:
print(traceback.format_exc())
ret_val = RevvyStatusCode.ERROR
finally:
print('stopping')
robot.stop()
print('terminated.')
return ret_val