WatlowF4 updates at 'beta' status

Author: Myles Metzler

.vscode/settings.json

@@ -4,5 +4,6 @@
     "python.autoComplete.extraPaths": [
         "${env.SPARK_HOME}\\python",
         "${env.SPARK_HOME}\\python\\pyspark"
-    ]
+    ],
+    "python.linting.pylintPath": "c:/Python27/Scripts/pylint.exe"
 }

bin/example.py

@@ -0,0 +1,37 @@
+'''
+examples of using the chamberconnectlibrary
+'''
+from chamberconnectlibrary.watlowf4 import WatlowF4
+
+LOOP_NAMES = ['Temperature', 'Humidity']
+
+CONTROLLER = WatlowF4(
+    interface='RTU',
+    serialport='//./COM7',
+    baudrate=19200,
+    loop_names=LOOP_NAMES
+)
+print CONTROLLER.process_controller()
+
+print '\ncascade loops:'
+for i in range(CONTROLLER.cascades):
+    print CONTROLLER.get_loop(i+1, 'cascade', ['processvalue', 'setpoint'])
+
+print '\nloops:'
+for i in range(CONTROLLER.loops):
+    print CONTROLLER.get_loop(i+1, 'loop', 'processvalue', 'setpoint')
+
+print '\nnamed loops:'
+for name in LOOP_NAMES:
+    print CONTROLLER.get_loop(name, ['processvalue', 'setpoint'])
+
+for name in LOOP_NAMES:
+    print CONTROLLER.set_loop(name, setpoint=60.0)
+
+print '\noperations:'
+print CONTROLLER.get_operation()
+CONTROLLER.set_operation('standby')
+
+print '\nEvents:'
+for i in range(8):
+    print CONTROLLER.get_event(i+1)

chamberconnectlibrary/controllerinterface.py

@@ -44,6 +44,7 @@ class ControllerInterface:
     __metaclass__ = ABCMeta
 
     loop_map = []
+    named_loop_map = {}
 
     def init_common(self, **kwargs):
         '''Setup properties of all controllers of the chamberconnectlibrary'''
@@ -99,16 +100,35 @@ def set_refrig(self, value):
         pass
 
     @exclusive
-    def get_loop(self, N, loop_type, param_list=None):
+    def get_loop(self, identifier, *args):
         '''
         Get all parameters for a loop from a given list.
-
-        Args:
-            N (int): The loop number (1-4).
-            loop_type (str): The loop type::
-                "cascade" -- A cascade control loop.
-                "loop" -- A standard control loop.
-            param_list (list(str)): The list of parameters to read defaults::
+        There are four different ways to call this method; all methods return the same data:
+
+        get_loop(str(identifier), *str(parameters))
+            Args:
+                identifier (str): The name of the loop.
+                parameters (list(string)): The list of parameters to get from the loop, (see below)
+
+        get_loop(str(identifier), [str(parameters)])
+            Args:
+                identifier (str): The name of the loop.
+                parameters (list(string)): The list of parameters to get from the loop, (see below)
+
+        get_loop(int(identifier), str(loop_type), *str(parameters))
+            Args:
+                identifier (str): The name of the loop.
+                loop_type (str): The type of loop to be accessed ("loop" or "cascade")
+                parameters (list(string)): The list of parameters to get from the loop, (see below)
+
+        get_loop(int(identifier), str(loop_type), [str(parameters)])
+            Args:
+                identifier (str): The name of the loop.
+                loop_type (str): The type of loop to be accessed ("loop" or "cascade")
+                parameters (list(string)): The list of parameters to get from the loop, (see below)
+
+        parameters:
+            The following is a list of available parameters as referenced by each call type:
                 "setpoint" -- The target temp/humi/altitude/etc of the control loop
                 "processvalue" -- The current conditions inside the chamber
                 "range" -- The settable range for the "setpoint"
@@ -158,41 +178,62 @@ def get_loop(self, N, loop_type, param_list=None):
                 'power':self.get_loop_power
             }
         }
+
+        if isinstance(identifier, basestring):
+            my_loop_map = self.loop_map[self.named_loop_map[identifier]]
+            loop_number = my_loop_map['num']
+            loop_type = my_loop_map['type']
+            param_list = args if len(args) > 0 else None
+        elif isinstance(identifier, int) and len(args) >= 1:
+            loop_number = identifier
+            loop_type = args[0]
+            param_list = args[1:] if len(args) > 1 else None
+        else:
+            raise ValueError(
+                'invalid argument format, call w/: '
+                'get_loop(int(identifier), str(loop_type), *args) or '
+                'get_loop(str(identifier), *args), *args are optional.'
+            )
+
         if param_list is None:
             param_list = loop_functions[loop_type].keys()
             excludes = ['setPoint', 'setValue', 'processValue']
             param_list = [x for x in param_list if x not in excludes]
+        elif len(param_list) >= 1 and \
+             (isinstance(param_list[0], list) or isinstance(param_list[0], tuple)):
+            param_list = param_list[0]
         ret = {}
         for key in param_list:
             try:
-                ret[key] = loop_functions[loop_type][key](N, exclusive=False)
+                ret[key] = loop_functions[loop_type][key](loop_number, exclusive=False)
             except KeyError:
                 ret[key] = None
             except NotImplementedError:
                 ret[key] = None
         return ret
 
     @exclusive
-    def set_loop(self, N, loop_type, param_list):
+    def set_loop(self, identifier, loop_type='loop', param_list=None, **kwargs):
         '''
         Set all parameters for a loop from a given list.
 
         Args:
-            N (int): The loop number (1-4).
-            loop_type (str): The loop type::
+            identifier (int or str): The loop number, or the name of the loop
+            loop_type (str): The loop type (disregarded when identifier is a str)::
                 "cascade" -- A cascade control loop.
-                "loop" -- A standard control loop.
-            param_list (dict(dict)): The possible keys and there values::
+                "loop" -- A standard control loop (default).
+            param_list (dict(dict)): The parameters to update as a dictionary::
+                see kwargs for possible keys/values
+            kwargs (dict): The parameters to update as key word arguments, param_list overrides::
                 "setpoint" -- The target temp/humi/altitude/etc of the control loop
                 "range" -- The settable range for the "setpoint"
                 "enable" -- turn the control loop on or off
                 "power" -- set the manual power of the control loop
+                "mode" -- set the control mode of the control loop
                 "deviation" -- (type="cascade" only) The allowable difference between air/prod.
                 "enable_cascade" -- (type="cascade" only) Enable or disable cascade type control
         Returns:
             None
-        Raises:
-            ModbusError
         '''
         loop_functions = {
             'cascade':{
@@ -216,14 +257,39 @@ def set_loop(self, N, loop_type, param_list):
                 'power':self.set_loop_power
             }
         }
+        if param_list is None:
+            param_list = kwargs
+        if isinstance(identifier, basestring):
+            my_loop_map = self.loop_map[self.named_loop_map[identifier]]
+            loop_number = my_loop_map['num']
+            loop_type = my_loop_map['type']
+        elif isinstance(identifier, int):
+            loop_number = identifier
+        else:
+            raise ValueError(
+                'invalid argument format, call w/: '
+                'set_loop(int(identifier), str(loop_type), **kwargs) or '
+                'get_loop(str(identifier), **kwargs)'
+            )
+
         #mode must be done first
         if 'mode' in param_list:
-            loop_functions[loop_type]['mode'](exclusive=False, N=N, value=param_list.pop('mode'))
+            loop_functions[loop_type]['mode'](
+                exclusive=False,
+                N=loop_number,
+                value=param_list.pop('mode')
+            )
         for key, val in param_list.items():
             try:
-                loop_functions[loop_type][key](exclusive=False, N=N, value=val)
+                loop_functions[loop_type][key](
+                    exclusive=False,
+                    N=loop_number,
+                    value=val
+                )
             except KeyError:
                 pass
+            except NotImplementedError:
+                pass
 
     @exclusive
     def get_operation(self, pgm=None):
@@ -341,7 +407,7 @@ def set_program(self, N, value):
 
         Args:
             N (int): The program number
-            value (dict): The program to write to the controller
+            value (dict): The program to write to the controller, None erases the given program
         '''
         if value is None:
             return self.prgm_delete(N, exclusive=False)
@@ -996,6 +1062,15 @@ def set_network_settings(self, value):
         '''
         pass
 
+    def get_operation_modes(self):
+        '''
+        Get the supported operation modes for this controller.
+
+        Returns:
+            ["standby","constant","program"] or ["constant","program"]
+        '''
+        return ['standby', 'constant', 'program']
+
     def self_test(self, loops, cascades):
         '''
         preform a self test on all functions

chamberconnectlibrary/espec.py

@@ -64,8 +64,11 @@ def __update_loop_map(self):
         '''
         update the loop map.
         '''
+        self.named_loop_map = {'Temperature':0, 'temperature':0, 'Temp':0, 'temp':0}
         self.loop_map = [{'type':'cascade', 'num':j+1} for j in range(self.cascades)]
         self.loop_map += [{'type':'loop', 'num':j+1} for j in range(self.loops)]
+        if len(self.loop_map) > 1:
+            self.named_loop_map = {'Humidity':1, 'humidity':1, 'Hum':1, 'hum':1}
 
     def connect(self):
         '''
@@ -124,7 +127,7 @@ def set_refrig(self, value):
         self.client.write_set(**value)
 
     @exclusive
-    def set_loop(self, N, loop_type, param_list):
+    def set_loop(self, N, loop_type, param_list=None, **kwargs):
         #cannot use the default controllerInterface version.
         lpfuncs = {
             'cascade':{
@@ -144,6 +147,8 @@ def set_loop(self, N, loop_type, param_list):
                 'mode':self.set_loop_mode
             }
         }
+        if param_list is None:
+            param_list = kwargs
         spt1 = 'setpoint' in param_list
         spt2 = 'setPoint' in param_list
         spt3 = 'setValue' in param_list
@@ -299,12 +304,12 @@ def set_loop_mode(self, N, value):
     def get_loop_mode(self, N):
         if N > 2:
             raise ValueError(self.lp_exmsg)
-        if self.lpd[N] == self.temp:
-            cur = 'On'
-            con = 'On'
-        elif self.lpd[N] == self.humi:
+        if self.lpd[N] == self.humi:
             cur = 'On' if self.cached(self.client.read_humi)['enable'] else 'Off'
             con = 'On' if self.cached(self.client.read_constant_humi)['enable'] else 'Off'
+        else:
+            cur = 'On'
+            con = 'On'
         if self.client.read_mode() in ['OFF', 'STANDBY']:
             cur = 'Off'
         return {"current": cur, "constant": con}
@@ -317,11 +322,12 @@ def get_loop_modes(self, N):
         else:
             raise ValueError(self.lp_exmsg)
 
+    @exclusive
     def get_loop_power(self, N):
         if self.lpd[N] == self.temp:
-            val = self.cached(self.client.read_htr['dry'])
+            val = self.cached(self.client.read_htr)['dry']
         elif self.lpd[N] == self.humi:
-            val = self.cached(self.client.read_htr['wet'])
+            val = self.cached(self.client.read_htr)['wet']
         else:
             raise ValueError(self.lp_exmsg)
         return {'current':val, 'constant':val}
@@ -434,11 +440,13 @@ def set_cascade_deviation(self, N, value):
             raise ValueError('value must contain "positive" and "negative" keys')
         self.client.write_temp_ptc(self.get_cascade_ctl(self.temp, exclusive=False), **value)
 
+    @exclusive
     def get_cascade_power(self, N):
         if self.lpd[N] != self.temp:
             raise ValueError(self.cs_exmsg)
         return self.get_loop_power(self.temp, exclusive=False)
 
+    @exclusive
     def set_cascade_power(self, N, value):
         raise NotImplementedError