registers changed

snippets/test8.py

@@ -0,0 +1,105 @@
+import unittest
+import json
+
+class A(object):
+    def __init__(self, arg1=None, arg2=None):
+        self.arg1 = arg1
+        self.arg2 = arg2
+        self.arg3 = self.arg1 + self.arg2
+
+    def __str__(self):
+        return "A: {0!s} {1!s} {2!s}".format(self.arg1, self.arg2, self.arg3)
+
+    def jsonify(self):
+        return {'type':self.__class__.__name__, 'args': {'arg1':self.arg1, 'arg2':self.arg2}}
+
+class MyEncoder(json.JSONEncoder):
+    def default(self, o):
+        try:
+            return o.jsonify()
+        except TypeError or AttributeError:
+            return super().default(o)
+
+
+def objectFactory(j):
+    klass = eval(j['type'])
+    o = klass(**j['args'])
+    return o
+
+def MyDecoder(j):
+    if type(j) == dict and 'type' in j:
+        return objectFactory(j)
+    else:
+        return j
+
+class Tests(unittest.TestCase):
+    def test_a1(self):
+        a1 = A(1, 2)
+        self.assertEqual(a1.arg1, 1)
+        self.assertEqual(a1.arg2, 2)
+        self.assertEqual(a1.arg3, 3)
+
+    def test_a2(self):
+        a2 = A(**{'arg1':2, 'arg2':4})
+        self.assertEqual(a2.arg1, 2)
+        self.assertEqual(a2.arg2, 4)
+        self.assertEqual(a2.arg3, 6)
+
+    def test_a3(self):
+        j = '{ "type": "A", "args": { "arg1": 3, "arg2": 5 } }'
+        jj = json.loads(j)
+        klass = eval(jj['type'])
+        self.assertEqual(A, klass)
+        a3 = klass(**jj['args'])
+        self.assertEqual(a3.arg1, 3)
+        self.assertEqual(a3.arg2, 5)
+        self.assertEqual(a3.arg3, 8)
+
+    def test_a4(self):
+        j = '{ "type": "A", "args": { "arg1": 3, "arg2": 5 } }'
+        jj = json.loads(j)
+        klass = eval(jj['type'])
+        self.assertEqual(A, klass)
+        a3 = klass(**jj['args'])
+        self.assertEqual(a3.arg1, 3)
+        self.assertEqual(a3.arg2, 5)
+        self.assertEqual(a3.arg3, 8)
+
+        jjjj = json.dumps(a3, cls=MyEncoder)
+
+        jjj = json.loads(jjjj)
+        klass = eval(jjj['type'])
+        self.assertEqual(A, klass)
+        a3 = klass(**jjj['args'])
+        self.assertEqual(a3.arg1, 3)
+        self.assertEqual(a3.arg2, 5)
+        self.assertEqual(a3.arg3, 8)
+
+    def test_a5(self):
+        jList = []
+        jList.append(objectFactory({'type':'A', 'args': {'arg1':1, 'arg2':2}}))
+        jList.append(objectFactory({'type':'A', 'args': {'arg1':2, 'arg2':3}}))
+        jList.append(objectFactory({'type':'A', 'args': {'arg1':3, 'arg2':4}}))
+
+        js = json.dumps(jList, cls=MyEncoder, sort_keys=True, indent=4)
+
+        print(js)
+
+        jResultList = json.loads(js, object_hook=MyDecoder)
+
+        self.assertEqual(jResultList[0].arg1, 1)
+        self.assertEqual(jResultList[0].arg2, 2)
+        self.assertEqual(jResultList[0].arg3, 3)
+
+        self.assertEqual(jResultList[1].arg1, 2)
+        self.assertEqual(jResultList[1].arg2, 3)
+        self.assertEqual(jResultList[1].arg3, 5)
+
+        self.assertEqual(jResultList[2].arg1, 3)
+        self.assertEqual(jResultList[2].arg2, 4)
+        self.assertEqual(jResultList[2].arg3, 7)
+
+
+
+if __name__ == '__main__':
+    unittest.main()

snippets/test9.py

@@ -0,0 +1,14 @@
+class A(object):
+    def __init__(self):
+        self.a = 1
+    def x(self):
+        return self.a
+
+class B(A):
+    def __init__(self):
+        self.a = 2
+    def x(self):
+        return self.a
+    def y(self):
+        return super().x()
+

src/CmdServer.py

@@ -4,9 +4,8 @@ import cmd
 import re
 import io
 import datetime
-import pickle
-import sys
 import RegisterDatapoint
+import logging
 
 class CmdInterpreterException(ValueError): pass
 
@@ -30,6 +29,7 @@ class CmdInterpreter(cmd.Cmd):
         self.prompt = "test8> "
         self.intro = "test8 admin interface"
         self.splitterRe = re.compile('\s+')
+        self.logger = logging.getLogger('CmdInterpreter')
 
     def __print(self, text):
         self.stdout.write(text)
@@ -51,7 +51,7 @@ class CmdInterpreter(cmd.Cmd):
     
     def do_add_hr(self, arg):
         try:
-            (label, unit, address, count, scanrate, readTopic, writeTopic, feedbackTopic) = self.splitterRe.split(arg)
+            (label, unit, address, count, scanrate, readTopic, writeTopic, feedbackTopic, converter) = self.splitterRe.split(arg)
             self.__println("Label:         {0}".format(label))
             self.__println("Unit:          {0}".format(unit))
             self.__println("Address:       {0}".format(address))
@@ -60,6 +60,7 @@ class CmdInterpreter(cmd.Cmd):
             self.__println("ReadTopic:     {0}".format(readTopic))
             self.__println("WriteTopic:    {0}".format(writeTopic))
             self.__println("FeedbackTopic: {0}".format(feedbackTopic))
+            self.__println("Converter:     {0}".format(converter))
 
             if readTopic == 'None':
                 readTopic = None
@@ -67,33 +68,22 @@ class CmdInterpreter(cmd.Cmd):
                 writeTopic = None
             if feedbackTopic == 'None':
                 feedbackTopic = None
+            if converter == 'None':
+                converter = None
             unit = parseIntArbitraryBase(unit)
             address = parseIntArbitraryBase(address)
             count = parseIntArbitraryBase(count)
             scanrate = float(scanrate)
-            if scanrate == 0:
+            r = RegisterDatapoint.HoldingRegisterDatapoint(label, unit, address, count, datetime.timedelta(seconds=scanrate), readTopic, writeTopic, feedbackTopic, converter)
-                if readTopic:
-                    raise CmdInterpreterException('readTopic must not be set when scanRate is zero')
-                if not writeTopic:
-                    raise CmdInterpreterException('writeTopic must be set when scanRate is zero')
-                if not feedbackTopic:
-                    raise CmdInterpreterException('feedbackTopic must be set when scanRate is zero')
-            else:
-                if not readTopic:
-                    raise CmdInterpreterException('readTopic must be set when scanRate is zero')
-                if writeTopic:
-                    raise CmdInterpreterException('writeTopic must not be set when scanRate is zero')
-                if feedbackTopic:
-                    raise CmdInterpreterException('feedbackTopic must not be set when scanRate is zero')
-            r = RegisterDatapoint.HoldingRegisterDatapoint(label, unit, address, count, datetime.timedelta(seconds=scanrate), readTopic, writeTopic, feedbackTopic)
             self.registers.append(r)
         except ValueError as e:
             self.__println("ERROR: {0!s}, {1!s}".format(e.__class__.__name__, e))
 
     def help_add_hr(self):
         # HoldingRegisterDatapoint('Voltage', 1, 0x2000, 2, datetime.timedelta(seconds=10), 'Pub/Voltage', None, None),
-        self.__println("Usage: add <Label> <Unit> <Address> <Count> <ScanRate>")
+        self.__println("Usage: add_hr <Label> <Unit> <Address> <Count> <ScanRate>")
-        self.__println("           <ReadTopic> <WriteTopic> <FeedbackTopic>")
+        self.__println("              <ReadTopic> <WriteTopic> <FeedbackTopic>")
+        self.__println("              <Converter>")
         self.__println("Adds a holding register")
         self.__println("DO NOT FORGET TO SAVE AFTERWARDS!")
         self.__println("---------------------------------------------------------------------")
@@ -107,15 +97,53 @@ class CmdInterpreter(cmd.Cmd):
         self.__println("<WriteTopic>                 Topic to be subscribe to receive data to be")
         self.__println("                             written")
         self.__println("<FeedbackTopic>              Topic to publish feedback after a write process,")
-        self.__println("")
+        self.__println("<Converter>                  Converter for data")
-        self.__println("For read items the <ScanRate> must be non-zero, a <ReadTopic> must be set and")
-        self.__println("<WriteTopic> and <FeedbackTopic> must be <None>.")
-        self.__println("For write items the <ScanRate> must be zero, <ReadTopic> must be <None> and ")
-        self.__println("<WriteTopic> and <FeedbackTopic> must be set.")
 
+    
+    def do_add_coil(self, arg):
+        try:
+            (label, unit, address, scanrate, readTopic, writeTopic, feedbackTopic) = self.splitterRe.split(arg)
+            self.__println("Label:         {0}".format(label))
+            self.__println("Unit:          {0}".format(unit))
+            self.__println("Address:       {0}".format(address))
+            self.__println("ScanRate:      {0}".format(scanrate))
+            self.__println("ReadTopic:     {0}".format(readTopic))
+            self.__println("WriteTopic:    {0}".format(writeTopic))
+            self.__println("FeedbackTopic: {0}".format(feedbackTopic))
+
+            if readTopic == 'None':
+                readTopic = None
+            if writeTopic == 'None':
+                writeTopic = None
+            if feedbackTopic == 'None':
+                feedbackTopic = None
+            unit = parseIntArbitraryBase(unit)
+            address = parseIntArbitraryBase(address)
+            scanrate = float(scanrate)
+            r = RegisterDatapoint.CoilDatapoint(label, unit, address, datetime.timedelta(seconds=scanrate), readTopic, writeTopic, feedbackTopic)
+            self.registers.append(r)
+        except ValueError as e:
+            self.__println("ERROR: {0!s}, {1!s}".format(e.__class__.__name__, e))
+
+    def help_add_coil(self):
+        self.__println("Usage: add_coil <Label> <Unit> <Address> <ScanRate>")
+        self.__println("                <ReadTopic> <WriteTopic> <FeedbackTopic>")
+        self.__println("Adds a coil")
+        self.__println("DO NOT FORGET TO SAVE AFTERWARDS!")
+        self.__println("---------------------------------------------------------------------")
+        self.__println("<Label>                      Descriptive label")
+        self.__println("<Unit>                       Modbus address of the device")
+        self.__println("<Address>                    Register address within the device")
+        self.__println("<ScanRate>                   Scanrate in seconds (float), for write datapoints")
+        self.__println("                             set to zero (0)")
+        self.__println("<ReadTopic>                  Topic to publish read data")
+        self.__println("<WriteTopic>                 Topic to be subscribe to receive data to be")
+        self.__println("                             written")
+        self.__println("<FeedbackTopic>              Topic to publish feedback after a write process,")
+    
     def do_add_ir(self, arg):
         try:
-            (label, unit, address, count, scanrate, updateOnly, readTopic) = self.splitterRe.split(arg)
+            (label, unit, address, count, scanrate, updateOnly, readTopic, converter) = self.splitterRe.split(arg)
             self.__println("Label:         {0}".format(label))
             self.__println("Unit:          {0}".format(unit))
             self.__println("Address:       {0}".format(address))
@@ -123,9 +151,12 @@ class CmdInterpreter(cmd.Cmd):
             self.__println("ScanRate:      {0}".format(scanrate))
             self.__println("UpdateOnly:    {0}".format(updateOnly))
             self.__println("ReadTopic:     {0}".format(readTopic))
+            self.__println("Converter:     {0}".format(converter))
 
             if readTopic == 'None':
                 readTopic = None
+            if converter == 'None':
+                converter = None
             if updateOnly in ['true', 'True', 'yes', 'Yes']:
                 updateOnly = True
             elif updateOnly in ['false', 'False', 'no', 'No']:
@@ -136,16 +167,14 @@ class CmdInterpreter(cmd.Cmd):
             address = parseIntArbitraryBase(address)
             count = parseIntArbitraryBase(count)
             scanrate = float(scanrate)
-            if scanrate == 0.0:
+            r = RegisterDatapoint.InputRegisterDatapoint(label, unit, address, count, datetime.timedelta(seconds=scanrate), updateOnly, readTopic, converter)
-                raise CmdInterpreterException('scanRate must not be zero')
-            r = RegisterDatapoint.InputRegisterDatapoint(label, unit, address, count, datetime.timedelta(seconds=scanrate), updateOnly, readTopic)
             self.registers.append(r)
         except ValueError as e:
             self.__println("ERROR: {0!s}, {1!s}".format(e.__class__.__name__, e))
 
     def help_add_ir(self):
-        self.__println("Usage: add <Label> <Unit> <Address> <Count> <ScanRate>")
+        self.__println("Usage: add_ir <Label> <Unit> <Address> <Count> <ScanRate>")
-        self.__println("           <UpdateOnly> <ReadTopic>")
+        self.__println("              <UpdateOnly> <ReadTopic> <Converter>")
         self.__println("Adds an input register")
         self.__println("DO NOT FORGET TO SAVE AFTERWARDS!")
         self.__println("---------------------------------------------------------------------")
@@ -156,10 +185,11 @@ class CmdInterpreter(cmd.Cmd):
         self.__println("<ScanRate>                   Scanrate in seconds (float)")
         self.__println("<UpdateOnly>                 Publish only when value has changed")
         self.__println("<ReadTopic>                  Topic to publish read data")
+        self.__println("<Converter>                  Converter for data")
 
     def do_add_di(self, arg):
         try:
-            (label, unit, address, count, scanrate, updateOnly, readTopic) = self.splitterRe.split(arg)
+            (label, unit, address, count, scanrate, updateOnly, readTopic, bitCount) = self.splitterRe.split(arg)
             self.__println("Label:         {0}".format(label))
             self.__println("Unit:          {0}".format(unit))
             self.__println("Address:       {0}".format(address))
@@ -167,6 +197,7 @@ class CmdInterpreter(cmd.Cmd):
             self.__println("ScanRate:      {0}".format(scanrate))
             self.__println("UpdateOnly:    {0}".format(updateOnly))
             self.__println("ReadTopic:     {0}".format(readTopic))
+            self.__println("BitCount:      {0}".format(bitCount))
 
             if readTopic == 'None':
                 readTopic = None
@@ -180,16 +211,15 @@ class CmdInterpreter(cmd.Cmd):
             address = parseIntArbitraryBase(address)
             count = parseIntArbitraryBase(count)
             scanrate = float(scanrate)
-            if scanrate == 0.0:
+            bitCount = int(bitCount)
-                raise CmdInterpreterException('scanRate must not be zero')
+            r = RegisterDatapoint.DiscreteInputDatapoint(label, unit, address, count, datetime.timedelta(seconds=scanrate), updateOnly, readTopic, None, bitCount)
-            r = RegisterDatapoint.DiscreteInputDatapoint(label, unit, address, count, datetime.timedelta(seconds=scanrate), updateOnly, readTopic)
             self.registers.append(r)
         except ValueError as e:
             self.__println("ERROR: {0!s}, {1!s}".format(e.__class__.__name__, e))
 
     def help_add_di(self):
-        self.__println("Usage: add <Label> <Unit> <Address> <Count> <ScanRate>")
+        self.__println("Usage: add_di <Label> <Unit> <Address> <Count> <ScanRate>")
-        self.__println("           <UpdateOnly> <ReadTopic>")
+        self.__println("              <UpdateOnly> <ReadTopic> <bitCount>")
         self.__println("Adds a discrete input")
         self.__println("DO NOT FORGET TO SAVE AFTERWARDS!")
         self.__println("---------------------------------------------------------------------")
@@ -200,6 +230,7 @@ class CmdInterpreter(cmd.Cmd):
         self.__println("<ScanRate>                   Scanrate in seconds (float)")
         self.__println("<UpdateOnly>                 Publish only when value has changed")
         self.__println("<ReadTopic>                  Topic to publish read data")
+        self.__println("<BitCount>                   Number of bit to be considered")
 
     def do_list(self, arg):
         for i, r in enumerate(self.registers):
@@ -307,45 +338,35 @@ class CmdInterpreter(cmd.Cmd):
         self.__println("DO NOT FORGET TO SAVE AFTERWARDS!")
 
     def do_save(self, arg):
-        with open(self.config.registerFile, 'wb') as f:
+        RegisterDatapoint.saveRegisterList(self.registers, self.config.registerFile)
-            pickle.dump(self.registers, f)
 
     def help_save(self):
         self.__println("Usage: save")
         self.__println("Saves a modified register list into the register file.")
 
     def do_load(self, arg):
-        registers = None
-        with open(self.config.registerFile, 'rb') as f:
-            registers = pickle.load(f)
         try:
-            RegisterDatapoint.checkRegisterList(registers)
+            registers = RegisterDatapoint.loadRegisterList(self.config.registerFile)
             self.registers = registers
-        except ValueError as e:
+        except Exception as e:
             self.__println("Unable to load register list: {0!s}".format(e))
 
     def help_load(self):
         self.__println("Usage: load")
         self.__println("Reload the register file, overwrite all unsaved changes.")
 
-    #def do_shutdown(self, arg):
-    #    sys.exit()
-
-    #def help_shutdown(self):
-    #    self.__println("Usage: shutdown")
-    #    self.__println("Shuts down the application")
-
 
 
 class CmdHandle(socketserver.StreamRequestHandler):
     def handle(self):
+        logger = logging.getLogger('CmdHandle')
         cmd = CmdInterpreter(io.TextIOWrapper(self.rfile), io.TextIOWrapper(self.wfile), self.server.userData.config, 
                              self.server.userData.notifier, self.server.userData.registers)
         try:
             cmd.cmdloop()
-            print("Cmd handle terminated")
+            logger.info("Cmd handle terminated")
         except ConnectionAbortedError as e:
-            print("Cmd handle externally interrupted")
+            logger.info("Cmd handle externally interrupted")
 
 class MyThreadingTCPServer(socketserver.ThreadingTCPServer):
     def __init__(self, host, handler, userData):

src/Config.py

@@ -9,7 +9,7 @@ class Config(object):
         self.mqttPassword = ''
         self.cmdAddress = '127.0.0.1'
         self.cmdPort = 9999
-        self.registerFile = 'registers.pkl'
+        self.registerFile = 'registers.json'
         self.serialPort = '/dev/ttyAMA0'
         self.serialBaudRate = 9600
         self.interCommDelay = 0.025

src/Converters.py

@@ -0,0 +1,18 @@
+# in:  from Modbus to MQTT, input is a list of 16bit integers, output shall be the desired format 
+#      to be sent in the MQTT message
+# out: from MQTT to Modbus, input is the format received from MQTT, output shall be a list of 
+#      16bit integers to be written to the Modbus slave
+
+from struct import pack, unpack
+
+
+Converters = {
+    "dht20TOFloat": {
+        "in": lambda x : float(x[0]) / 10.0,
+        "out": None
+    },
+    "uint32": {
+        "in": lambda x : unpack('L', pack('HH', *x))[0],
+        "out": lambda x : unpack('HH', pack('L', int(x)))
+    }
+}

src/MqttProcessor.py

@@ -34,7 +34,7 @@ class MqttProcessor(threading.Thread, AbstractNotificationReceiver):
     def __processUpdatedRegisters(self, force=False):
         self.logger.debug("MqttProcessor.__updateSubscriptions")
 
-        subscribeTopics = [ r.subscribeTopic for r in self.registers if r.subscribeTopic]
+        subscribeTopics = [ r.subscribeTopic for r in self.registers if hasattr(r,'subscribeTopic') and r.subscribeTopic]
         self.logger.debug("Topics: {0!s}".format(subscribeTopics))
 
         for subscribeTopic in subscribeTopics:
@@ -49,7 +49,7 @@ class MqttProcessor(threading.Thread, AbstractNotificationReceiver):
                 self.client.unsubscribe(subscription)
                 self.subscriptions.remove(subscription)
 
-        self.topicRegisterMap = { r.subscribeTopic: r for r in self.registers if r.subscribeTopic }
+        self.topicRegisterMap = { r.subscribeTopic: r for r in self.registers if hasattr(r,'subscribeTopic') and r.subscribeTopic }
 
     def receiveNotification(self, arg):
         self.logger.info("MqttProcessor:registersChanged")

src/MySSLThreadingTCPServer.py

@@ -1,28 +0,0 @@
-from socketserver import TCPServer, ThreadingMixIn
-import ssl
-
-class MySSL_TCPServer(TCPServer):
-    def __init__(self,
-                 server_address,
-                 RequestHandlerClass,
-                 certfile,
-                 keyfile,
-                 ssl_version=ssl.PROTOCOL_TLSv1,
-                 bind_and_activate=True):
-        TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate)
-        self.certfile = certfile
-        self.keyfile = keyfile
-        self.ssl_version = ssl_version
-
-    def get_request(self):
-        newsocket, fromaddr = self.socket.accept()
-        connstream = ssl.wrap_socket(newsocket,
-                                 server_side=True,
-                                 certfile = self.certfile,
-                                 keyfile = self.keyfile,
-                                 ssl_version = self.ssl_version)
-        return connstream, fromaddr
-
-class MySSL_ThreadingTCPServer(ThreadingMixIn, MySSL_TCPServer): pass
-
-  

src/RegisterDatapoint.py

@@ -3,18 +3,23 @@ from pymodbus.pdu import ExceptionResponse
 from pymodbus.exceptions import ModbusIOException
 import MqttProcessor
 import logging
-import pickle
+import json
-
+import Converters
 
 class DatapointException(Exception): pass
 
 class AbstractModbusDatapoint(object):
-    def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None):
+    def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None, converter=None):
+        self.argList = ['label', 'unit', 'address', 'count', 'scanRate', 'converter']
         self.label = label
         self.unit = unit
         self.address = address
         self.count = count
-        self.scanRate = scanRate
+        self.converter = converter
+        if type(scanRate) == float:
+            self.scanRate = datetime.timedelta(seconds=scanRate)
+        else:
+            self.scanRate = scanRate
         self.type = 'abstract data point'
         self.enqueued = False
         self.lastContact = None
@@ -27,19 +32,27 @@ class AbstractModbusDatapoint(object):
 
     def __str__(self):
         return ("{0}, {1}: unit: {2},  address: {3}, count: {4}, scanRate: {5}, "
-                "enqueued: {6}, lastContact: {7}, errorCount: {8}, processCount: {9}"
+                "enqueued: {6}, lastContact: {7}, errorCount: {8}, processCount: {9}, "
+                "converter: {10}"
                 .format(self.type, self.label, self.unit, self.address, self.count,
                         self.scanRate, self.enqueued, self.lastContact,
-                        self.errorCount, self.processCount))
+                        self.errorCount, self.processCount, self.converter))
+
+    def jsonify(self):
+        return {'type':self.__class__.__name__, 
+                'args': { k: getattr(self, k) for k in self.argList }
+               }
 
     def process(self, client):
         raise NotImplementedError
 
 
+
 class HoldingRegisterDatapoint(AbstractModbusDatapoint):
     def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None, 
-                 publishTopic=None, subscribeTopic=None, feedbackTopic=None):
+                 publishTopic=None, subscribeTopic=None, feedbackTopic=None, converter=None):
-        super().__init__(label, unit, address, count, scanRate)
+        super().__init__(label, unit, address, count, scanRate, converter)
+        self.argList = self.argList + ['publishTopic', 'subscribeTopic', 'feedbackTopic']
         self.publishTopic = publishTopic
         self.subscribeTopic = subscribeTopic
         self.feedbackTopic = feedbackTopic
@@ -53,14 +66,29 @@ class HoldingRegisterDatapoint(AbstractModbusDatapoint):
                         self.writeRequestValue))
 
     def process(self, client, pubQueue):
-        self.logger = logging.getLogger('HoldingRegisterDatapoint')
+        logger = logging.getLogger('HoldingRegisterDatapoint')
         if self.writeRequestValue:
             # perform write operation
-            self.logger.debug("Holding register, perform write operation")
+            logger.debug("Holding register, perform write operation")
+            self.processCount += 1
+            values = None
+            logger.debug("{0}: raw: {1!s}".format(self.label, self.writeRequestValue))
+            if self.converter and Converters.Converters[self.converter]['out']:
+                try:
+                    values = Converters.Converters[self.converter]['out'](self.writeRequestValue)
+                    logger.debug("{0}: converted: {1!s}".format(self.label, values))
+                except Exception as e:
+                    raise DatapointException("Exception caught when trying to converter modbus data: {0!s}".format(e))
+            else:
+                values = [int(self.writeRequestValue)]
+            result = client.write_registers(address=self.address,
+                                           unit=self.unit,
+                                           values=values)
+            logger.debug("Write result: {0!s}".format(result))                
             self.writeRequestValue = None
         else:
             # perform read operation
-            self.logger.debug("Holding register, perform read operation")
+            logger.debug("Holding register, perform read operation")
             self.processCount += 1
             result = client.read_holding_registers(address=self.address, 
                                                    count=self.count, 
@@ -68,17 +96,87 @@ class HoldingRegisterDatapoint(AbstractModbusDatapoint):
             if type(result) in [ExceptionResponse, ModbusIOException]:
                 self.errorCount += 1
                 raise DatapointException(result)
-            self.logger.debug("{0}: {1!s}".format(self.label, result.registers))
+            logger.debug("{0}: {1!s}".format(self.label, result.registers))
-            pubQueue.put(MqttProcessor.PublishItem(self.publishTopic, str(result.registers)))
+            value = None
+            if self.converter and Converters.Converters[self.converter]['in']:
+                try:
+                    value = Converters.Converters[self.converter]['in'](result.registers)
+                    logger.debug("{0}: converted: {1!s}".format(self.label, value))
+                except Exception as e:
+                    raise DatapointException("Exception caught when trying to converter modbus data: {0!s}".format(e))
+            else:
+                value = result.registers
+            if self.publishTopic:
+                pubQueue.put(MqttProcessor.PublishItem(self.publishTopic, str(value)))
             self.lastContact = datetime.datetime.now()
     
     def onMessage(self, value):
         self.writeRequestValue = value
 
 
+class CoilDatapoint(AbstractModbusDatapoint):
+    def __init__(self, label=None, unit=None, address=None, scanRate=None, publishTopic=None, subscribeTopic=None,
+                 feedbackTopic=None):
+        super().__init__(label, unit, address, 1, scanRate, None)
+        self.argList = ['label', 'unit','address','scanRate','publishTopic', 'subscribeTopic', 'feedbackTopic']
+        self.publishTopic = publishTopic
+        self.subscribeTopic = subscribeTopic
+        self.feedbackTopic = feedbackTopic
+        self.writeRequestValue = None
+        self.type = 'coil'
+
+    def __str__(self):
+        return ("{0}, {1}: unit: {2},  address: {3}, scanRate: {4}, "
+                "enqueued: {5}, lastContact: {6}, errorCount: {7}, processCount: {8}, "
+                "publishTopic: {9}, subscribeTopic: {10}, feedbackTopic: {11}"
+                .format(self.type, self.label, self.unit, self.address,
+                        self.scanRate, self.enqueued, self.lastContact,
+                        self.errorCount, self.processCount, 
+                        self.publishTopic, self.subscribeTopic, self.feedbackTopic))
+
+    def onMessage(self, value):
+        self.writeRequestValue = value.decode()
+
+    def process(self, client, pubQueue):
+        logger = logging.getLogger('CoilDatapoint')
+        if self.writeRequestValue:
+            # perform write operation
+            logger.debug("Coil, perform write operation")
+            self.processCount += 1
+            logger.debug("{0}: raw: {1!s}".format(self.label, self.writeRequestValue))
+            value=None
+            if self.writeRequestValue in ['true', 'True', 'yes', 'Yes', 'On', 'on']:
+                value = True
+            elif self.writeRequestValue in ['false', 'False', 'no', 'No', 'Off', 'off']:
+                value = False
+            else:
+                self.writeRequestValue = None
+                raise DatapointException('illegal value {0!s} for coil write'.format(self.writeRequestValue))
+            result = client.write_coil(address=self.address,
+                                       unit=self.unit,
+                                       value=value)
+            logger.debug("Write result: {0!s}".format(result))                
+            self.writeRequestValue = None
+        else:
+            # perform read operation
+            logger.debug("Coil, perform read operation")
+            self.processCount += 1
+            result = client.read_coils(address=self.address, 
+                                       unit=self.unit)
+            if type(result) in [ExceptionResponse, ModbusIOException]:
+                self.errorCount += 1
+                raise DatapointException(result)
+            logger.debug("{0}: {1!s}".format(self.label, result.getBit(0)))
+            value = result.getBit(0)
+            if self.publishTopic:
+                pubQueue.put(MqttProcessor.PublishItem(self.publishTopic, str(value)))
+            self.lastContact = datetime.datetime.now()
+
+
 class ReadOnlyDatapoint(AbstractModbusDatapoint):
-    def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None, updateOnly=None, publishTopic=None):
+    def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None, updateOnly=None, publishTopic=None, converter=None):
-        super().__init__(label, unit, address, count, scanRate)
+        super().__init__(label, unit, address, count, scanRate, converter)
+        self.argList = self.argList + ['updateOnly', 'publishTopic']
         self.updateOnly = updateOnly
         self.lastValue = None
         self.publishTopic = publishTopic
@@ -91,14 +189,15 @@ class ReadOnlyDatapoint(AbstractModbusDatapoint):
 
 
 class InputRegisterDatapoint(ReadOnlyDatapoint):
-    def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None, updateOnly=None, publishTopic=None):
+    def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None, updateOnly=None, 
-        super().__init__(label, unit, address, count, scanRate, updateOnly, publishTopic)
+                 publishTopic=None, converter=None):
+        super().__init__(label, unit, address, count, scanRate, updateOnly, publishTopic, converter)
         self.type = 'input register'
 
     def process(self, client, pubQueue):
-        self.logger = logging.getLogger('InputRegisterDatapoint')
+        logger = logging.getLogger('InputRegisterDatapoint')
         # perform read operation
-        self.logger.debug("Input register, perform read operation")
+        logger.debug("Input register, perform read operation")
         self.processCount += 1
         result = client.read_input_registers(address=self.address,
                                              count=self.count,
@@ -108,20 +207,38 @@ class InputRegisterDatapoint(ReadOnlyDatapoint):
             raise DatapointException(result)
         if not self.updateOnly or (result.registers != self.lastValue):
             self.lastValue = result.registers
-            self.logger.debug("{0}: {1!s}".format(self.label, result.registers))        
+            logger.debug("{0}: raw: {1!s}".format(self.label, result.registers))
-            pubQueue.put(MqttProcessor.PublishItem(self.publishTopic, str(result.registers)))
+            value = None
+            if self.converter and Converters.Converters[self.converter]['in']:
+                try:
+                    value = Converters.Converters[self.converter]['in'](result.registers)
+                    logger.debug("{0}: converted: {1!s}".format(self.label, value))
+                except Exception as e:
+                    raise DatapointException("Exception caught when trying to converter modbus data: {0!s}".format(e))
+            else:
+                value = result.registers
+            if self.publishTopic:
+                pubQueue.put(MqttProcessor.PublishItem(self.publishTopic, str(value)))
         self.lastContact = datetime.datetime.now()
 
 
 class DiscreteInputDatapoint(ReadOnlyDatapoint):
-    def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None, updateOnly=None, publishTopic=None):
+    def __init__(self, label=None, unit=None, address=None, count=None, scanRate=None, updateOnly=None, 
-        super().__init__(label, unit, address, count, scanRate, updateOnly, publishTopic)
+                 publishTopic=None, converter=None, bitCount=8):
+        super().__init__(label, unit, address, count, scanRate, updateOnly, publishTopic, converter)
+        self.argList = self.argList + ['bitCount']
         self.type = 'discrete input'
+        self.bitCount = bitCount
+        self.lastValues = [None] * self.bitCount
+
+    def __str__(self):
+        return ("[{0!s}, bitCount: {1}"
+                .format(super().__str__(), self.bitCount))
 
     def process(self, client, pubQueue):
-        self.logger = logging.getLogger('DiscreteInputDatapoint')
+        logger = logging.getLogger('DiscreteInputDatapoint')
         # perform read operation
-        self.logger.debug("Discrete input, perform read operation")
+        logger.debug("Discrete input, perform read operation")
         self.processCount += 1
         result = client.read_discrete_inputs(address=self.address,
                                              count=self.count,
@@ -129,47 +246,46 @@ class DiscreteInputDatapoint(ReadOnlyDatapoint):
         if type(result) in [ExceptionResponse, ModbusIOException]:
             self.errorCount += 1
             raise DatapointException(result)
-        if not self.updateOnly or (result.bits != self.lastValue):
+        logger.debug("{0}: raw: {1!s}".format(self.label, result.bits))
-            self.lastValue = result.bits
+        for i in range(self.bitCount):
-            self.logger.debug("{0}: {1!s}".format(self.label, result.bits))        
+            if not self.updateOnly or (result.getBit(i) != self.lastValues[i]):
-            pubQueue.put(MqttProcessor.PublishItem(self.publishTopic, str(result.bits)))
+                self.lastValues[i] = result.getBit(i)
+                logger.debug("{0}, {1}: changed: {2!s}".format(self.label, i, result.getBit(i)))
+                if self.publishTopic:
+                    pubQueue.put(MqttProcessor.PublishItem("{0}/{1}".format(self.publishTopic, i), str(result.getBit(i))))
         self.lastContact = datetime.datetime.now()
 
 
 
-def loadRegisterList(registerList):
-    # Load, check and auto-update registers file
 
-    with open(registerList, 'rb') as f:
+class JsonifyEncoder(json.JSONEncoder):
-        datapoints = pickle.load(f)
+    def default(self, o):
-
+        res = None
-    checkRegisterList(datapoints)
+        try:
-
+            res = o.jsonify()
-    newDatapoints = []
+        except (TypeError, AttributeError):
-    for dp in datapoints:
+            if type(o) == datetime.timedelta:
-        ndp = type(dp)()
+                res = o.total_seconds()
-        for k,v in dp.__dict__.items():
+            else:
-            ndp.__dict__[k] = v
+                res = super().default(o)
-        newDatapoints.append(ndp)
+        return res
-        logging.getLogger('loadRegisterList').debug("Datapoint loaded: {0!s}".format(ndp))
-
-    checkRegisterList(newDatapoints, reset=True)
-
-    with open(registerList, 'wb') as f:
-        pickle.dump(newDatapoints, f)
-
-    return newDatapoints
-
-
-def checkRegisterList(registers, reset=False):
-    for r in registers:
-        if not isinstance(r, AbstractModbusDatapoint):
-            raise ValueError('Entry in register list {0!s} is not derived from class AbstractModbusDatapoint'.format(r))        
-        else:
-            if reset:
-                r.errorCount = 0
-                r.processCount = 0
-                r.enqueued = False
 
+def datapointObjectHook(j):
+    if type(j) == dict and 'type' in j and 'args' in j:
+        klass = eval(j['type'])
+        o = klass(**j['args'])
+        return o
+    else:
+        return j
 
+def saveRegisterList(registerList, registerListFile):
+    js = json.dumps(registerList, cls=JsonifyEncoder, sort_keys=True, indent=4)
+    with open(registerListFile, 'w') as f:
+        f.write(js)
+    
+def loadRegisterList(registerListFile):
+    with open(registerListFile, 'r') as f:
+        js = f.read()
+        registerList = json.loads(js, object_hook=datapointObjectHook)
+        return registerList
 

src/loadRegisterFile.py

@@ -0,0 +1,6 @@
+import RegisterDatapoint
+
+registers = RegisterDatapoint.loadRegisterList('registers.json')
+
+for r in registers:
+    print("{0!s}".format(r))

src/registers.json

@@ -0,0 +1,122 @@
+[
+    {
+        "args": {
+            "address": 1,
+            "converter": "dht20TOFloat",
+            "count": 1,
+            "label": "Temperature",
+            "publishTopic": "Pub/Temperature",
+            "scanRate": 10.0,
+            "unit": 5,
+            "updateOnly": false
+        },
+        "type": "InputRegisterDatapoint"
+    },
+    {
+        "args": {
+            "address": 2,
+            "converter": "dht20TOFloat",
+            "count": 1,
+            "label": "Humidity",
+            "publishTopic": "Pub/Humidity",
+            "scanRate": null,
+            "unit": 5,
+            "updateOnly": false
+        },
+        "type": "InputRegisterDatapoint"
+    },
+    {
+        "args": {
+            "address": 0,
+            "bitCount": 8,
+            "converter": null,
+            "count": 1,
+            "label": "Switches",
+            "publishTopic": "Pub/Switches",
+            "scanRate": null,
+            "unit": 4,
+            "updateOnly": false
+        },
+        "type": "DiscreteInputDatapoint"
+    },
+    {
+        "args": {
+            "address": 40010,
+            "converter": "uint32",
+            "count": 2,
+            "feedbackTopic": "FB/Counter1",
+            "label": "Counter1",
+            "publishTopic": "Pub/Counter1",
+            "scanRate": 1.0,
+            "subscribeTopic": "Sub/Counter1",
+            "unit": 4
+        },
+        "type": "HoldingRegisterDatapoint"
+    },
+    {
+        "args": {
+            "address": 40012,
+            "converter": "uint32",
+            "count": 2,
+            "feedbackTopic": "FB/Counter2",
+            "label": "Counter2",
+            "publishTopic": "Pub/Counter2",
+            "scanRate": null,
+            "subscribeTopic": "Pub/Counter2",
+            "unit": 4
+        },
+        "type": "HoldingRegisterDatapoint"
+    },
+    {
+        "args": {
+            "address": 40014,
+            "converter": "uint32",
+            "count": 2,
+            "feedbackTopic": "FB/Counter3",
+            "label": "Counter3",
+            "publishTopic": "Pub/Counter3",
+            "scanRate": null,
+            "subscribeTopic": "FB/Counter3",
+            "unit": 4
+        },
+        "type": "HoldingRegisterDatapoint"
+    },
+    {
+        "args": {
+            "address": 40016,
+            "converter": "uint32",
+            "count": 2,
+            "feedbackTopic": "FB/Counter4",
+            "label": "Counter4",
+            "publishTopic": "Pub/Counter4",
+            "scanRate": 1.0,
+            "subscribeTopic": "Sub/Counter4",
+            "unit": 4
+        },
+        "type": "HoldingRegisterDatapoint"
+    },
+    {
+        "args": {
+            "address": 0,
+            "feedbackTopic": "FB/Coil1",
+            "label": "Coil1",
+            "publishTopic": "Pub/Coil1",
+            "scanRate": 1.0,
+            "subscribeTopic": "Sub/Coil1",
+            "unit": 4
+        },
+        "type": "CoilDatapoint"
+    },
+    {
+        "args": {
+            "address": 1,
+            "feedbackTopic": "FB/Coil2",
+            "label": "Coil2",
+            "publishTopic": "Pub/Coil2",
+            "scanRate": 1.0,
+            "subscribeTopic": "Sub/Coil2",
+            "unit": 4
+        },
+        "type": "CoilDatapoint"
+    }
+]

src/updateRegisterFile.py

@@ -1,24 +1,24 @@
 import datetime
 import RegisterDatapoint
 import pickle
-
+import json
 
 
 with open('registers.pkl', 'rb') as f:
     datapoints = pickle.load(f)
 
-RegisterDatapoint.checkRegisterList(datapoints, reset=True)
-
 newDatapoints = []
 for dp in datapoints:
     ndp = type(dp)()
     for k,v in dp.__dict__.items():
-        ndp.__dict__[k] = v
+        if k != 'logger':
+            ndp.__dict__[k] = v
     newDatapoints.append(ndp)
 
-RegisterDatapoint.checkRegisterList(newDatapoints, reset=True)
 
-with open('registers.pkl', 'wb') as f:
-    pickle.dump(newDatapoints, f)
 
+js = json.dumps(newDatapoints, cls=RegisterDatapoint.JsonifyEncoder, sort_keys=True, indent=4)
+print(js)
     
+
+RegisterDatapoint.saveRegisterList(newDatapoints, 'registers.json')