Merge pull request #9 from sonelu/dynamixel

changed to pytest and Dynamixel testing on CI

.travis.yml

@@ -26,13 +26,14 @@ before_install:
   - pip install flake8
   - pip install coverage
   - pip install codecov
+  - pip install pytest
 
 
 install:
   - pip install .[all]
 
 script:
-  - coverage run tests.py
+  - coverage run -m pytest -v tests.py
   - flake8 roboglia --statistics --count
 
 after_success:

roboglia/base/__init__.py

@@ -19,7 +19,6 @@
 
 from .thread import BaseThread                  # noqa: 401
 from .thread import BaseLoop                    # noqa: 401
-from .thread import StepLoop                    # noqa: 401
 
 from .sync import BaseSync                      # noqa: 401
 from .sync import BaseReadSync                  # noqa: 401

roboglia/base/bus.py

@@ -50,6 +50,7 @@ class BaseBus():
     def __init__(self, init_dict):
         # alredy checked by robot
         self.__name = init_dict['name']
+        self.__robot = init_dict['robot']
         check_key('port', init_dict, 'bus', self.__name, logger)
         self.__port = init_dict['port']
         self.__auto_open = init_dict.get('auto', True)
@@ -61,6 +62,11 @@ def name(self):
         """(read-only) the bus name."""
         return self.__name
 
+    @property
+    def robot(self):
+        """The robot that owns the bus."""
+        return self.__robot
+
     @property
     def port(self):
         """(read-only) the bus port."""
@@ -89,7 +95,7 @@ def is_open(self):
         """Returns `True` or `False` if the bus is open. Must be overriden
         by the subclass.
         """
-        return False
+        raise NotImplementedError
 
     def read(self, dev, reg):
         """Reads one standrd information from the bus. Must be overwriden.
@@ -189,7 +195,7 @@ def read(self, dev, reg):
         the value.
         """
         if not self.is_open:
-            logger.error(f'attempt to write to closed bus {self.name}')
+            logger.error(f'attempt to read from a closed bus {self.name}')
             return None
         else:
             if (dev.dev_id, reg.address) not in self.__last:

roboglia/base/device.py

@@ -53,50 +53,50 @@ class BaseDevice():
     """
     def __init__(self, init_dict):
         # these are already checked by robot
-        self._name = init_dict['name']
-        self._bus = init_dict['bus']
-        check_key('id', init_dict, 'device', self._name, logger)
-        check_key('model', init_dict, 'device', self._name, logger)
-        self._dev_id = init_dict['id']
-        self._model = init_dict['model']
+        self.__name = init_dict['name']
+        self.__bus = init_dict['bus']
+        check_key('id', init_dict, 'device', self.__name, logger)
+        check_key('model', init_dict, 'device', self.__name, logger)
+        self.__dev_id = init_dict['id']
+        self.__model = init_dict['model']
         # registers
         model_path = init_dict.get('path', self.get_model_path())
-        model_file = os.path.join(model_path, self._model + '.yml')
+        model_file = os.path.join(model_path, self.__model + '.yml')
         with open(model_file, 'r') as f:
             model_ini = yaml.load(f, Loader=yaml.FullLoader)
-        self._registers = {}
+        self.__registers = {}
         for index, reg_info in enumerate(model_ini['registers']):
-            check_key('name', reg_info, self._model + ' register',
+            check_key('name', reg_info, self.__model + ' register',
                       index, logger)
             reg_class_name = reg_info.get('class', self.default_register())
             reg_class = get_registered_class(reg_class_name)
             reg_info['device'] = self
             new_register = reg_class(reg_info)
             self.__dict__[reg_info['name']] = new_register
-            self._registers[reg_info['name']] = new_register
+            self.__registers[reg_info['name']] = new_register
         self.__auto_open = init_dict.get('auto', True)
         check_options(self.__auto_open, [True, False], 'device',
                       self.name, logger)
 
     @property
     def name(self):
         """Device name."""
-        return self._name
+        return self.__name
 
     @property
     def registers(self):
         """Device registers as dict."""
-        return self._registers
+        return self.__registers
 
     @property
     def dev_id(self):
         """The device number"""
-        return self._dev_id
+        return self.__dev_id
 
     @property
     def bus(self):
         """The bus where the device is connected to."""
-        return self._bus
+        return self.__bus
 
     @property
     def auto_open(self):
@@ -131,26 +131,27 @@ def read_register(self, register):
         More complex devices should overwrite the method to provide
         specific functionality.
         """
-        return self._bus.read(self, register)
+        return self.bus.read(self, register)
 
     def write_register(self, register, value):
         """Implements the write of a register using the associated bus.
         More complex devices should overwrite the method to provide
         specific functionality.
         """
-        self._bus.write(self, register, value)
+        self.bus.write(self, register, value)
 
     def open(self):
-        """Performs initialization of the device."""
-        pass
+        """Performs initialization of the device by reading all registers."""
+        for register in self.registers.values():
+            self.read_register(register)
 
     def close(self):
         """Perform device closure."""
         pass
 
     def __str__(self):
-        result = f'Device: {self._name}, ID: {self._dev_id} ' + \
-                 f'on bus: {self._bus.name}:\n'
-        for reg in self._registers.values():
+        result = f'Device: {self.name}, ID: {self.dev_id} ' + \
+                 f'on bus: {self.bus.name}:\n'
+        for reg in self.registers.values():
             result += f'\t{reg}\n'
         return result

roboglia/base/devices/DUMMY.yml

@@ -45,7 +45,7 @@ registers:
     max: 1023
     factor: 10.24
 
-  - name: enable
+  - name: enable_device
     class: BoolRegister
     address: 60
     access: RW
@@ -78,4 +78,16 @@ registers:
     max: 2047
     factor: 10.24
     threshold: 1024
+    default: 1536
+
+    # not really often in practice as RW
+    # here for testing
+  - name: writtable_current_load
+    class: RegisterWithThreshold
+    address: 95
+    size: 2
+    access: RW
+    max: 2047
+    factor: 10.24
+    threshold: 1024
     default: 1536