Add analog and PWM reading and writing.

Author: jburhenn

myDevices/devices/analog/__init__.py

@@ -15,6 +15,7 @@
 from myDevices.decorators.rest import request, response
 from myDevices.utils.types import toint, M_JSON
 from myDevices.devices import instance
+from myDevices.utils.logger import info
 
 
 class ADC():
@@ -91,8 +92,8 @@ def analogReadAllVolt(self):
         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_functions = {'float': self.analogReadFloat, 'f': self.analogReadFloat,
+            'volt': self.analogReadVolt, 'v': self.analogReadVolt}
         read_function = read_functions.get(data_type, self.analogRead)
         return read_function(channel, diff)
 
@@ -205,14 +206,18 @@ def pwmWriteFloat(self, channel, value):
         self.pwmWrite(channel, int(value * self._pwmMax))
         return self.pwmReadFloat(channel)
 
-    def read(self, channel):
-        return self.pwmRead(channel)
+    def read(self, channel, data_type=None):
+        read_functions = {'float': self.pwmReadFloat, 'angle': self.pwmReadAngle}
+        read_function = read_functions.get(data_type, self.pwmRead)
+        return read_function(channel)        
 
     def readFloat(self, channel):
         return self.pwmReadFloat(channel)
 
-    def write(self, channel, value):
-        return self.pwmWrite(channel, value)
+    def write(self, channel, value, data_type=None):
+        write_functions = {'float': self.pwmWriteFloat, 'angle': self.pwmWriteAngle}
+        write_function = write_functions.get(data_type, self.pwmWrite)        
+        return write_function(channel, value)
 
     def writeFloat(self, channel, value):
         return self.pwmWriteFloat(channel, value)

myDevices/plugins/analog.py

@@ -1,40 +1,20 @@
 """
-This module provides classes for interfacing with analog plugins.
+This module provides classes for interfacing with analog and PWM plugins.
 """
-from myDevices.plugins.manager import PluginManager
+from myDevices.plugins.io import InputOutput
 from myDevices.utils.logger import info, debug
 
 
-class AnalogInput():
-    """Reads data from an analog input."""
+class AnalogInput(InputOutput):
+    """Reads data from an analog or PWM plugin input."""
 
-    def __init__(self, adc):
-        """Initializes the analog input.
+    def __init__(self, plugin_id):
+        """Initializes the plugin input.
         
         Arguments:
-            adc: Analog-to-digital converter plugin ID in the format 'plugin_name:section', e.g. 'cayenne-mcp3xxx:MCP'
-        """
-        self.adc_name = adc
-        self.adc = None
-        self.read_args = {}
-        self.plugin_manager = PluginManager()
-        self.set_adc()
-    
-    def set_adc(self):
-        """Sets the ADC plugin."""
-        if not self.adc:
-            self.adc = self.plugin_manager.get_plugin_by_id(self.adc_name)
-            self.read_args = self.plugin_manager.get_args(self.adc, 'read_args')
-
-    def read_value(self, channel, data_type=None):
-        """Read the data value on the specified channel."""
-        self.set_adc()
-        try:
-            value = getattr(self.adc['instance'], self.adc['read'])(channel, data_type=data_type, **self.read_args)
-        except ValueError as e:
-            debug(e)
-            value = None
-        return value
+            plugin_id: Plugin ID in the format 'plugin_name:section', e.g. 'cayenne-pca9685:PCA9685'
+        """        
+        InputOutput.__init__(self, plugin_id, 'analog', 'in')
 
     def read_float(self, channel):
         """Read the float value on the specified channel."""
@@ -43,3 +23,45 @@ def read_float(self, channel):
     def read_volt(self, channel):
         """Read the voltage on the specified channel."""
         return self.read_value(channel, 'volt')
+    
+    def read_angle(self, channel):
+        """Read the angle on the specified channel."""
+        return self.read_value(channel, 'angle')
+
+
+class AnalogIO(AnalogInput):
+    """Reads/writes data from an analog or PWM plugin input/output."""
+
+    def __init__(self, plugin_id, function):
+        """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)
+       
+    def write_float(self, value, channel):
+        """Write the float value on the specified channel."""
+        return self.write_value(value, channel, 'float')
+
+    def write_volt(self, value, channel):
+        """Write the voltage on the specified channel."""
+        return self.write_value(value, channel, 'volt')
+
+    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')
+  

myDevices/plugins/io.py

@@ -0,0 +1,107 @@
+"""
+This module provides a class for interfacing with digital, analog and PWM plugins.
+"""
+from myDevices.plugins.manager import PluginManager
+from myDevices.utils.logger import debug, info, exception
+
+
+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'}}
+
+    def __init__(self, plugin_id, io_type, function):
+        """Initializes the analog 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
+        """
+        self.plugin_id = plugin_id
+        self.plugin = None
+        self.io_type = io_type.lower()
+        self.function = function.lower()
+        self.current_functions = {}        
+        self.read_args = {}
+        self.write_args = {}        
+        self.plugin_manager = PluginManager()
+        self.set_plugin()
+    
+    def set_plugin(self):
+        """Sets the plugin_id plugin."""
+        if not self.plugin:
+            self.plugin = self.plugin_manager.get_plugin_by_id(self.plugin_id)
+            try:
+                self.read_args = self.plugin_manager.get_args(self.plugin, 'read_args')
+                self.write_args = self.plugin_manager.get_args(self.plugin, 'write_args')
+            except:
+                pass
+
+    def set_function(self, channel):
+        """Sets the input/output function."""
+        try:
+            if self.plugin and (channel not in self.current_functions or self.function != self.current_functions[channel]):
+                function = getattr(self.plugin['instance'], self.plugin['set_function'])(channel, self.function).lower()
+                self.current_functions[channel] = function
+                if function == 'in':
+                    try:
+                        debug('Register callback for channel {}'.format(channel))
+                        getattr(self.plugin['instance'], self.plugin['register_callback'])(channel, self.data_changed, data=channel)
+                    except:
+                        debug('Unable to register callback for channel {}'.format(channel))
+                        pass
+        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 read(self, channel, data_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))                
+
+    def read_value(self, channel, data_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)
+        except:
+            info('Error reading value from plugin {}, channel {}, {}'.format(self.plugin_id, channel, self.plugin))
+        return result
+
+    def write(self, value, channel, data_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)
+
+    def write_value(self, value, channel, data_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)
+        except ValueError as e:
+            debug(e)
+        return result
+
+    def register_callback(self, callback):
+        """Register a callback for data changes."""
+        info('Registering callback: {}'.format(callback))
+        self.callback = callback
+
+    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))

myDevices/plugins/manager.py

@@ -203,7 +203,11 @@ def write_value(self, plugin, channel, value):
                 write_function = getattr(self.plugins[actuator]['instance'], self.plugins[actuator]['write'])
                 write_args = self.get_args(self.plugins[actuator], 'write_args')
                 write_function(float(value), **write_args)
-            except:
+            except KeyError as e:
+                error('Error writing value, missing key: {}'.format(e))
+                return False    
+            except Exception as e:
+                error('Error writing value: {}'.format(e))
                 return False
         else:
             return False