Merge pull request #164 from rhempel/feature-support-new-11-kernel

Feature support new 11 kernel

Author: rhempel

ev3dev-lang

@@ -53,6 +53,7 @@ class Leds(object):
     LED1 = ( blue_led1, )
     LED2 = ( blue_led2, )
 
+    BLACK = ( 0, )
     BLUE = ( 1, )
 
     @staticmethod

ev3dev/brickpi.py

@@ -24,7 +24,7 @@
 # -----------------------------------------------------------------------------
 
 # ~autogen autogen-header
-# Sections of the following code were auto-generated based on spec v1.1.0
+# Sections of the following code were auto-generated based on spec v1.2.0
 
 # ~autogen
 
@@ -269,7 +269,6 @@ def __init__(self, address=None, name_pattern=SYSTEM_DEVICE_NAME_CONVENTION, nam
         self._driver_name = None
         self._duty_cycle = None
         self._duty_cycle_sp = None
-        self._encoder_polarity = None
         self._full_travel_count = None
         self._polarity = None
         self._position = None
@@ -286,8 +285,8 @@ def __init__(self, address=None, name_pattern=SYSTEM_DEVICE_NAME_CONVENTION, nam
         self._speed_i = None
         self._speed_d = None
         self._state = None
-        self._stop_command = None
-        self._stop_commands = None
+        self._stop_action = None
+        self._stop_actions = None
         self._time_sp = None
 
 # ~autogen
@@ -391,22 +390,6 @@ def duty_cycle_sp(self):
     def duty_cycle_sp(self, value):
         self._duty_cycle_sp = self.set_attr_int(self._duty_cycle_sp, 'duty_cycle_sp', value)
 
-    @property
-    def encoder_polarity(self):
-        """
-        Sets the polarity of the rotary encoder. This is an advanced feature to all
-        use of motors that send inversed encoder signals to the EV3. This should
-        be set correctly by the driver of a device. It You only need to change this
-        value if you are using a unsupported device. Valid values are `normal` and
-        `inversed`.
-        """
-        self._encoder_polarity, value = self.get_attr_string(self._encoder_polarity, 'encoder_polarity')
-        return value
-
-    @encoder_polarity.setter
-    def encoder_polarity(self, value):
-        self._encoder_polarity = self.set_attr_string(self._encoder_polarity, 'encoder_polarity', value)
-
     @property
     def full_travel_count(self):
         """
@@ -613,35 +596,35 @@ def state(self):
         return value
 
     @property
-    def stop_command(self):
+    def stop_action(self):
         """
-        Reading returns the current stop command. Writing sets the stop command.
+        Reading returns the current stop action. Writing sets the stop action.
         The value determines the motors behavior when `command` is set to `stop`.
         Also, it determines the motors behavior when a run command completes. See
-        `stop_commands` for a list of possible values.
+        `stop_actions` for a list of possible values.
         """
-        self._stop_command, value = self.get_attr_string(self._stop_command, 'stop_command')
+        self._stop_action, value = self.get_attr_string(self._stop_action, 'stop_action')
         return value
 
-    @stop_command.setter
-    def stop_command(self, value):
-        self._stop_command = self.set_attr_string(self._stop_command, 'stop_command', value)
+    @stop_action.setter
+    def stop_action(self, value):
+        self._stop_action = self.set_attr_string(self._stop_action, 'stop_action', value)
 
     @property
-    def stop_commands(self):
+    def stop_actions(self):
         """
-        Returns a list of stop modes supported by the motor controller.
+        Returns a list of stop actions supported by the motor controller.
         Possible values are `coast`, `brake` and `hold`. `coast` means that power will
         be removed from the motor and it will freely coast to a stop. `brake` means
         that power will be removed from the motor and a passive electrical load will
         be placed on the motor. This is usually done by shorting the motor terminals
         together. This load will absorb the energy from the rotation of the motors and
         cause the motor to stop more quickly than coasting. `hold` does not remove
-        power from the motor. Instead it actively try to hold the motor at the current
+        power from the motor. Instead it actively tries to hold the motor at the current
         position. If an external force tries to turn the motor, the motor will 'push
         back' to maintain its position.
         """
-        self._stop_commands, value = self.get_attr_set(self._stop_commands, 'stop_commands')
+        self._stop_actions, value = self.get_attr_set(self._stop_actions, 'stop_actions')
         return value
 
     @property
@@ -814,7 +797,7 @@ class LargeMotor(Motor):
     """
 
     SYSTEM_CLASS_NAME = Motor.SYSTEM_CLASS_NAME
-    SYSTEM_DEVICE_NAME_CONVENTION = 'motor*'
+    SYSTEM_DEVICE_NAME_CONVENTION = '*'
 
     def __init__(self, address=None, name_pattern=SYSTEM_DEVICE_NAME_CONVENTION, name_exact=False, **kwargs):
 
@@ -831,7 +814,7 @@ class MediumMotor(Motor):
     """
 
     SYSTEM_CLASS_NAME = Motor.SYSTEM_CLASS_NAME
-    SYSTEM_DEVICE_NAME_CONVENTION = 'motor*'
+    SYSTEM_DEVICE_NAME_CONVENTION = '*'
 
     def __init__(self, address=None, name_pattern=SYSTEM_DEVICE_NAME_CONVENTION, name_exact=False, **kwargs):
 
@@ -848,7 +831,7 @@ class NxtMotor(Motor):
     """
 
     SYSTEM_CLASS_NAME = Motor.SYSTEM_CLASS_NAME
-    SYSTEM_DEVICE_NAME_CONVENTION = 'motor*'
+    SYSTEM_DEVICE_NAME_CONVENTION = '*'
 
     def __init__(self, address=None, name_pattern=SYSTEM_DEVICE_NAME_CONVENTION, name_exact=False, **kwargs):
 

ev3dev/core.py

@@ -55,11 +55,12 @@ class Leds(object):
     LEFT = ( red_left, green_left, )
     RIGHT = ( red_right, green_right, )
 
+    BLACK = ( 0, 0, )
     RED = ( 1, 0, )
     GREEN = ( 0, 1, )
     AMBER = ( 1, 1, )
     ORANGE = ( 1, 0.5, )
-    YELLOW = ( 0.5, 1, )
+    YELLOW = ( 0.1, 1, )
 
     @staticmethod
     def set_color(group, color, pct=1):

ev3dev/ev3.py

@@ -1,8 +1,8 @@
 # ~autogen spec_version
-spec_version = "1.1.0"
+spec_version = "1.2.0"
 kernel_versions = { 
-    "10-ev3dev"
-    "10-rc1-ev3dev"
+    "11-ev3dev"
+    "11-rc1-ev3dev"
     }
 
 # ~autogen

spec_version.py

@@ -118,31 +118,6 @@ def test_duty_cycle_sp_after_reset(self):
         self._param['motor'].command = 'reset'
         self.assertEqual(self._param['motor'].duty_cycle_sp, 0)
 
-class TestTachoMotorEncoderPolarityValue(ptc.ParameterizedTestCase):
-
-    def test_encoder_polarity_normal_value(self):
-        self._param['motor'].encoder_polarity = 'normal'
-        self.assertEqual(self._param['motor'].encoder_polarity, 'normal')
-
-    def test_encoder_polarity_inversed_value(self):
-        self._param['motor'].encoder_polarity = 'inversed'
-        self.assertEqual(self._param['motor'].encoder_polarity, 'inversed')
-
-    def test_encoder_polarity_illegal_value(self):
-        with self.assertRaises(IOError):
-            self._param['motor'].encoder_polarity = "ThisShouldNotWork"
-
-    def test_encoder_polarity_after_reset(self):
-        if ('normal' == motor_info[self._param['motor'].driver_name]['encoder_polarity']):
-            self._param['motor'].encoder_polarity = 'inversed'
-        else:
-            self._param['motor'].encoder_polarity = 'normal'
-        self._param['motor'].command = 'reset'
-        if ('normal' == motor_info[self._param['motor'].driver_name]['encoder_polarity']):
-            self.assertEqual(self._param['motor'].encoder_polarity, 'normal')
-        else:
-            self.assertEqual(self._param['motor'].encoder_polarity, 'inversed')
-
 class TestTachoMotorMaxSpeedValue(ptc.ParameterizedTestCase):
 
     def test_max_speed_value(self):
@@ -459,39 +434,39 @@ def test_state_value_after_reset(self):
         self._param['motor'].command = 'reset'
         self.assertEqual(self._param['motor'].state, [])
 
-class TestTachoMotorStopCommandValue(ptc.ParameterizedTestCase):
+class TestTachoMotorStopActionValue(ptc.ParameterizedTestCase):
 
-    def test_stop_command_illegal(self):
+    def test_stop_action_illegal(self):
         with self.assertRaises(IOError):
-            self._param['motor'].stop_command = 'ThisShouldNotWork'
+            self._param['motor'].stop_action = 'ThisShouldNotWork'
 
-    def test_stop_command_coast(self):
-        self._param['motor'].stop_command = 'coast'
-        self.assertEqual(self._param['motor'].stop_command, 'coast')
+    def test_stop_action_coast(self):
+        self._param['motor'].stop_action = 'coast'
+        self.assertEqual(self._param['motor'].stop_action, 'coast')
 
-    def test_stop_command_brake(self):
-        self._param['motor'].stop_command = 'brake'
-        self.assertEqual(self._param['motor'].stop_command, 'brake')
+    def test_stop_action_brake(self):
+        self._param['motor'].stop_action = 'brake'
+        self.assertEqual(self._param['motor'].stop_action, 'brake')
 
-    def test_stop_command_hold(self):
-        self._param['motor'].stop_command = 'hold'
-        self.assertEqual(self._param['motor'].stop_command, 'hold')
+    def test_stop_action_hold(self):
+        self._param['motor'].stop_action = 'hold'
+        self.assertEqual(self._param['motor'].stop_action, 'hold')
 
-    def test_time_sp_after_reset(self):
-        self._param['motor'].stop_command = 'hold'
+    def test_stop_action_after_reset(self):
+        self._param['motor'].stop_action = 'hold'
         self._param['motor'].command = 'reset'
-        self.assertEqual(self._param['motor'].stop_command, 'coast')
+        self.assertEqual(self._param['motor'].stop_action, 'coast')
 
-class TestTachoMotorStopCommandsValue(ptc.ParameterizedTestCase):
+class TestTachoMotorStopActionsValue(ptc.ParameterizedTestCase):
 
-    def test_stop_commands_value(self):
-        self.assertTrue(set(self._param['motor'].stop_commands) == {'coast'
-                                                                   ,'brake'
-                                                                   ,'hold'})
+    def test_stop_actions_value(self):
+        self.assertTrue(set(self._param['motor'].stop_actions) == {'coast'
+                                                                  ,'brake'
+                                                                  ,'hold'})
 
-    def test_stop_commands_value_is_read_only(self):
+    def test_stop_actions_value_is_read_only(self):
         with self.assertRaises(AttributeError):
-            self._param['motor'].stop_commands = "ThisShouldNotWork"
+            self._param['motor'].stop_actions = "ThisShouldNotWork"
 
 class TestTachoMotorTimeSpValue(ptc.ParameterizedTestCase):
 
@@ -528,7 +503,6 @@ def AddTachoMotorParameterTestsToSuite( suite, driver_name, params ):
         suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorFullTravelCountValue, param=params))
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorDriverNameValue, param=params))
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorDutyCycleSpValue, param=params))
-    suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorEncoderPolarityValue, param=params))
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorMaxSpeedValue, param=params))
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorPositionPValue, param=params))
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorPositionIValue, param=params))
@@ -544,8 +518,8 @@ def AddTachoMotorParameterTestsToSuite( suite, driver_name, params ):
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorSpeedIValue, param=params))
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorSpeedDValue, param=params))
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorStateValue, param=params))
-    suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorStopCommandValue, param=params))
-    suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorStopCommandsValue, param=params))
+    suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorStopActionValue, param=params))
+    suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorStopActionsValue, param=params))
     suite.addTest(ptc.ParameterizedTestCase.parameterize(TestTachoMotorTimeSpValue, param=params))
 
 if __name__ == '__main__':