Esempio n. 1
0
def create_robot_mock():

    robot_mock = mockobj()
    robot_mock.resources = {
        'led_ring': Resource(),
        'drivetrain': Resource(),
        'sound': Resource()
    }
    robot_mock.robot = mockobj()
    robot_mock.robot.time = lambda: 0
    robot_mock.robot.motors = []
    robot_mock.robot.sensors = []

    robot_mock.config = mockobj()
    robot_mock.config.motors = mockobj()
    robot_mock.config.motors.__iter__ = lambda: []
    robot_mock.config.motors.names = {}

    robot_mock.config.sensors = mockobj()
    robot_mock.config.sensors.__iter__ = lambda: []
    robot_mock.config.sensors.names = {}

    robot_mock.robot.drivetrain = mockobj()
    robot_mock.robot.drivetrain.turn = lambda *args, **kwargs: None
    robot_mock.robot.drivetrain.drive = lambda *args, **kwargs: None
    robot_mock.robot.sound = MockSound()
    robot_mock.robot.led = mockobj()
    robot_mock.robot.led.count = 0

    robot_mock.robot.imu = mockobj()

    return robot_mock
Esempio n. 2
0
    def test_resource_can_be_retaken_by_same_priority(self):
        r = Resource()

        handle = r.request(priority_high)
        handle2 = r.request(priority_high)

        self.assertEqual(handle, handle2)
Esempio n. 3
0
def create_robot_mock():

    robot_mock = mockobj()
    robot_mock.resources = {
        'led_ring': Resource(),
        'drivetrain': Resource(),
        'sound': Resource()
    }
    robot_mock.robot = mockobj()
    robot_mock.robot.start_time = 0
    robot_mock.robot.motors = []
    robot_mock.robot.sensors = []

    robot_mock.config = mockobj()
    robot_mock.config.motors = mockobj()
    robot_mock.config.motors.__iter__ = lambda: []
    robot_mock.config.motors.names = {}

    robot_mock.config.sensors = mockobj()
    robot_mock.config.sensors.__iter__ = lambda: []
    robot_mock.config.sensors.names = {}

    robot_mock.robot.drivetrain = mockobj()
    robot_mock.robot.sound = mockobj()
    robot_mock.robot.led_ring = mockobj()
    robot_mock.robot.led_ring.count = 0

    robot_mock.robot.imu = mockobj()

    return robot_mock
Esempio n. 4
0
    def test_lower_priority_can_take_resource_after_higher_priority_releases(self):
        r = Resource()

        handle = r.request(priority_high)
        handle.release()
        handle2 = r.request(priority_low)
        self.assertTrue(handle)
        self.assertFalse(handle.is_interrupted)
        self.assertTrue(handle2)
Esempio n. 5
0
    def test_higher_priority_handle_can_not_be_taken_taken_away(self):
        r = Resource()

        mock = Mock()
        handle = r.request(priority_high, mock)
        handle2 = r.request(priority_low)
        self.assertIsNotNone(handle)
        self.assertEqual(False, handle.is_interrupted)
        self.assertIsNone(handle2)
        self.assertEqual(0, mock.call_count)
Esempio n. 6
0
    def test_lower_priority_handle_can_be_taken_taken_away(self):
        r = Resource()

        mock = Mock()
        handle = r.request(priority_low, mock)
        handle2 = r.request(priority_high)
        self.assertTrue(handle)
        self.assertTrue(handle.is_interrupted)
        self.assertTrue(handle2)
        self.assertEqual(1, mock.call_count)
Esempio n. 7
0
    def test_run_should_only_run_on_active_handle(self):
        r = Resource()

        mock = Mock()

        handle = r.request(priority_low)
        handle2 = r.request(priority_high)

        handle2.run_uninterruptable(mock)
        handle.run_uninterruptable(lambda: self.fail('This should not run'))
        self.assertEqual(1, mock.call_count)
Esempio n. 8
0
    def test_resource_can_be_retaken_by_same_priority(self):
        r = Resource()

        handle = r.request(priority_high)
        handle2 = r.request(priority_high)

        self.assertTrue(handle)
        self.assertTrue(handle2)

        self.assertTrue(handle.is_interrupted)
        self.assertFalse(handle2.is_interrupted)
Esempio n. 9
0
    def __init__(self,
                 interface: RevvyControl,
                 revvy,
                 sound_paths,
                 sw_version,
                 default_config=None):
        print("RobotManager: __init__()")
        self.needs_interrupting = True

        self._configuring = False
        self._robot = Robot(interface, sound_paths, sw_version)
        self._interface = interface
        self._ble = revvy
        self._default_configuration = default_config or RobotConfig()

        self._status_update_thread = periodic(self._update, 0.02,
                                              "RobotStatusUpdaterThread")
        self._background_fn_lock = Lock()
        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_scheduler = rcs
        self._remote_controller_thread = create_remote_controller_thread(rcs)

        self._resources = {
            'led_ring': Resource(),
            'drivetrain': Resource(),
            'sound': Resource(),
            **{
                'motor_{}'.format(port.id): Resource()
                for port in self._robot.motors
            },
            **{
                'sensor_{}'.format(port.id): Resource()
                for port in self._robot.sensors
            }
        }

        revvy['live_message_service'].register_message_handler(
            self._remote_controller_scheduler.data_ready)
        revvy.on_connection_changed(self._on_connection_changed)

        self._scripts = ScriptManager(self)
        self._config = self._default_configuration

        self._status_code = RevvyStatusCode.OK
        self.exited = False
    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
Esempio n. 11
0
    def test_resource_handle_needed_to_release(self):
        r = Resource()

        handle = r.request(priority_low)
        handle2 = r.request(priority_high)
        r.release(handle)
        handle3 = r.request(priority_low)
        self.assertIsNone(handle3)
        self.assertEqual(False, handle2.is_interrupted)
    def test_ring_leds_are_indexed_from_one(self):
        led_mock = Mock()
        led_mock.display_user_frame = Mock()
        led_mock.count = 6

        led_resource = ResourceWrapper(Resource(), 0)

        script = Mock()
        script.is_stop_requested = False

        rw = RingLedWrapper(script, led_mock, led_resource)
        self.assertRaises(IndexError, lambda: rw.set(0, '#112233'))
        rw.set(1, '#112233')
        rw.set(2, '#112233')
        rw.set(3, '#112233')
        rw.set(4, '#112233')
        rw.set(5, '#112233')
        rw.set(6, '#112233')
        self.assertRaises(IndexError, lambda: rw.set(7, '#112233'))
Esempio n. 13
0
    def test_ring_leds_are_indexed_from_one(self):
        led_mock = Mock()
        led_mock.display_user_frame = Mock()
        led_mock.count = 6

        led_resource = ResourceWrapper(Resource(), 0)

        script = Mock()
        script.is_stop_requested = False

        rw = RingLedWrapper(script, led_mock, led_resource)
        self.assertRaises(IndexError,
                          lambda: rw.set(leds=[0], color='#112233'))
        rw.set(leds=[1], color='#112233')
        rw.set(leds=[2], color='#112233')
        rw.set(leds=[3], color='#112233')
        rw.set(leds=[4], color='#112233')
        rw.set(leds=[5], color='#112233')
        rw.set(leds=[6], color='#112233')
        self.assertRaises(IndexError,
                          lambda: rw.set(leds=[7], color='#112233'))
    def test_ring_led_set_remembers_previous_state(self):
        led_mock = Mock()
        led_mock.display_user_frame = Mock()
        led_mock.count = 6

        led_resource = ResourceWrapper(Resource(), 0)

        script = Mock()
        script.is_stop_requested = False

        rw = RingLedWrapper(script, led_mock, led_resource)
        rw.set(1, '#112233')
        self.assertEqual([hex2rgb("#112233"), 0, 0, 0, 0, 0], led_mock.display_user_frame.call_args[0][0])
        self.assertEqual(1, led_mock.display_user_frame.call_count)

        rw.set([3, 4], '#223344')
        self.assertEqual(
            [hex2rgb("#112233"), 0, hex2rgb("#223344"), hex2rgb("#223344"), 0, 0],
            led_mock.display_user_frame.call_args[0][0]
        )
        self.assertEqual(2, led_mock.display_user_frame.call_count)
Esempio n. 15
0
    def test_empty_resource_can_be_taken(self):
        r = Resource()

        handle = r.request()
        self.assertIsNotNone(handle)