Refactor plugin input and output classes.

Author: jburhenn

myDevices/devices/analog/__init__.py

@@ -91,10 +91,9 @@ def analogReadAllVolt(self):
             values[i] = float("%.2f" % self.analogReadVolt(i))
         return values
 
-    def read(self, channel, data_type=None, diff=False):
-        read_functions = {'float': self.analogReadFloat, 'f': self.analogReadFloat,
-            'volt': self.analogReadVolt, 'v': self.analogReadVolt}
-        read_function = read_functions.get(data_type, self.analogRead)
+    def read(self, channel, value_type=None, diff=False):
+        read_functions = {'float': self.analogReadFloat, 'volt': self.analogReadVolt}
+        read_function = read_functions.get(value_type, self.analogRead)
         return read_function(channel, diff)
 
     def readFloat(self, channel, diff=False):
@@ -131,8 +130,10 @@ def analogWriteVolt(self, channel, value):
         self.analogWriteFloat(channel, value /self._analogRef)
         return self.analogReadVolt(channel)
 
-    def write(self, channel, value):
-        return self.analogWrite(channel, value)
+    def write(self, channel, value, value_type=None):
+        write_functions = {'float': self.analogWriteFloat, 'volt': self.analogWriteVolt}
+        write_function = write_functions.get(value_type, self.analogWrite)        
+        return write_function(channel, value)
 
     def writeFloat(self, channel, value):
         return self.analogWriteFloat(channel, value)
@@ -206,17 +207,17 @@ def pwmWriteFloat(self, channel, value):
         self.pwmWrite(channel, int(value * self._pwmMax))
         return self.pwmReadFloat(channel)
 
-    def read(self, channel, data_type=None):
+    def read(self, channel, value_type=None):
         read_functions = {'float': self.pwmReadFloat, 'angle': self.pwmReadAngle}
-        read_function = read_functions.get(data_type, self.pwmRead)
+        read_function = read_functions.get(value_type, self.pwmRead)
         return read_function(channel)        
 
     def readFloat(self, channel):
         return self.pwmReadFloat(channel)
 
-    def write(self, channel, value, data_type=None):
+    def write(self, channel, value, value_type=None):
         write_functions = {'float': self.pwmWriteFloat, 'angle': self.pwmWriteAngle}
-        write_function = write_functions.get(data_type, self.pwmWrite)        
+        write_function = write_functions.get(value_type, self.pwmWrite)
         return write_function(channel, value)
 
     def writeFloat(self, channel, value):
@@ -291,5 +292,4 @@ def writeAngle(self, channel, value):
 DRIVERS["mcp4725"] = ["MCP4725"]
 DRIVERS["mcp48XX"] = ["MCP4802", "MCP4812", "MCP4822"]
 DRIVERS["mcp492X"] = ["MCP4921", "MCP4922"]
-DRIVERS["pca9685"] = ["PCA9685"]
 DRIVERS["pcf8591"] = ["PCF8591"]

myDevices/plugins/analog.py

@@ -14,7 +14,7 @@ def __init__(self, plugin_id):
         Arguments:
             plugin_id: Plugin ID in the format 'plugin_name:section', e.g. 'cayenne-pca9685:PCA9685'
         """        
-        InputOutput.__init__(self, plugin_id, 'analog', 'in')
+        InputOutput.__init__(self, plugin_id, 'in', 'analog_sensor')
 
     def read_float(self, channel):
         """Read the float value on the specified channel."""
@@ -29,18 +29,17 @@ def read_angle(self, channel):
         return self.read_value(channel, 'angle')
 
 
-class AnalogIO(AnalogInput):
+class AnalogOutput(AnalogInput):
     """Reads/writes data from an analog or PWM plugin input/output."""
 
-    def __init__(self, plugin_id, function):
+    def __init__(self, plugin_id):
         """Initializes the plugin input/output.
         
         Arguments:
             plugin_id: Plugin ID in the format 'plugin_name:section', e.g. 'cayenne-pca9685:PCA9685'
-            function: The pin function, 'in' if the pin is an input, 'out' if it is an output 
-        """        
-        InputOutput.__init__(self, plugin_id, 'analog', function)
-       
+        """
+        InputOutput.__init__(self, plugin_id, 'out', 'analog_actuator')
+
     def write_float(self, value, channel):
         """Write the float value on the specified channel."""
         return self.write_value(value, channel, 'float')
@@ -51,17 +50,4 @@ def write_volt(self, value, channel):
 
     def write_angle(self, value, channel):
         """Write the angle on the specified channel."""
-        return self.write_value(value, channel, 'angle')
-
-
-class AnalogOutput(AnalogIO):
-    """Reads/writes data from an analog or PWM plugin input/output."""
-
-    def __init__(self, plugin_id):
-        """Initializes the plugin input/output.
-        
-        Arguments:
-            plugin_id: Plugin ID in the format 'plugin_name:section', e.g. 'cayenne-pca9685:PCA9685'
-        """        
-        AnalogIO.__init__(self, plugin_id, 'out')
-  
+        return self.write_value(value, channel, 'angle')  

myDevices/plugins/digital.py

@@ -1,97 +1,33 @@
 """
 This module provides classes for interfacing with digital plugins.
 """
-from myDevices.plugins.manager import PluginManager
+from myDevices.plugins.io import InputOutput
 from myDevices.utils.logger import info, debug, exception
 
 
-class DigitalIO():
-    """Reads data from an digital input/output."""
+class DigitalInput(InputOutput):
+    """Reads data from an digital input."""
 
-    def __init__(self, gpio, function):
-        """Initializes the digital input/output.
+    def __init__(self, plugin_id):
+        """Initializes the plugin input.
         
         Arguments:
-            gpio: The GPIO plugin ID in the format 'plugin_name:section', e.g. 'cayenne-mcp23xxx:MCP'
-            function: The pin function, 'in' if the pin is an input, 'out' if it is an output
-        """
-        self.gpio_name = gpio
-        self.gpio = None
-        self.function = function.lower()
-        self.current_functions = {}
-        self.read_args = {}
-        self.write_args = {}
-        self.plugin_manager = PluginManager()
-        self.set_gpio()
-    
-    def set_gpio(self):
-        """Sets the GPIO plugin."""
-        if not self.gpio:
-            self.gpio = self.plugin_manager.get_plugin_by_id(self.gpio_name)
-            self.read_args = self.plugin_manager.get_args(self.gpio, 'read_args')
-            self.write_args = self.plugin_manager.get_args(self.gpio, 'write_args')
-
-    def set_function(self, channel):
-        """Sets the GPIO function."""
-        if self.gpio and (channel not in self.current_functions or self.function != self.current_functions[channel]):
-            function = getattr(self.gpio['instance'], self.gpio['set_function'])(channel, self.function).lower()
-            self.current_functions[channel] = function
-            if function == 'in':
-                try:
-                    debug('Register callback for channel {}'.format(channel))
-                    getattr(self.gpio['instance'], self.gpio['register_callback'])(channel, self.data_changed, data=channel)
-                except:
-                    debug('Unable to register callback for channel {}'.format(channel))
-                    pass
-
-    def to_tuple(self, value):
-        """Converts value to tuple with the appropriate data type."""
-        data_type = 'digital_sensor'
-        if (self.function == 'out'):
-            data_type = 'digital_actuator'
-        return (value, data_type)
-
-    def read_value(self, channel):
-        """Read the data value on the specified channel."""
-        self.set_gpio()
-        self.set_function(channel)
-        try:
-            value = getattr(self.gpio['instance'], self.gpio['read'])(channel, **self.read_args)
-            value = int(value)
-        except ValueError as e:
-            debug(e)
-            value = None
-        return value
-
-    def read(self, channel):
-        """Gets the digital value for the channel as a tuple with the type."""
-        return self.to_tuple(self.read_value(channel))
+            plugin_id: Plugin ID in the format 'plugin_name:section', e.g. 'cayenne-pca9685:PCA9685'
+        """        
+        InputOutput.__init__(self, plugin_id, 'in', 'digital_sensor')
 
-    def write_value(self, value, channel):
-        """Write the data value on the specified channel."""
-        self.set_gpio()
-        self.set_function(channel)
-        try:
-            value = getattr(self.gpio['instance'], self.gpio['write'])(channel, int(value), **self.write_args)
-        except ValueError as e:
-            debug(e)
-            value = None
-        return value
+    def value_to_tuple(self, value):
+        """Converts value to tuple with the appropriate Cayenne data type."""
+        return (int(value), self.data_type)
 
-    def write(self, value, channel):
-        """Write the digital value for the channel."""
-        return self.write_value(value, channel)
 
-    def register_callback(self, callback):
-        """Register a callback for data changes."""
-        info('Registering callback: {}'.format(callback))
-        self.callback = callback
+class DigitalOutput(DigitalInput):
+    """Reads and writes data from a digital output."""
 
-    def unregister_callback(self):
-        """Register a callback for data changes."""
-        self.callback = None
-
-    def data_changed(self, channel, value):
-        """Callback that is called when data has changed."""
-        if self.callback:
-            self.callback(self.to_tuple(value))
+    def __init__(self, plugin_id):
+        """Initializes the digital input/output.
+        
+        Arguments:
+            plugin_id: Plugin ID in the format 'plugin_name:section', e.g. 'cayenne-mcp23xxx:MCP'
+        """
+        InputOutput.__init__(self, plugin_id, 'out', 'digital_actuator')

myDevices/plugins/io.py

@@ -6,21 +6,19 @@
 
 
 class InputOutput():
-    """Reads/writes data from a digital, analog or PWM input/output plugin."""
-    DATA_TYPES = {'digital': {'in': 'digital_sensor', 'out':'digital_actuator'},
-        'analog': {'in': 'analog_sensor', 'out': 'analog_actuator'}}
+    """Reads data from and writes data to an input/output plugin."""
 
-    def __init__(self, plugin_id, io_type, function):
-        """Initializes the analog input/output.
+    def __init__(self, plugin_id, function, data_type):
+        """Initializes the input/output.
         
         Arguments:
             plugin_id: Extension plugin ID in the format 'plugin_name:section', e.g. 'cayenne-pca9685:PCA9685'
-            io_type: The type of IO, 'analog' or 'digital'
-            function: The pin function, 'in' if the pin is an input, 'out' if it is an output
+            function: The IO function, 'in' or 'out'
+            data_type: The Cayenne data type, e.g. 'digital_sensor'
         """
         self.plugin_id = plugin_id
         self.plugin = None
-        self.io_type = io_type.lower()
+        self.data_type = data_type.lower()
         self.function = function.lower()
         self.current_functions = {}        
         self.read_args = {}
@@ -54,40 +52,42 @@ def set_function(self, channel):
         except:
             debug('Error setting function')
 
-    def to_tuple(self, value):
-        """Converts value to tuple with the appropriate data type."""
-        try:
-            return (value, InputOutput.DATA_TYPES[self.io_type][self.function])
-        except:
-            return value
+    def value_to_tuple(self, value):
+        """Converts value to tuple with the appropriate Cayenne data type."""
+        return (value, self.data_type)
 
-    def read(self, channel, data_type=None):
+    def read(self, channel, value_type=None):
         """Gets the data value for the channel as a tuple with the type."""
-        return self.to_tuple(self.read_value(channel, data_type))                
+        return self.value_to_tuple(self.read_value(channel, value_type))                
 
-    def read_value(self, channel, data_type=None):
+    def read_value(self, channel, value_type=None):
         """Read the data value on the specified channel."""
         self.set_plugin()
         self.set_function(channel)
         result = None
         try:
-            result = getattr(self.plugin['instance'], self.plugin['read'])(channel, data_type=data_type, **self.read_args)
+            read_args = self.read_args
+            if value_type:
+                read_args['value_type'] = value_type
+            result = getattr(self.plugin['instance'], self.plugin['read'])(channel, **read_args)
         except:
-            info('Error reading value from plugin {}, channel {}, {}'.format(self.plugin_id, channel, self.plugin))
+            exception('Error reading value from plugin {}, channel {}, {}'.format(self.plugin_id, channel, self.plugin))
         return result
 
-    def write(self, value, channel, data_type=None):
+    def write(self, value, channel, value_type=None):
         """Write the digital value for the channel."""
-        info('IO write, value {}, channel {}'.format(value, channel))
-        return self.write_value(value, channel, data_type)
+        return self.write_value(value, channel, value_type)
 
-    def write_value(self, value, channel, data_type=None):
+    def write_value(self, value, channel, value_type=None):
         """Write the data value on the specified channel."""
         self.set_plugin()
         self.set_function(channel)
         result = None
         try:
-            result = getattr(self.plugin['instance'], self.plugin['write'])(channel, value, data_type=data_type, **self.write_args)
+            write_args = self.write_args
+            if value_type:
+                write_args['value_type'] = value_type            
+            result = getattr(self.plugin['instance'], self.plugin['write'])(channel, value, **write_args)
         except ValueError as e:
             debug(e)
         return result
@@ -104,4 +104,4 @@ def unregister_callback(self):
     def data_changed(self, channel, value):
         """Callback that is called when data has changed."""
         if self.callback:
-            self.callback(self.to_tuple(value))
+            self.callback(self.value_to_tuple(value))