Пример #1
0
    def test_infrared_sensor(self):
        clean_arena()
        populate_arena({'infrared_sensor' : [0, 'in1']})

        s = ev3.InfraredSensor()

        self.assertTrue(s.connected)

        self.assertEqual(s.device_index,    0)
        self.assertEqual(s.bin_data_format, 's8')
        self.assertEqual(s.bin_data('<b'),  (16,))
        self.assertEqual(s.num_values,      1)
        self.assertEqual(s.address,         'in1')
        self.assertEqual(s.value(0),        16)
Пример #2
0
    def test_tank_units(self):
        clean_arena()
        populate_arena([('large_motor', 0, 'outA'),
                        ('large_motor', 1, 'outB')])

        drive = MoveTank(OUTPUT_A, OUTPUT_B)
        drive.on_for_rotations(SpeedDPS(400), SpeedDPM(10000), 10)

        self.assertEqual(drive.left_motor.position, 0)
        self.assertEqual(drive.left_motor.position_sp, 10 * 360)
        self.assertEqual(drive.left_motor.speed_sp, 400)

        self.assertEqual(drive.right_motor.position, 0)
        self.assertAlmostEqual(drive.right_motor.position_sp,
                               10 * 360 * ((10000 / 60) / 400))
        self.assertAlmostEqual(drive.right_motor.speed_sp,
                               10000 / 60,
                               delta=0.5)
Пример #3
0
    def test_motor_on_for_rotations(self):
        clean_arena()
        populate_arena([('large_motor', 0, 'outA')])

        m = LargeMotor()

        # simple case
        m.on_for_rotations(75, 5)
        self.assertEqual(m.speed_sp, int(round(0.75 * 1050)))
        self.assertEqual(m.position_sp, 5 * 360)

        # None speed
        with self.assertRaises(ValueError):
            m.on_for_rotations(None, 5)

        # None distance
        with self.assertRaises(ValueError):
            m.on_for_rotations(75, None)
Пример #4
0
    def test_device(self):
        clean_arena()
        populate_arena([('medium_motor', 0, 'outA'), ('infrared_sensor', 0, 'in1')])

        d = ev3dev2.Device('tacho-motor', 'motor*')

        d = ev3dev2.Device('tacho-motor', 'motor0')

        d = ev3dev2.Device('tacho-motor', 'motor*', driver_name='lego-ev3-m-motor')

        d = ev3dev2.Device('tacho-motor', 'motor*', address='outA')

        with self.assertRaises(ev3dev2.DeviceNotFound):
            d = ev3dev2.Device('tacho-motor', 'motor*', address='outA', driver_name='not-valid')

        d = ev3dev2.Device('lego-sensor', 'sensor*')

        with self.assertRaises(ev3dev2.DeviceNotFound):
            d = ev3dev2.Device('this-does-not-exist')
Пример #5
0
    def test_medium_motor(self):
        def dummy(self):
            pass

        clean_arena()
        populate_arena({'medium_motor': [0, 'outA']})

        # Do not write motor.command on exit (so that fake tree stays intact)
        ev3.MediumMotor.__del__ = dummy

        m = ev3.MediumMotor()

        self.assertTrue(m.connected)

        self.assertEqual(m.device_index, 0)

        # Check that reading twice works:
        self.assertEqual(m.driver_name, 'lego-ev3-m-motor')
        self.assertEqual(m.driver_name, 'lego-ev3-m-motor')

        self.assertEqual(m.count_per_rot, 360)
        self.assertEqual(m.commands, [
            'run-forever', 'run-to-abs-pos', 'run-to-rel-pos', 'run-timed',
            'run-direct', 'stop', 'reset'
        ])
        self.assertEqual(m.duty_cycle, 0)
        self.assertEqual(m.duty_cycle_sp, 42)
        self.assertEqual(m.polarity, 'normal')
        self.assertEqual(m.address, 'outA')
        self.assertEqual(m.position, 42)
        self.assertEqual(m.position_sp, 42)
        self.assertEqual(m.ramp_down_sp, 0)
        self.assertEqual(m.ramp_up_sp, 0)
        self.assertEqual(m.speed, 0)
        self.assertEqual(m.speed_sp, 0)
        self.assertEqual(m.state, ['running'])
        self.assertEqual(m.stop_action, 'coast')
        self.assertEqual(m.time_sp, 1000)

        with self.assertRaises(Exception):
            c = m.command
Пример #6
0
    def test_motor_on_for_degrees(self):
        clean_arena()
        populate_arena([('large_motor', 0, 'outA')])

        m = LargeMotor()

        # simple case
        m.on_for_degrees(75, 100)
        self.assertEqual(m.speed_sp, int(round(0.75 * 1050)))
        self.assertEqual(m.position_sp, 100)

        # various negative cases; values act like multiplication
        m.on_for_degrees(-75, 100)
        self.assertEqual(m.speed_sp, int(round(0.75 * 1050)))
        self.assertEqual(m.position_sp, -100)

        m.on_for_degrees(75, -100)
        self.assertEqual(m.speed_sp, int(round(0.75 * 1050)))
        self.assertEqual(m.position_sp, -100)

        m.on_for_degrees(-75, -100)
        self.assertEqual(m.speed_sp, int(round(0.75 * 1050)))
        self.assertEqual(m.position_sp, 100)

        # zero speed (on-device, this will return immediately due to reported stall)
        m.on_for_degrees(0, 100)
        self.assertEqual(m.speed_sp, 0)
        self.assertEqual(m.position_sp, 100)

        # zero distance
        m.on_for_degrees(75, 0)
        self.assertEqual(m.speed_sp, int(round(0.75 * 1050)))
        self.assertEqual(m.position_sp, 0)

        # zero speed and distance
        m.on_for_degrees(0, 0)
        self.assertEqual(m.speed_sp, 0)
        self.assertEqual(m.position_sp, 0)
Пример #7
0
    def test_medium_motor(self):
        def dummy(self):
            pass

        clean_arena()
        populate_arena({'medium_motor' : [0, 'outA']})

        # Do not write motor.command on exit (so that fake tree stays intact)
        ev3.MediumMotor.__del__ = dummy

        m = ev3.MediumMotor()

        self.assertTrue(m.connected);

        self.assertEqual(m.device_index, 0)

        # Check that reading twice works:
        self.assertEqual(m.driver_name, 'lego-ev3-m-motor')
        self.assertEqual(m.driver_name, 'lego-ev3-m-motor')

        self.assertEqual(m.count_per_rot,            360)
        self.assertEqual(m.commands,                 ['run-forever', 'run-to-abs-pos', 'run-to-rel-pos', 'run-timed', 'run-direct', 'stop', 'reset'])
        self.assertEqual(m.duty_cycle,               0)
        self.assertEqual(m.duty_cycle_sp,            42)
        self.assertEqual(m.polarity,                 'normal')
        self.assertEqual(m.address,                  'outA')
        self.assertEqual(m.position,                 42)
        self.assertEqual(m.position_sp,              42)
        self.assertEqual(m.ramp_down_sp,             0)
        self.assertEqual(m.ramp_up_sp,               0)
        self.assertEqual(m.speed,                    0)
        self.assertEqual(m.speed_sp,                 0)
        self.assertEqual(m.state,                    ['running'])
        self.assertEqual(m.stop_action,              'coast')
        self.assertEqual(m.time_sp,                  1000)

        with self.assertRaises(Exception):
            c = m.command
Пример #8
0
    def test_joystick(self):
        clean_arena()
        populate_arena([('large_motor', 0, 'outA'),
                        ('large_motor', 1, 'outB')])

        drive = MoveJoystick(OUTPUT_A, OUTPUT_B)

        # With the joystick at (x, y) of (0, 50) we should drive straigh ahead
        # at 50% of max_speed
        drive.on(0, 50)
        self.assertEqual(drive.left_motor.speed_sp, 1050 / 2)
        self.assertEqual(drive.right_motor.speed_sp, 1050 / 2)
        self.assertEqual(
            drive.left_motor._get_attribute(None, 'command')[1], 'run-forever')
        self.assertEqual(
            drive.right_motor._get_attribute(None, 'command')[1],
            'run-forever')

        # With the joystick centered, motors should both be stopped
        drive.on(0, 0)
        self.assertEqual(
            drive.left_motor._get_attribute(None, 'command')[1], 'stop')
        self.assertEqual(
            drive.right_motor._get_attribute(None, 'command')[1], 'stop')
Пример #9
0
    def test_infrared_sensor(self):
        clean_arena()
        populate_arena([('infrared_sensor', 0, 'in1')])

        s = InfraredSensor()

        self.assertEqual(s.device_index, 0)
        self.assertEqual(s.bin_data_format, 's8')
        self.assertEqual(s.bin_data('<b'), (16, ))
        self.assertEqual(s.num_values, 1)
        self.assertEqual(s.address, 'in1')
        self.assertEqual(s.value(0), 16)
        self.assertEqual(s.mode, "IR-PROX")

        s.mode = "IR-REMOTE"
        self.assertEqual(s.mode, "IR-REMOTE")

        val = s.proximity
        self.assertEqual(s.mode, "IR-PROX")
        self.assertEqual(val, 16)

        val = s.buttons_pressed()
        self.assertEqual(s.mode, "IR-REMOTE")
        self.assertEqual(val, [])
Пример #10
0
    def test_device(self):
        clean_arena()
        populate_arena({'medium_motor' : [0, 'outA'], 'infrared_sensor' : [0, 'in1']})

        d = ev3.Device('tacho-motor', 'motor*')
        self.assertTrue(d.connected)

        d = ev3.Device('tacho-motor', 'motor0')
        self.assertTrue(d.connected)

        d = ev3.Device('tacho-motor', 'motor*', driver_name='lego-ev3-m-motor')
        self.assertTrue(d.connected)

        d = ev3.Device('tacho-motor', 'motor*', address='outA')
        self.assertTrue(d.connected)

        d = ev3.Device('tacho-motor', 'motor*', address='outA', driver_name='not-valid')
        self.assertTrue(not d.connected)

        d = ev3.Device('lego-sensor', 'sensor*')
        self.assertTrue(d.connected)

        d = ev3.Device('this-does-not-exist')
        self.assertFalse(d.connected)
Пример #11
0
    def test_move_tank_relative_distance(self):
        clean_arena()
        populate_arena([('large_motor', 0, 'outA'),
                        ('large_motor', 1, 'outB')])

        drive = MoveTank(OUTPUT_A, OUTPUT_B)

        # simple case (degrees)
        drive.on_for_degrees(50, 25, 100)
        self.assertEqual(drive.left_motor.position_sp, 100)
        self.assertEqual(drive.left_motor.speed_sp, 0.50 * 1050)
        self.assertEqual(drive.right_motor.position_sp, 50)
        self.assertAlmostEqual(drive.right_motor.speed_sp,
                               0.25 * 1050,
                               delta=0.5)

        # simple case (rotations, based on degrees)
        drive.on_for_rotations(50, 25, 10)
        self.assertEqual(drive.left_motor.position_sp, 10 * 360)
        self.assertEqual(drive.left_motor.speed_sp, 0.50 * 1050)
        self.assertEqual(drive.right_motor.position_sp, 5 * 360)
        self.assertAlmostEqual(drive.right_motor.speed_sp,
                               0.25 * 1050,
                               delta=0.5)

        # negative distance
        drive.on_for_rotations(50, 25, -10)
        self.assertEqual(drive.left_motor.position_sp, -10 * 360)
        self.assertEqual(drive.left_motor.speed_sp, 0.50 * 1050)
        self.assertEqual(drive.right_motor.position_sp, -5 * 360)
        self.assertAlmostEqual(drive.right_motor.speed_sp,
                               0.25 * 1050,
                               delta=0.5)

        # negative speed
        drive.on_for_rotations(-50, 25, 10)
        self.assertEqual(drive.left_motor.position_sp, -10 * 360)
        self.assertEqual(drive.left_motor.speed_sp, 0.50 * 1050)
        self.assertEqual(drive.right_motor.position_sp, 5 * 360)
        self.assertAlmostEqual(drive.right_motor.speed_sp,
                               0.25 * 1050,
                               delta=0.5)

        # negative distance and speed
        drive.on_for_rotations(-50, 25, -10)
        self.assertEqual(drive.left_motor.position_sp, 10 * 360)
        self.assertEqual(drive.left_motor.speed_sp, 0.50 * 1050)
        self.assertEqual(drive.right_motor.position_sp, -5 * 360)
        self.assertAlmostEqual(drive.right_motor.speed_sp,
                               0.25 * 1050,
                               delta=0.5)

        # both speeds zero but nonzero distance
        drive.on_for_rotations(0, 0, 10)
        self.assertEqual(drive.left_motor.position_sp, 10 * 360)
        self.assertAlmostEqual(drive.left_motor.speed_sp, 0)
        self.assertEqual(drive.right_motor.position_sp, 10 * 360)
        self.assertAlmostEqual(drive.right_motor.speed_sp, 0)

        # zero distance
        drive.on_for_rotations(25, 50, 0)
        self.assertEqual(drive.left_motor.position_sp, 0)
        self.assertAlmostEqual(drive.left_motor.speed_sp,
                               0.25 * 1050,
                               delta=0.5)
        self.assertEqual(drive.right_motor.position_sp, 0)
        self.assertAlmostEqual(drive.right_motor.speed_sp, 0.50 * 1050)

        # zero distance and zero speed
        drive.on_for_rotations(0, 0, 0)
        self.assertEqual(drive.left_motor.position_sp, 0)
        self.assertAlmostEqual(drive.left_motor.speed_sp, 0)
        self.assertEqual(drive.right_motor.position_sp, 0)
        self.assertAlmostEqual(drive.right_motor.speed_sp, 0)
Пример #12
0
    # already existed in the buffer. On the real device we're writing to sysfs
    # attributes where there isn't any persistent buffer, but in the test
    # environment they're normal files on disk which retain previous data.
    attribute = _internal_set_attribute(self, attribute, name, value)
    attribute.write(b'\n')
    return attribute
ev3dev2.Device._set_attribute = _set_attribute

_internal_get_attribute = ev3dev2.Device._get_attribute
def _get_attribute(self, attribute, name):
    # Split on newline delimiter; see _set_attribute above
    attribute, value = _internal_get_attribute(self, attribute, name)
    return attribute, value.split('\n', 1)[0]
ev3dev2.Device._get_attribute = _get_attribute

def dummy_wait(self, cond, timeout=None):
    pass

Motor.wait = dummy_wait

def dummy_speak(self, text, play_type):
    pass
Sound.speak = dummy_speak

if __name__ == "__main__":
    clean_arena()
    populate_arena([
        ('large_motor', 0, 'outA'),
        ('large_motor', 1, 'outB'),])
    main()
Пример #13
0
def main_docker():
    clean_arena()
    populate_arena([('large_motor', 0, 'outA'),('large_motor', 1, 'outB'),('ultrasonic_sensor', 0, 'in2'),('color_sensor', 1, 'in3')])
    main()