Merge pull request #21 from myDevicesIoT/development

Development

Author: jburhenn

myDevices/__init__.py

@@ -1,4 +1,5 @@
 """
 This package contains the Cayenne agent, which is a full featured client for the Cayenne IoT project builder: https://cayenne.mydevices.com. It sends system information as well as sensor and actuator data and responds to actuator messages initiated from the Cayenne dashboard and mobile apps.
 """
-__version__ = '2.0.2'
+__version__ = '2.0.3'
+

myDevices/cloud/apiclient.py

@@ -98,3 +98,7 @@ def loginDevice(self, inviteCode):
         if response and response.status_code == 200:
             return self.getCredentials(response.content)
         return None
+
+    def getDataTypes(self):
+        url = '/ui/datatypes'
+        return self.sendRequest('GET', url)

myDevices/datatypes.py

@@ -0,0 +1,41 @@
+"""This module provides a script for getting the available data types and units that can be used with Cayenne."""
+
+import sys
+import inspect
+from myDevices.cloud.apiclient import CayenneApiClient
+
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    if '--help' in args or '-h' in args:
+        print('Usage: python3 -m myDevices.datatypes [-h] [PATTERN ...]\n\n'
+            'Search for PATTERN in any of the available Cayenne data types and units.\n'
+            'If no PATTERN is specified all available data types and units are displayed.\n'
+            'The case of PATTERN is ignored.\n\n'
+            'Example: python3 -m myDevices.datatypes temp humidity\n\n'
+            'Options:\n'
+            '    -h, --help       Display this help message and exit')
+        sys.exit()
+    api_client = CayenneApiClient('https://api.mydevices.com')
+    data_types = api_client.getDataTypes().json()
+    if 'error' in data_types:
+        print('Error {}. Could not retrieve data types. Please try again later.'.format(data_types['statusCode']))
+        sys.exit()
+    output = []
+    for data_type in data_types:
+        # Ignore LT100GPS type since that is a custom type that is not intended for general use.
+        if data_type['data_type'] != 'LT100GPS':
+            units = ''
+            for unit in data_type['units']:
+                payload_unit = unit['payload_unit'] if unit['payload_unit'] else 'null'
+                units += ('\'{}\' ({}), '.format(payload_unit, unit['unit_label']))
+            units = units[:-2]
+            entry = '{}\n   Type: \'{}\'\n   Units: {}\n'.format(data_type['data_type'], data_type['payload_type'], units)
+            if not args:
+                output.append(entry)
+            else:
+                for arg in args:
+                    if entry.lower().find(arg.lower()) != -1:
+                        output.append(entry)
+    output.sort(key=lambda x: x.lower())
+    for item in output:
+        print(item)

myDevices/devices/analog/__init__.py

@@ -15,6 +15,8 @@
 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():
     def __init__(self, channelCount, resolution, vref):
@@ -34,79 +36,72 @@ 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, 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):
-         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,35 +113,35 @@ 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)
         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)
 
     def writeVolt(self, channel, value):
         return self.analogWriteVolt(channel, value)
 
+
 class PWM():
     def __init__(self, channelCount, resolution, frequency):
         self._pwmCount = channelCount
@@ -179,54 +174,51 @@ 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))
         return self.pwmReadFloat(channel)
 
-    def read(self, channel):
-        return self.pwmRead(channel)
+    def read(self, channel, value_type=None):
+        read_functions = {'float': self.pwmReadFloat, 'angle': self.pwmReadAngle}
+        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):
-        return self.pwmWrite(channel, value)
+    def write(self, channel, value, value_type=None):
+        write_functions = {'float': self.pwmWriteFloat, 'angle': self.pwmWriteAngle}
+        write_function = write_functions.get(value_type, self.pwmWrite)
+        return write_function(channel, value)
 
     def writeFloat(self, channel, value):
         return self.pwmWriteFloat(channel, value)
@@ -256,7 +248,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 +258,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 +268,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 = {}
@@ -300,9 +289,7 @@ def writeAngle(self, channel, value):
 DRIVERS = {}
 DRIVERS["helper"]  = ["AnalogSensor", "AnalogActuator", "ServoMotor", "Thermistor", "Photoresistor", "LoadSensor", "DistanceSensor", "LightDimmer"]
 DRIVERS["ads1x1x"] = ["ADS1014", "ADS1015", "ADS1114", "ADS1115"]
-DRIVERS["mcp3x0x"] = ["MCP3002", "MCP3004", "MCP3008", "MCP3204", "MCP3208"]
 DRIVERS["mcp4725"] = ["MCP4725"]
 DRIVERS["mcp48XX"] = ["MCP4802", "MCP4812", "MCP4822"]
 DRIVERS["mcp492X"] = ["MCP4921", "MCP4922"]
-DRIVERS["pca9685"] = ["PCA9685"]
 DRIVERS["pcf8591"] = ["PCF8591"]

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_plugin_by_id(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)