Add extension plugin support.

Author: jburhenn

myDevices/devices/analog/__init__.py

@@ -16,6 +16,7 @@
 from myDevices.utils.types import toint, M_JSON
 from myDevices.devices import instance
 
+
 class ADC():
     def __init__(self, channelCount, resolution, vref):
         self._analogCount = channelCount
@@ -34,79 +35,73 @@ def checkAnalogValue(self, value):
         if not 0 <= value <= self._analogMax:
             raise ValueError("Value %d out of range [%d..%d]" % (value, 0, self._analogMax))
 
-    #@request("GET", "analog/count")
     @response("%d")
     def analogCount(self):
         return self._analogCount
 
-    #@request("GET", "analog/resolution")
     @response("%d")
     def analogResolution(self):
         return self._analogResolution
 
-    #@request("GET", "analog/max")
     @response("%d")
     def analogMaximum(self):
         return int(self._analogMax)
 
-    #@request("GET", "analog/vref")
     @response("%.2f")
     def analogReference(self):
         return self._analogRef
 
     def __analogRead__(self, channel, diff):
         raise NotImplementedError
 
-    #@request("GET", "analog/%(channel)d/integer")
     @response("%d")
     def analogRead(self, channel, diff=False):
         self.checkAnalogChannel(channel)
         return self.__analogRead__(channel, diff)
 
-    #@request("GET", "analog/%(channel)d/float")
     @response("%.2f")
     def analogReadFloat(self, channel, diff=False):
         return self.analogRead(channel, diff) / float(self._analogMax)
 
-    #@request("GET", "analog/%(channel)d/volt")
     @response("%.2f")
     def analogReadVolt(self, channel, diff=False):
         if self._analogRef == 0:
             raise NotImplementedError
         return self.analogReadFloat(channel, diff) * self._analogRef
 
-    #@request("GET", "analog/*/integer")
     @response(contentType=M_JSON)
     def analogReadAll(self):
         values = {}
         for i in range(self._analogCount):
             values[i] = self.analogRead(i)
         return values
 
-    #@request("GET", "analog/*/float")
     @response(contentType=M_JSON)
     def analogReadAllFloat(self):
         values = {}
         for i in range(self._analogCount):
             values[i] = float("%.2f" % self.analogReadFloat(i))
         return values
 
-    #@request("GET", "analog/*/volt")
     @response(contentType=M_JSON)
     def analogReadAllVolt(self):
         values = {}
         for i in range(self._analogCount):
             values[i] = float("%.2f" % self.analogReadVolt(i))
         return values
 
-    def read(self, channel, diff=False):
-        return self.analogRead(channel, diff)
+    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)
+        return read_function(channel, diff)
 
     def readFloat(self, channel, diff=False):
-         return self.analogReadFloat(channel, diff)
+        return self.analogReadFloat(channel, diff)
 
     def readVolt(self, channel, diff=False):
-         return self.analogReadVolt(channel, diff)
+        return self.analogReadVolt(channel, diff)
+
 
 class DAC(ADC):
     def __init__(self, channelCount, resolution, vref):
@@ -118,21 +113,18 @@ def __family__(self):
     def __analogWrite__(self, channel, value):
         raise NotImplementedError
 
-    #@request("POST", "analog/%(channel)d/integer/%(value)d")
     @response("%d")    
     def analogWrite(self, channel, value):
         self.checkAnalogChannel(channel)
         self.checkAnalogValue(value)
         self.__analogWrite__(channel, value)
         return self.analogRead(channel)
 
-    #@request("POST", "analog/%(channel)d/float/%(value)f")        
     @response("%.2f")    
     def analogWriteFloat(self, channel, value):
         self.analogWrite(channel, int(value * self._analogMax))
         return self.analogReadFloat(channel)
 
-    #@request("POST", "analog/%(channel)d/volt/%(value)f")        
     @response("%.2f")    
     def analogWriteVolt(self, channel, value):
         self.analogWriteFloat(channel, value /self._analogRef)
@@ -147,6 +139,7 @@ def writeFloat(self, channel, value):
     def writeVolt(self, channel, value):
         return self.analogWriteVolt(channel, value)
 
+
 class PWM():
     def __init__(self, channelCount, resolution, frequency):
         self._pwmCount = channelCount
@@ -179,41 +172,34 @@ def __pwmRead__(self, channel):
     def __pwmWrite__(self, channel, value):
         raise NotImplementedError
 
-    #@request("GET", "pwm/count")
     @response("%d")
     def pwmCount(self):
         return self._pwmCount
 
-    #@request("GET", "pwm/resolution")
     @response("%d")
     def pwmResolution(self):
         return self._pwmResolution
 
-    #@request("GET", "pwm/max")
     @response("%d")
     def pwmMaximum(self):
         return int(self._pwmMax)
 
-    #@request("GET", "pwm/%(channel)d/integer")
     @response("%d")
     def pwmRead(self, channel):
         self.checkPWMChannel(channel)
         return self.__pwmRead__(channel)
 
-    #@request("GET", "pwm/%(channel)d/float")
     @response("%.2f")
     def pwmReadFloat(self, channel):
         return self.pwmRead(channel) / float(self._pwmMax)
 
-    #@request("POST", "pwm/%(channel)d/integer/%(value)d")
     @response("%d")    
     def pwmWrite(self, channel, value):
         self.checkPWMChannel(channel)
         self.checkPWMValue(value)
         self.__pwmWrite__(channel, value)
         return self.pwmRead(channel)
 
-    #@request("POST", "pwm/%(channel)d/float/%(value)f")        
     @response("%.2f")    
     def pwmWriteFloat(self, channel, value):
         self.pwmWrite(channel, int(value * self._pwmMax))
@@ -256,7 +242,6 @@ def AngleToRatio(self, value):
         f /= self.period
         return f
 
-    #@request("GET", "pwm/%(channel)d/angle")
     @response("%.2f")
     def pwmReadAngle(self, channel):
         f = self.pwmReadFloat(channel)
@@ -267,7 +252,6 @@ def pwmReadAngle(self, channel):
             f = f
         return f
 
-    #@request("POST", "pwm/%(channel)d/angle/%(value)f")
     @response("%.2f")
     def pwmWriteAngle(self, channel, value):
         if self.reverse[channel]:
@@ -278,7 +262,6 @@ def pwmWriteAngle(self, channel, value):
         self.pwmWriteFloat(channel, f)
         return self.pwmReadAngle(channel)
 
-    #@request("GET", "pwm/*")
     @response(contentType=M_JSON)
     def pwmWildcard(self):
         values = {}

myDevices/devices/analog/helper.py

@@ -16,12 +16,14 @@
 from myDevices.utils.types import toint
 from myDevices.devices import instance
 from myDevices.utils.logger import info
+from myDevices.plugins.manager import PluginManager
 
 class AnalogSensor():
     def __init__(self, adc, channel):
         self.adcname = adc
         self.channel = toint(channel)
         self.adc = None
+        self.pluginManager = PluginManager()
         self.setADCInstance()
 
     def __str__(self):
@@ -33,32 +35,44 @@ def __family__(self):
     def setADCInstance(self):
         if not self.adc:
             self.adc = instance.deviceInstance(self.adcname)
+            if not self.adc:
+                self.adc = self.pluginManager.get_extension(self.adcname)
 
-    #@request("GET", "integer")
     @response("%d")
     def read(self):
         self.setADCInstance()
-        return self.adc.analogRead(self.channel)
+        try:
+            value = self.adc.analogRead(self.channel)
+        except:
+            value = getattr(self.adc['instance'], self.adc['read'])(self.channel)
+        return value
 
-    #@request("GET", "float")
     @response("%.2f")
     def readFloat(self):
         self.setADCInstance()
-        return self.adc.analogReadFloat(self.channel)
+        try:
+            value = self.adc.analogReadFloat(self.channel)
+        except:
+            value = getattr(self.adc['instance'], self.adc['read'])(self.channel, 'float')
+        return value
 
-    #@request("GET", "volt")
     @response("%.2f")
     def readVolt(self):
         self.setADCInstance()
-        return self.adc.analogReadVolt(self.channel)
+        try:
+            value = self.adc.analogReadVolt(self.channel)
+        except:
+            value = getattr(self.adc['instance'], self.adc['read'])(self.channel, 'volt')
+        return value
+
 
 class Photoresistor(AnalogSensor):
     def __init__(self, adc, channel):
         AnalogSensor.__init__(self, adc, channel)
 
     def __str__(self):
         return "Photoresistor"
-    
+            
 class Thermistor(AnalogSensor):
     def __init__(self, adc, channel):
         AnalogSensor.__init__(self, adc, channel)

myDevices/plugins/manager.py

@@ -10,20 +10,21 @@
 import myDevices.cloud.cayennemqtt as cayennemqtt
 from myDevices.utils.config import Config
 from myDevices.utils.logger import debug, error, exception, info
+from myDevices.utils.singleton import Singleton
 from myDevices.utils.subprocess import executeCommand
 
 PLUGIN_FOLDER = '/etc/myDevices/plugins'
 
 
-class PluginManager():
+class PluginManager(Singleton):
     """Loads plugins and reads/writes plugin data."""
 
     def __init__(self, callback=None):
         """Initializes the plugin manager and loads the plugin list."""
         self.plugin_folder = PLUGIN_FOLDER
         self.callback = callback
         self.plugins = {}
-        self.load_plugins()
+        self.extensions = {}
 
     def load_plugin_from_file(self, filename):
         """Loads a plugin from a specified plugin config file and adds it to the plugin list."""
@@ -42,15 +43,19 @@ def load_plugin_from_file(self, filename):
                 try:
                     enabled = config.get(section, 'enabled', 'true').lower() == 'true'
                     inherit = config.get(section, 'inherit', None)
+                    extension = config.get(section, 'extension', 'false').lower() == 'true'
                     if enabled or section in inherited_from:
                         plugin = {
                             'enabled': enabled,
                             'filename': filename,
                             'section': section,
-                            'channel': config.get(section, 'channel'),
                             'name': config.get(section, 'name', section),
                         }
-                        plugin['id'] = plugin_name + ':' + plugin['channel']
+                        if not extension:
+                            plugin['channel'] = config.get(section, 'channel')
+                            plugin['id'] = plugin_name + ':' + plugin['channel']
+                        else:
+                            plugin['id'] = plugin_name + ':' + section
                         inherit_items = {}
                         if inherit in config.sections():
                             if inherit == section:
@@ -86,8 +91,11 @@ def load_plugin_from_file(self, filename):
                         try:
                             self.override_plugin_value(config, section, 'unregister_callback', plugin)
                         except:
-                            pass                                                    
-                        self.plugins[plugin['id']] = plugin
+                            pass
+                        if not extension:                                                
+                            self.plugins[plugin['id']] = plugin
+                        else:
+                            self.extensions[plugin['id']] = plugin
                         loaded.append(section)
                 except Exception as e:
                     error(e)
@@ -103,11 +111,21 @@ def load_plugins(self):
             #Remove any disabled plugins that were only loaded because they are inherited from.
             self.plugins = {key:value for key, value in self.plugins.items() if value['enabled']}
         info('Enabled plugins: {}'.format(self.plugins.keys()))
+        info('Enabled extensions: {}'.format(self.extensions.keys()))
 
     def get_plugin(self, filename, section):
         """Return the plugin for the corresponding filename and section."""
         return next(plugin for plugin in self.plugins.values() if plugin['filename'] == filename and plugin['section'] == section)
 
+    def get_extension(self, id):
+        """Return the extension with the corresponding id."""
+        extension = None
+        try:
+            extension = self.extensions[id]
+        except:
+            pass
+        return extension
+
     def override_plugin_value(self, config, section, key, plugin):
         """Override the plugin value for the specified key if it exists in the config file"""
         if key not in plugin:
@@ -209,4 +227,4 @@ def data_changed(self, value, plugin):
             data = self.convert_to_dict(value)
             data['name'] = plugin['name']
             data['id'] = plugin['id']
-            self.callback(data)
+            self.callback(data)

myDevices/sensors/sensors.py

@@ -52,6 +52,7 @@ def __init__(self):
                 self.disabledSensors[row[0]] = 1
         self.realTimeMonitorRunning = False
         self.pluginManager = PluginManager(self.OnPluginChange)
+        self.pluginManager.load_plugins()
         self.InitCallbacks()
         self.StartMonitoring()